RU2776910C1 - Entropy encoding of differences in motion vectors - Google Patents

Abstract

FIELD: video encoding.

SUBSTANCE: invention relates to means for video encoding. For the horizontal and vertical components of each of the motion vector differences, a truncated unary code and exponential Golomb code are obtained from the data stream. The truncated unary code is decoded using context-adaptive binary entropy decoding with one context per bin position of the truncated unary code. Wherein the context is shared by the horizontal and vertical components of the difference of motion vectors. The exponential Golomb code is decoded using the constant equiprobability bypass mode to obtain the horizontal and vertical components of the motion vector difference. The video is reconstructed based on the horizontal and vertical components of the motion vector differences.

EFFECT: improving the efficiency of video encoding.

28 cl, 22 dwg, 12 tbl

Description

The present invention relates to an entropy coding principle for encoding video data.

Many video codecs are known in the art. Typically, these codecs reduce the amount of data required to represent the video content, i.e. they compress data. In the context of video coding, it is known that video data compression is advantageously achieved by successively applying different coding techniques: motion-compensated prediction is used to predict the content of an image. The motion vectors determined by motion-compensated prediction, as well as the prediction residual, are entropy lossless encoded. To further reduce the amount of data, the motion vectors themselves are subject to prediction, so that only the motion vector differences representing the residual of the motion vector prediction need to be entropy encoded. In H.264, for example, the procedure just outlined is applied to convey motion vector difference information. In particular, the motion vector differences are binarized into rows of bins (containers) corresponding to a combination of a truncated unary code and, from a certain cutoff value, an exponential Golomb code. While the bins of the Exponential Golomb code are easily encoded using the equiprobable traversal mode with a fixed probability of 0.5, multiple contexts are provided for the first bins. The cutoff value is chosen to be nine. Therefore, a large number of contexts are provided for encoding motion vector differences.

Providing a large number of contexts, however, not only increases the complexity of coding, but can also have a negative impact on coding efficiency: if a context is visited very infrequently, probabilistic adaptation is not performed efficiently, i.e. adapting the probability estimate associated with the respective context at the time of the entropy encoding cause. Therefore, improperly applied probability estimates estimate the actual symbol statistics. In addition, if multiple contexts are provided for a certain binarization bin, the choice between them may require inspection of the values of neighboring bins/syntax elements, the need for which may prevent the decoding process from being performed. On the other hand, if the number of contexts is provided too small, bins with highly variable actual symbol statistics are grouped together in one context, and hence the probability score associated with that context does not efficiently encode the bins associated with it.

There is a current need to further improve the coding efficiency of motion vector difference entropy coding.

Therefore, it is an object of the present invention to provide such an encoding principle.

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

The main solution of the present invention is that the coding efficiency of entropy coding of motion vector differences can be further improved by reducing the cutoff value up to which the truncated unary code is used to binarize the motion vector differences to two, so that there are only two bin positions of the truncated unary code , and if the order of one is used for the exponential Golomb code to binarize the motion vector differences from the cutoff value, and if, additionally, exactly one context is provided for the two bin positions of the truncated unary code, respectively, so that it is not necessary to choose a context based on bin or syntax element values of adjacent image blocks, and overly fine classification of bins at those bin positions into contexts is avoided so that probabilistic adaptation works properly, and if the same contexts are used for horizontal and vertical constituents, thereby further reducing the negative effects of subdividing the context too finely.

In addition, it has been found that the just-mentioned motion vector difference entropy encoding settings are particularly valuable when combined with improved motion vector prediction techniques and reducing the required number of motion vector differences to be transmitted. For example, multiple motion vector predictors may be provided to obtain an ordered list of motion vector predictors, and an index of this list of motion vector predictors may be used to determine the actual motion vector predictor whose prediction residual is represented by the considered motion vector difference. Although the list index used information should be outputted from the data stream at the decoding side, the overall motion vector prediction quality is improved, and therefore the magnitude of the motion vector differences is further reduced, so that the overall encoding efficiency is further improved, and the reduction of the cutoff value and the overall use of the context for the horizontal and vertical components of the motion vector differences correspond to such improved motion vector prediction. On the other hand, merging may be used to reduce the number of motion vector differences to be transmitted in the data stream: to this end, merging information may be transmitted in the data stream signaling decoder blocks to subdivide blocks that are grouped into a block group. The motion vector differences can then be transmitted in the data stream in units of these combined groups instead of individual blocks, thus reducing the number of motion vector differences that need to be transmitted. Since this block clustering reduces cross-correlation between adjacent motion vector differences, the exception just mentioned of providing multiple contexts for a single bin position prevents the entropy coding scheme from being very finely classified into contexts depending on neighboring motion vector differences. Instead, the merge principle already uses the cross-correlation between the motion vector differences of adjacent blocks, and hence one context for one bin position is sufficient - the same for the horizontal and vertical components.

Preferred embodiments of the present application are described below with respect to the figures, among which:

fig. 1 is a block diagram of an encoder according to an embodiment;

fig. 2a-2c schematically depict different subdivisions of a bin array, such as an image, into blocks;

fig. 3 is a block diagram of a decoder according to an embodiment;

fig. 4 shows a block diagram of an encoder according to an embodiment in more detail;

fig. 5 shows a block diagram of a decoder according to an embodiment in more detail;

fig. 6 schematically illustrates the transformation of a block from the spatial domain to the spectral domain, the resulting transformation block, and its retransformation;

fig. 7 is a block diagram of an encoder according to an embodiment;

fig. 8 is a block diagram of a decoder suitable for decoding a bitstream generated by the encoder of FIG. 8 according to an embodiment;

fig. 9 is a schematic diagram illustrating a data packet with multiplexed partial bitstreams according to an embodiment;

fig. 10 is a schematic diagram illustrating an alternative slicing data packet using fixed size segments, according to another embodiment;

fig. 11 shows a decoder supporting mode switching according to an embodiment;

fig. 12 shows a decoder supporting mode switching according to another embodiment;

fig. 13 shows an encoder corresponding to the decoder of FIG. 11 according to an embodiment;

fig. 14 shows an encoder corresponding to the decoder of FIG. 12 according to an embodiment;

fig. 15 shows the mapping of pStateCtx and fullCtxState/256**E**;

fig. 16 shows a decoder according to an embodiment of the present invention; and

fig. 17 depicts an encoder according to an embodiment of the present invention.

Fig. 18 schematically depicts motion vector difference binarization according to an embodiment of the present invention;

fig. 19 schematically illustrates the principle of merging according to an embodiment; and

fig. 20 schematically illustrates a motion vector prediction scheme according to an embodiment.

It is noted that when describing the figures, elements that occur in several of these figures are designated by the same reference position in each of these figures, and repeated description of these elements is excluded, with regard to functionality, in order to avoid unnecessary repetition. However, functionality and descriptions provided with respect to one figure also apply to other figures, unless explicitly stated to the contrary.

Embodiments of the general principle of video coding are first described below with respect to FIG. 1-10. Fig. 1-6 refer to the part of the video codec that works at the syntax level. The following figs. 8-10 refer to embodiments for a portion of code related to converting a stream of syntax elements to a data stream and vice versa. Specific aspects and embodiments of the present invention are then described in terms of possible implementations of the general principle representatively summarized with respect to FIG. 1-10.

Fig. 1 depicts an example encoder 10 in which aspects of the present application may be implemented.

The encoder encodes an array of sampling elements 20 of information into the data stream. The information bin array may represent information bins corresponding to, for example, luminance values, chrominance values, luminance values, chroma values, or the like. However, the information bins may also be depth values in the case of the bin array 20 being a depth map generated from, for example, a light sensor time or the like.

Encoder 10 is a block based encoder. Those. encoder 10 encodes bin array 20 into 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 quite independently of each other. Instead, encoder 10 may use reconstructions of previously encoded blocks to extrapolate or internally predict the remaining blocks, and may use the degree of block splitting to set encoding parameters, i.e. to set the method by which each region of the bin array corresponding to the corresponding block is encoded.

In addition, encoder 10 is a transform encoder. Those. encoder 10 encodes blocks 40 by using a transform to transfer the information bins in each block 40 from the spatial domain to the spectral domain. A two-dimensional transform such as Discrete Cosine Transform (DCT), Fast Fourier Transform (FFT) or the like may be used. Preferably, the blocks 40 are square or rectangular in shape.

The subdivision of the bin array 20 into blocks 40 shown in FIG. 1 is merely for illustration purposes. Fig. 1 depicts a bin array 20 subdivided into a conventional two-dimensional arrangement of square or rectangular blocks 40 that are adjacent to each other in a non-overlapping manner. The size of the blocks 40 may be predetermined. Those. the encoder 10 may not carry the block size information of the blocks 40 in the data stream 30 to the decoding side. For example, a decoder may expect a given block size.

However, several alternatives are possible. For example, blocks can overlap each other. The overlap, however, may be limited to such an extent that each block has a portion not overlapped by any neighboring block, or such that each block bin overlaps at most one block from among neighboring blocks adjacent to each other with the current block at a given direction. The latter means that the left and right adjacent blocks may overlap the current block to completely cover the current block, but they may not overlap each other, and the same applies to neighbors in the vertical and diagonal direction.

As another alternative, subdivision of bin array 20 into blocks 40 may be adapted to the content of bin array 20 by encoder 10, with subdivision information about the subdivision being used being sent to the decoder side via bitstream 30.

Fig. 2a-2c depict different examples for dividing the bin array 20 into blocks 40. FIG. 2a shows a quadtree subdivision of an array of 20 bins into blocks of 40 different sizes, with typical blocks being designated 40a, 40b, 40c and 40d in increasing size. According to the subdivision in FIG. 2a, the bin array 20 is first divided into a conventional two-dimensional arrangement of treeblocks 40d, which in turn have individual subdivision information associated with it, according to which some treeblock 40d may or may not be further subdivided according to the quadtree structure. The tree block to the left of block 40d is, by way of example, subdivided into smaller blocks according to the quadtree structure. Encoder 10 may perform one 2D transform for each of the blocks shown in solid and dashed lines in FIG. 2a. In other words, encoder 10 may transform array 20 in units of block subdivision.

Instead of a quadtree-based division, a more general multiple-tree division may be used, and the number of child nodes per hierarchy level may differ between different levels of the hierarchy.

Fig. 2b shows another example for a division. In accordance with FIG. 2b, the bin array 20 is first divided into macroblocks 40b arranged in a conventional two-dimensional arrangement in a non-overlapping, mutually adjacent manner, each macroblock 40b having subdivision information associated with it, according to which the macroblock is not subdivided, or if subdivided, is subdivided in a conventional two-dimensional manner. into subblocks of equal size to achieve different degrees of subdivision partitioning for different macroblocks. The result is a division of the array of 20 bins into blocks 40 with different sizes, with representatives of different sizes being denoted by positions 40a, 40b and 40a'. As in FIG. 2a, encoder 10 performs a 2D transform on each of the blocks shown in solid and dashed lines in FIG. 2b. Fig. 2c is described below.

Fig. 3 shows a decoder 50 capable of decoding a data stream 30 generated by an encoder 10 to recover a reconstructed version 60 of a bin array 20. The decoder 50 extracts from the data stream 30 a transform coefficient block for each of the blocks 40 and reconstructs the reconstructed version 60 by performing an inverse transform on each of the transform coefficient blocks.

Encoder 10 and decoder 50 may be configured to perform entropy encoding/decoding to insert information about transform coefficient blocks into and extract the information from the data stream, respectively. Details in this regard are described below in accordance with various embodiments. It should be noted that the data stream 30 does not necessarily contain transform coefficient block information for all blocks 40 of the bin array 20 . Instead, since a subset of blocks 40 may be encoded into bitstream 30 in a different manner. For example, encoder 10 may instead choose to refrain from inserting a block of transform coefficients for some block of blocks 40 with insertion into bitstream 30 of alternative encoding parameters that allow decoder 50 to predict or otherwise populate the corresponding block in reconstructed version 60. For example , the encoder 10 may perform texture analysis to determine the location of blocks in the bin array 20, which may be populated on the decoder side by the decoder through texture synthesis, and indicate this in the bitstream accordingly.

As described with respect to the following figures, the blocks of transform coefficients do not necessarily represent the spectral domain representation of the original bin information of the corresponding block 40 of the bin array 20. Instead, such a block of transform coefficients may represent a spectral region representation of the prediction residual of the corresponding block 40. FIG. 4 depicts an embodiment for such an encoder. The encoder of FIG. 4 contains a transformation stage (cascade) 100, an entropy encoder 102, an inverse transformation stage 104, a predictor (predictor) 106 and a subtractor 108, and an adder 110. The subtractor 108, the transformation stage 100 and the entropy encoder 102 are connected in series in the mentioned order between the input 112 and encoder output 114 in FIG. 4. Inverse transform stage 104, adder 110, and predictor 106 are connected in this order between the output of transform stage 100 and the inverting input of subtractor 108, with the output of predictor 106 also connected to another input of adder 110.

The encoder of FIG. 4 is a block encoder based on predictive transform. Those. bin array blocks 20 input 112 are predicted from previously encoded and reconstructed portions of the same bin array 20 or previously encoded and reconstructed other bin arrays that may precede or follow the current bin array 20 in presentation time. Prediction is performed by predictor 106. Subtractor 108 subtracts the prediction from such an original block, and transform stage 100 performs a two-dimensional transform of the prediction residuals. The 2D transform itself, or a subsequent measure in the transform stage 100, may result in quantization of the transform coefficients in blocks of transform coefficients. The quantized blocks of transform coefficients are losslessly encoded, for example, by entropy coding in entropy encoder 102, with the resulting data stream output at output 114. Inverse transform stage 104 reconstructs the quantized residual, and adder 110 in turn combines the reconstructed residual with the corresponding prediction for obtaining recovered bins of information based on which the predictor 106 can predict the aforementioned currently encoded prediction blocks. The predictor 106 may use different prediction modes such as intra prediction modes and inter prediction modes to predict blocks, and the prediction parameters are sent to the entropy encoder 102 for insertion into the data stream. For each inter-prediction block, the corresponding motion data is inserted into the bitstream by the entropy encoder 114 to enable the decoding side to re-perform the prediction. The motion data for the image prediction block may include a syntax part including a syntax element representing a motion vector difference differentially encoding a motion vector for the current prediction block with respect to a motion vector predictor obtained, for example, by a predetermined method from neighboring motion vectors already encoded prediction blocks.

Those. according to the embodiment of FIG. 4, the transform coefficient blocks represent the spectral representation of the remainder of the bin array rather than its actual information bins. Those. according to the embodiment of FIG. 4, a sequence of syntax elements may be provided to an entropy encoder 102 for entropy encoding into a data stream 114. The sequence of syntax elements may contain syntax elements of motion vector differences for inter prediction blocks and syntax elements relating to a significance map indicating the positions of significant levels of transform coefficients, as well as syntax elements defining the significant levels of transform coefficients themselves for transformation blocks.

It should be noted that several alternatives exist for the embodiment of FIG. 4, some of which have been described in the introductory part of the description of the invention, the description of which is included in the description of FIG. 4 of this document.

Fig. 5 shows a decoder capable of decoding a data stream generated by the encoder of FIG. 4. The decoder of FIG. 5 includes an entropy decoder 150, an inverse transform stage 152, an adder 154, and a predictor 156. An entropy decoder 150, an inverse transform stage 152, and an adder 154 are connected in series between input 158 and output 160 of the decoder of FIG. 5 in that order. The other output of the entropy decoder 150 is connected to a predictor 156, which in turn is connected between the output of the adder 154 and its other input. Entropy decoder 150 extracts from the data stream input to the decoder of FIG. 5 at input 158, transform coefficient blocks, with an inverse transform being applied to the transform coefficient blocks at stage 152 to produce a residual signal. The residual signal is combined with the prediction from predictor 156 at summer 154 to obtain a reconstructed block of the reconstructed version of the bin array at output 160. Based on the reconstructed versions, predictor 156 generates predictions, thereby recovering the predictions made by encoder-side predictor 106. To obtain the same predictions as those used at the encoder side, the predictor 156 uses the prediction parameters that the entropy decoder 150 also receives from the data stream at the input 158.

It should be noted that in the above-described embodiments, the spatial division degree with which prediction and residual transformation are performed need not be equal to each other. This is shown in FIG. 2C. This figure depicts the subdivision for prediction blocks of the prediction split ratio with solid lines and the residual split ratio with dotted lines. As can be seen, the subdivisions may be independently selected by the encoder. More specifically, the dataflow syntax may allow for the definition of a residual division regardless of the prediction division. Alternatively, the residual division may be an extension of the prediction division such that each residual block is either equal to, or a proper subset of, the prediction block. This is shown in FIG. 2a and fig. 2b, for example, where again the degree of splitting of the prediction is shown by solid lines and the degree of splitting of the residual is shown by dotted lines. Those. in fig. 2a-2c, all blocks having a reference position associated with them will be residual blocks for which one 2D transformation will be performed, while larger blocks with solid lines spanning blocks 40a with dotted lines, for example, will be prediction blocks for which prediction parameters are set individually.

The above embodiments have in common that a block (of residual bins or original bins) must be transformed at the encoder side into a block of transform coefficients, which in turn must be back-transformed into a reconstructed block of bins at the decoder side. This is shown in FIG. 6. FIG. 6 shows a bin block 200. In the case of FIG. 6, this block 200 is, by way of example, square and has 4×4 bins 202 in size. The bins 202 are regularly arranged in the horizontal x direction and in the vertical y direction. Through the aforementioned two-dimensional T transform, the block 200 is transformed into a spectral domain, namely, a block 204 of the transform coefficients 206, with the transform block 204 having the same size as the block 200. That is, transform block 204 has as many transform coefficients 206 as block 200 has bins in both the horizontal direction and the vertical direction. However, since the transform T is a spectral transform, the positions of the transform coefficients 206 in the transform block 204 do not correspond to the spatial positions, but rather to the spectral components of the contents of the block 200. In particular, the horizontal axis of the transform block 204 corresponds to an axis along which the spectral frequency in the horizontal direction is monotonically increases while the vertical axis corresponds to an axis along which the spatial frequency in the vertical direction increases monotonically, with the DC component conversion factor located at the corner—here, by way of example, the upper left corner—of the block 204, so that in the lower right corner is the conversion factor 206 corresponding to the highest frequency in both the horizontal and vertical directions. Neglecting the spatial direction, the spatial frequency to which a certain transform factor 206 belongs typically increases from the upper left corner to the lower right corner. Through the inverse transform T ^-1 , the transform block 204 is transferred from the spectral domain to the spatial domain to re-obtain a copy 208 of the block 200. If there is no introduction of quantization loss in the transform, the reconstruction will be perfect.

As noted above, it can be seen in Fig. 6 that the large block sizes of block 200 increase the spectral resolution of the resulting spectral representation 204. On the other hand, quantization noise tends to propagate throughout block 208, and thus sharp and highly localized features in blocks 200 tend to lead to deviations in the retransformed block. relative to the original block 200 due to quantization noise. The main advantage of using large blocks, however, is that the ratio between the number of significant, i.e. non-zero (quantized) transformation coefficients, i.e. levels, on the one hand, and the number of insignificant transform coefficients, on the other hand, can be reduced in large blocks compared to smaller blocks, thereby allowing better coding efficiency to be obtained. In other words, often significant levels of transform coefficients, i.e. transform coefficients not quantized to zero are rarely distributed over transform block 204. As a consequence, according to the embodiments described in more detail below, the positions of the significant levels of the transform coefficients are signaled in the data stream by a significance map. Apart from it, the values of the significant transformation coefficient, i.e. the levels of the transform coefficients in the case where the transform coefficients are quantized are transmitted in the data stream.

All of the encoders and decoders described above are thus configured to work with some syntax of the syntax elements. Those. the aforementioned syntax elements such as transform coefficient levels, syntax elements regarding a significance map of transform blocks, motion data syntax elements regarding inter prediction blocks, and the like, are assumed to be arranged sequentially in the data stream in a predetermined manner. Such a given image may be represented as pseudocode, such as is done in the H.264 standard or other video codecs.

In other words, the above description, dealing mainly with the transformation of multimedia data, here, as an example, video data, into a sequence of syntax elements in accordance with a predefined syntax structure defining some types of syntax elements, its semantics, and the order among them. The entropy encoder and entropy decoder of FIG. 4 and 5 may be made operable, and may be structured as summarized below. They are responsible for performing the transformation between the sequence of syntax elements and the data stream, i.e. stream of characters or bits.

An entropy encoder according to an embodiment is shown in FIG. 7. The lossless encoder converts the stream of syntax elements 301 into a set of two or more partial bitstreams 312.

In a preferred embodiment of the invention, each syntax element 301 is associated with a category of a set of one or more categories, i. e. the type of the syntax element. As an example, the categories may define the type of a syntax element. In the context of hybrid video coding, a particular category may be associated with macroblock coding modes, block coding modes, reference picture indices, motion vector differences, division flags, coded block flags, quantization parameters, transform coefficient levels, and so on. In other applications, such as audio, speech, text, document, or conventional data encoding, different categorizations of syntax elements are possible.

Typically, each syntax element can take on the value of a finite or countably infinite set of values, where the set of possible values of a syntax element may differ for different categories of syntax elements. For example, there are binary syntax elements as well as integer ones.

To reduce the complexity of the encoding and decoding algorithm, and to allow common design of encoding and decoding for different syntax elements and categories of syntax elements, the syntax elements 301 are converted into ordered binary decision sets, and these binary decisions are then processed by simple binary encoding algorithms. Therefore, binarizer 302 bijectively (one-to-one) maps the value of each syntax element 301 to a sequence (or string or word) of bins 303. A bin sequence 303 represents a set of ordered binary solutions. Each bin 303 or binary decision may take one value out of a set of two values, such as one of the values 0 and 1. The binarization scheme may be different for different categories of syntax elements. The binarization scheme for a particular category of syntax elements may depend on the set of possible syntax element values and/or other properties of the syntax element for a particular category.

Table 1 illustrates three exemplary binarization schemes for countably infinite sets. Binarization schemes for countably infinite sets can also be applied to finite sets of values of syntactic elements. In particular, for large finite sets of syntax element values, there may be a slight inefficiency (resulting from unused bin sequences), but the generality of such binarization schemes provides an advantage in terms of complexity and memory requirements. For small finite sets of syntax element values, it is often preferable (in terms of coding efficiency) to adapt the binarization scheme to the number of possible character values.

Table 2 illustrates three exemplary binarization schemes for finite sets of 8 values. Binarization schemes for finite sets can be derived from universal binarization schemes for countably infinite sets by modifying some sequences of bins such that finite sets of sequences of bins represent a code without redundancy (and potentially reordering of sequences of bins). As an example, the truncated unary binarization scheme in Table 2 was created by modifying the bin sequence for syntax element 7 of the universal unary binarization (see Table 1). The truncated and reordered exponential Golomb binarization of order 0 in Table 2 was created by modifying the bin sequence for syntax element 7 of the universal exponential Golomb binarization of order 0 (see Table 1) and by reordering the bin sequences (the truncated bin sequence for character 7 was assigned to character 1) . For finite sets of syntax elements, it is also possible to use non-systematic/non-universal binarization schemes, as given as an example in the last column of Table 2.

Each bin 303 of the sequence of bins generated by the binarizer 302 is provided to the parameter assigner 304 in sequential order. The parameter assigner assigns a set of one or more parameters to each bin 303 and outputs a bin with an associated parameter set 305. The parameter set is defined in exactly the same way in the encoder and decoder. The parameter set may consist of one or more of the following parameters:

In particular, the parameter assigner 304 can be configured to assign a context model to the current bean 303 . For example, the parameter assigner 304 may select one of the available context indexes for the current bean 303. The available set of contexts for the current bean 303 may depend on the type of the bean, which in turn may be determined by the type/category of the syntax element 301 which current bean binarizes. 303 is the part and position of the current bin 303 in the last binarization. The selection of a context from among the available set of contexts may depend on the previous beans and the syntax elements associated with the last one. Each of these contexts has a probabilistic model associated with it, i.e. a measure for estimating the probability for one of the two possible bin values for the current bin. The probability model may in particular be a measure for estimating a probability for a less likely or more likely bin value for the current bin, the probability model being further defined by an identifier specifying which of the two possible bin values represents the less likely or more likely bin value for current bean 303. In the case where only one context is available for the current bean, context selection may be omitted. As discussed in more detail below, the parameter assigner 304 may also perform probability model adaptation to adapt the probability models associated with different contexts with the actual bin statistics of the respective bins belonging to the respective contexts.

As also described in more detail below, the parameter assigner 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 any of the bin encoders 310 as follows, but the mode of operation of the parameter assigner 304 tends to be less complex in the LC mode, however, coding gain is increased in the high efficiency mode due to that the parameter assigner 304 causes the association of individual bins 310 to individual encoders 310 with bin statistics to be more closely adapted, thereby optimizing the entropy with respect to the LC mode.

Each bin with an associated parameter set 305 that is the output of the parameter assigner 304 is provided to a bin buffer selector 306 . The bin buffer selector 306 potentially modifies the value of the input bin 305 based on the value of the input bin and the associated parameters 305, and feeds the output bin 307—with the potentially modified value—into one of two or more bin buffers 308. The bin buffer 308 to which the output bin 307 is sent is determined based on the value of the input bin 305 and/or the value of the associated parameters 305.

In the preferred embodiment, the bin buffer selector 306 does not modify the value of the bin, ie. the output bin 307 always has the same value as the input bin 305. In another preferred embodiment of the invention, the bin buffer selector 306 determines the output bin value 307 based on the input bin value 305 and an associated measure to estimate the probability for one of two possible values. bin for the current bin. In a preferred embodiment of the invention, the output bin value 307 is set equal to the input bin value 305 if the measure for the probability for one of the two possible bin values for the current bin is less than (or less than or equal to) a particular threshold; if the measure for the probability for one of the two possible bin values for the current bin is greater than or equal to (or greater than) a particular threshold, the output bin value 307 is modified (ie, set to the opposite value of the input bin value). In another preferred embodiment of the invention, the output bin value 307 is set equal to the input bin value 305 if the measure for the probability for one of the two possible bin values for the current bin is greater than (or greater than or equal to) a particular threshold; if the measure for the probability for one of the two possible bin values for the current bin is less than or equal to (or less than) a particular threshold, the output bin value 307 is modified (ie, set to the opposite value of the input bin value). In a preferred embodiment of the invention, the threshold value corresponds to a value of 0.5 for the estimated probability for both possible bin values.

In another preferred embodiment of the invention, the bin buffer selector 306 determines the output bin value 307 based on the input bin value 305 and an associated identifier specifying which of the two possible bin values represents the less likely or more likely bin value for the current bin. In the preferred embodiment of the invention, output bin value 307 is set equal to input bin value 305 if the identifier specifies that the first of two possible bin values represents the less likely (or more likely) bin value for the current bin, and output bin value 307 is modified (i.e., e. set to the opposite value of the input bin value) if the identifier specifies that the second of two possible bin values represents the less likely (or more likely) bin value for the current bin.

In the preferred embodiment, the bin buffer selector 306 determines the bin buffer 308 to which the output bin 307 is sent based on an associated measure to estimate the probability for one of the two possible bin values for the current bin. In a preferred embodiment of the invention, the set of possible values for the probability score measure for one of the two possible bin values is finite, and the bin buffer selector 306 contains a table that associates exactly one bin buffer 308 with each possible probability score for one of the two possible values. bin values, where different values for the measure to estimate the probability for one of the two possible bin values can be associated with the same bin buffer 308 . In another preferred embodiment of the invention, the range of possible values for the probability measure for one of the two possible bin values is divided into multiple intervals, the bin buffer selector 306 determines the interval index for the current probability measure for one of the two possible bin values, and the selector 306 The bin buffer contains a table that associates exactly one bin buffer 308 with each possible value for the bin index, where different values for the bin index can be associated with the same bin buffer 308. In a preferred embodiment of the invention, input bins 305 with opposite measures for the probability score for one of the two possible bin values (the opposite measure being those representing the P and 1-P probability scores) are fed into the same bin buffer 308. In another preferred embodiment of the invention, the association of a measure for estimating a probability for one of the two possible bin values for the current bin with a particular bin buffer is adapted over time, for example, to ensure that the generated partial bitstreams have similar bit rates. In addition, the interval index is also called the pipe index (probability interval division entropy), while the pipe index, together with the refinement index, and the flag indicating the more probable value of the bin, indexes the actual probability model, i.e. probability estimate.

In another preferred embodiment of the invention, the bin buffer selector 306 determines the bin buffer 308 to which the output bin 307 is sent based on the associated measure to estimate the probability for the less likely or more likely bin value for the current bin. In a preferred embodiment of the invention, the set of possible values for a measure to estimate a probability for a less likely or more likely bin value is finite, and the bin buffer selector 306 contains a table that associates exactly one bin buffer 308 with each possible probability estimate value for the less likely or more a likely bin value, where different values for a measure for estimating a probability for a less likely or more likely bin value can be associated with the same bin buffer 308 . In another preferred embodiment of the invention, the range of possible values for the probability measure for the less likely or more likely bin value is divided into multiple bins, the bin buffer selector 306 determines the bin index for the current probability measure for the less likely or more likely bin value, and the bin buffer selector 306 contains a table that associates exactly one bin buffer 308 with each possible value for the bin index, where different values for the bin index may be associated with the same bin buffer 308 . In another preferred embodiment, the association of a measure for estimating a probability for a less likely or more likely bin value for the current bin with a particular bin buffer is time-adapted, for example, to ensure that the generated partial bitstreams have similar bit rates.

Each of the two or more bin buffers 308 is connected to exactly one bin encoder 310, and each bin encoder is connected to only one bin buffer 308. Each bin encoder 310 reads bins from an associated bin buffer 308 and converts a sequence of bins 309 into a codeword 311 that represents a sequence of bits. The bin buffers 308 represent first-come-first-served buffers; bins that are fed later (in sequential order) into the bin buffer 308 are not encoded before bins that are fed earlier (in sequential order) into the bin buffer. Codewords 311, which are the output of a particular bin encoder 310, are written to a particular partial bitstream 312. The general encoding algorithm converts syntax elements 301 into two or more partial bitstreams 312, where the number of partial bitstreams is equal to the number of bin buffers and bin encoders . In the preferred embodiment of the invention, the bin encoder 310 converts the variable number of bins 309 into a codeword 311 with a variable number of bits. One advantage of the above and below summarized embodiments of the invention is that the encoding of the bins can be performed in parallel (eg, for different groups of probability measures), which reduces the processing time for multiple implementations.

Another advantage of embodiments of the invention is that the bin encoding that is performed by the bin encoders 310 can be specifically designed for different parameter sets 305. In particular, the bin encoding and encoding can be optimized (in terms of coding efficiency and/or complexity) for different groups of estimated probabilities. On the one hand, this makes it possible to reduce the complexity of encoding/decoding, and on the other hand, it makes it possible to obtain an increase in encoding efficiency. In a preferred embodiment of the invention, bin encoders 310 implement different coding algorithms (i.e., mapping bin sequences to codewords) for different groups of measures to estimate a probability for one of two possible bin values 305 for the current bin. In another preferred embodiment of the invention, bin encoders 310 implement different coding algorithms for different measure groups to estimate the probability for the less likely or more likely bin value for the current bin.

In the preferred embodiment, the bin encoders 310—or one or more of the bin encoders—are entropy encoders that directly map sequences of input bins 309 to codewords 310. Such a mapping can be efficiently implemented and does not require a complex arithmetic encoding mechanism. The reverse mapping of codewords to bin sequences (which is done in the decoder) must be unique to ensure perfect decoding of the input sequence, but the mapping of bin sequences 309 to codewords 310 need not be unique, i. it is possible that a particular bin sequence may map to more than one codeword sequence. In the preferred embodiment of the invention, the mapping of input bin sequences 309 to codewords 310 is bijective. In another preferred embodiment of the invention, the bin encoders 310—or one or more of the bin encoders—are entropy encoders that directly map variable length sequences of input bins 309 into variable length codewords 310. In a preferred embodiment of the invention, the output codewords represent non-redundant codes such as generic Huffman codes or canonical Huffman codes.

Table 3 shows two examples for bijectively mapping bin sequences to codes without redundancy. In another preferred embodiment of the invention, the output codewords represent redundant codes suitable for error detection and error recovery. In another preferred embodiment of the invention, the output codewords represent encryption codes suitable for encrypting syntax elements.

In another preferred embodiment of the invention, the bin encoders 310—or one or more of the bin encoders—are entropy encoders that directly map variable length sequences of input bins 309 into fixed length codewords 310. In another preferred embodiment of the invention, the bin encoders 310—or one or more of the bin encoders—are entropy encoders that directly map fixed length sequences of input bins 309 into variable length codewords 310.

A decoder according to an embodiment of the invention is shown in FIG. 8. The decoder performs basically the inverse of the encoder, so that the (previously encoded) sequence of syntax elements 327 is decoded from a set of two or more partial bitstreams 324. The decoder includes two different processing streams: a stream for requesting data, which repeats the encoder data stream, and the data stream that represents the reverse of the encoder data stream. In the illustration in FIG. 8, dashed arrows represent the data request flow, while solid arrows represent the data flow. The building blocks of the decoder basically repeat the building blocks of the encoder, but implement the reverse operations.

Syntax element decoding is triggered by a request for a new decodable syntax element 313, which is sent to the binarizer 314. In the preferred embodiment of the invention, each request for a new decodable syntax element 313 is associated with a category of a set of one or more categories. The category that is associated with a syntax element request is the same as the category that was associated with the corresponding syntax element at the time of encoding.

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

The parameter assigner 316 assigns a set of one or more parameters to each bean request and sends the bean request with the associated parameter set to the bin buffer selector. The parameter set that is assigned to the requested bean by the parameter assigner is the same one that was assigned to the corresponding bean during encoding. The set of parameters may consist of one or more parameters, which are mentioned in the description of the encoder in FIG. 7.

In the preferred embodiment of the invention, parameter assigner 316 associates each bean request with the same parameters as assigner 304 did, i. a context and its associated measure for estimating the probability for one of the two possible bin values for the current requested bin, such as a measure for estimating the probability for the less likely or more likely bin value for the current requested bin, and an identifier specifying which of the two possible bin values represents the less likely or more likely bean value for the currently requested bean.

The parameter assigner 316 may determine one or more of the above probability measures (a measure for estimating a probability for one of the two possible bin values for the current requested bin, a measure for estimating a probability for a less likely or more likely bin value for the current requested bin, an identifier specifying judging which of the two possible bin values represents the less likely or more likely bin value for the currently requested bin) based on the set of one or more already decoded symbols. Determining the probability measures for a particular bin request repeats the process in the encoder for the corresponding bin. The decoded symbols that are used to determine the probability measures may include one or more already decoded symbols of the same symbol category, one or more already decoded symbols of the same symbol category that corresponds to data sets (such as blocks or bin groups) of neighboring spatial and/or temporal locations (in relation to the data set associated with the current syntax element request), or one or more already decoded symbols of different character categories that correspond to data sets of the same and/or neighboring spatial and/or temporal locations (in relation to to the data set associated with the current syntax element request).

Each bin request with an associated parameter set 317, which is the output of the parameter assigner 316, is applied to a bin buffer selector 318 . Based on the associated parameter set 317, the bin buffer selector 318 sends a bin request 319 to one of two or more bin buffers 320 and receives a decoded bin 325 from the selected bin buffer 320. The decoded input bean 325 is potentially modified, and the decoded output bean 326—with the potentially modified value—is sent to the binarizer 314 as the final response to the bean request with the associated parameter set 317.

The bin buffer 320 to which the bin request is directed is selected in the same manner as the bin buffer to which the output bin of the bin buffer selector on the encoder side was sent.

In the preferred embodiment, the bin buffer selector 318 determines the bin buffer 320 to which the bin request 319 is sent based on the associated measure to estimate the probability for one of the two possible bin values for the currently requested bin. In a preferred embodiment of the invention, the set of possible values for a measure for a probability score for one of the two possible bin values is finite, and the bin buffer selector 318 contains a table that associates exactly one bin buffer 320 with each possible probability score value for one of the two possible values. bin, where different values for the measure to estimate the probability for one of the two possible values of the bin can be associated with the same buffer 320 bins. In another preferred embodiment of the invention, the range of possible values for the probability measure for one of the two possible bin values is divided into multiple intervals, the bin buffer selector 318 determines the interval index for the current probability measure for one of the two possible bin values, and the selector 318 The bin buffer contains a table that associates exactly one bin buffer 320 with each possible value for the bin index, where different values for the bin index may be associated with the same bin buffer 320. In a preferred embodiment of the invention, requests for bins 317 with opposite measures for a probability score for one of two possible bin values (the opposite measure being those representing the P and 1-P probability scores) are sent to the same bin buffer 320. In another preferred embodiment of the invention, the association of a measure for estimating a probability for one of the two possible bin values for the current bin request with a particular bin buffer is adapted over time.

In another preferred embodiment of the invention, the bin buffer selector 318 determines the bin buffer 320 to which the bin request 319 is sent, based on the associated measure for estimating the probability for the less likely or more likely bin value for the current requested bin. In a preferred embodiment of the invention, the set of possible values for a measure to estimate a probability for a less likely or more likely bin value is finite, and the bin buffer selector 318 contains a table that associates exactly one bin buffer 320 with each possible probability estimate value for the less likely or more a likely bin value, where different values for a measure for estimating a probability for a less likely or more likely bin value can be associated with the same bin buffer 320 . In another preferred embodiment of the invention, the range of possible values for the probability score measure for the less likely or more likely bin value is divided into multiple bins, the bin buffer selector 318 determines the bin index for the current probability score measure for the less likely or more likely bin value, and the bin buffer selector 318 contains a table that associates exactly one bin buffer 320 with each possible value for the bin index, where different values for the bin index can be associated with the same bin buffer 320. In another preferred embodiment of the invention, the association of a probability measure for a less likely or more likely bin value for the current bin request with a particular bin buffer is time-adaptive.

Upon receipt of the decoded bin 325 from the selected bin buffer 320, the bin buffer selector 318 potentially modifies the input bin 325 and sends the output bin 326—with the potentially modified value—to the binarizer 314. The input/output bin mapping of the bin buffer selector 318 is the reverse of the input/output bin mapping. bin buffer selector on the encoder side.

In the preferred embodiment, the bin buffer selector 318 does not modify the value of the bin, ie. the output bin 326 always has the same value as the input bin 325. In another preferred embodiment of the invention, the bin buffer selector 318 determines the output bin value 326 based on the input bin value 325 and a measure to estimate the probability for one of two possible bin values. for the current requested bean that is associated with the bean request 317. In a preferred embodiment of the invention, output bean value 326 is set equal to input bin value 325 if the measure for the probability for one of the two possible bin values for the current bean request is less than (or less than or equal to) specific threshold; if the measure for the probability for one of the two possible bin values for the current bin request is greater than or equal to (or greater than) a particular threshold, the output bin value 326 is modified (ie, set to the opposite value of the input bin). In another preferred embodiment of the invention, output bin value 326 is set equal to input bin value 325 if the measure for the probability for one of the two possible bin values for the current bin request is greater than (or greater than or equal to) a particular threshold; if the measure for the probability for one of the two possible bin values for the current bin request is less than or equal to (or less than) a particular threshold, the output bin value 326 is modified (ie, set to the opposite value of the input bin). In a preferred embodiment of the invention, the threshold value corresponds to a value of 0.5 for the estimated probability for both possible bin values.

In another preferred embodiment of the invention, the bin buffer selector 318 determines the output bin value 326 based on the input bin value 325 and an identifier specifying which of the two possible bin values represents the less likely or more likely bin value for the current bin request that is associated with bean request 317. In the preferred embodiment of the invention, output bin value 326 is set to input bin value 325 if the identifier specifies that the first of two possible bin values represents the less likely (or more likely) bin value for the current bean request, and output bin value 326 the bean is modified (ie, set to the opposite value of the input bean) if the identifier specifies that the second of the two possible bean values represents the less likely (or more likely) bean value for the current bean request.

As described above, the bin buffer selector sends a bin request 319 to one of two or more bin buffers 320 . The bin buffers 20 represent a first-come-first-served buffer to which sequences of decoded bins 321 are fed from connected bin decoders 322. In response to the bin request 319 that is sent to the bin buffer 320 from the bin buffer selector 318, the bin buffer 320 removes the bin from its contents that was first submitted to the bin buffer 320 and sends it to the bin buffer selector 318. The bins that were previously sent to the bin buffer 320 are previously removed and sent to the bin buffer selector 318 .

Each of the two or more bin buffers 320 is connected to exactly one bin decoder 322, and each bin decoder is connected to only one bin buffer 320. Each bin decoder 322 reads codewords 323, which represent sequences of bits, from a separate partial bitstream 324. The bin decoder converts codeword 323 into a sequence of bins 321, which is sent to the attached bin buffer 320. The general decoding algorithm converts two or more partial bitstreams 324 into multiple decoded syntax elements, where the number of partial bitstreams is equal to the number of bin buffers and bin decoders, and syntax element decoding is triggered by requests for new syntax elements. In a preferred embodiment of the invention, a bin decoder 322 converts variable-bit codewords 323 into a variable-bit-number sequence 321. probability measures), which reduces the processing time for several implementations.

Another advantage of embodiments of the invention is that the bin decoding that is performed by the bin decoders 322 can be specifically designed for different parameter sets 317. In particular, bin encoding and decoding can be optimized (in terms of coding efficiency and/or complexity) for different groups. estimated probabilities. On the one hand, this makes it possible to reduce the coding/decoding complexity relative to modern entropy coding algorithms with similar coding efficiency. On the other hand, this improves the coding efficiency relative to modern entropy coding algorithms with similar encoding/decoding complexity. In a preferred embodiment of the invention, bin decoders 322 implement different decoding algorithms (i.e., mapping bin sequences to codewords) for different measure groups to estimate the probability for one of two possible bin values 317 for the current bin request. In another preferred embodiment of the invention, bin decoders 322 implement different decoding algorithms for different measure groups to estimate the probability for the less likely or more likely bin value for the currently requested bin.

The bin decoders 322 perform the reverse mapping to the corresponding bin encoders on the encoder side.

In the preferred embodiment, the bin decoders 322 - or one or more of the bin decoders - are entropy decoders that directly map codewords 323 to a sequence of bins 321. Such mapping can be efficiently implemented and does not require a complex arithmetic encoding mechanism. The mapping of codewords in a bin sequence must be unique. In the preferred embodiment of the invention, the mapping of codewords 323 to bin sequence 321 is bijective. In another preferred embodiment of the invention, the bin decoders 310—or one or more of the bin decoders—are entropy decoders that directly map variable length codewords 323 to a variable length sequence of bins 321. In a preferred embodiment of the invention, the input codewords represent codes without redundancy, such as general Huffman codes or canonical Huffman codes. Two examples for bijective mapping of codes without redundancy in a sequence of bins are given in Table 3.

In another preferred embodiment of the invention, bin decoders 322—or one or more of the bin decoders—are entropy decoders that directly map fixed-length codewords 323 to variable-length sequences of bins 321. In another preferred embodiment, bin decoders 322 are either one or several of the bin decoders are entropy decoders that directly map variable length codewords 323 onto sequences of fixed length bins 321.

Thus, FIG. 7 and 8 show an embodiment for an encoder to encode the 3 symbol sequence and a decoder to recover them. The encoder includes assigner 304 configured to assign multiple parameters 305 to each character of a character sequence. The assignment is based on information contained in the previous characters of the character sequence, such as the category of syntax element 1 for representation - such as binarization - to which the current character belongs, and which, according to the syntax structure of syntax elements 1, is currently expected to be the expectation, in turn, is derived from the history of the previous syntax elements 1 and symbols 3. In addition, the encoder contains a plurality of entropy encoders 10, each of which is configured to convert symbols 3, sent to the corresponding entropy encoder, into the corresponding bitstream 312, and a selector 306 configured to direct each symbol 3 to a selected one of a plurality of entropy encoders 10, the selection depending on the number of parameters 305 assigned to the corresponding symbol 3. The assigner 304 may be considered to be integrated into the selector 206 to obtain with the corresponding 502 selector.

The symbol recovery decoder comprises a plurality of entropy decoders 322, each of which is configured to convert a respective bitstream 323 into symbols 321; assignment means 316, configured to assign multiple parameters 317 to each character 315 of the character sequence to be recovered based on information contained in previously recovered characters of the character sequence (see 326 and 327 in FIG. 8); and a selector 318 for extracting each symbol from the symbol sequence to be recovered from a selected one of the plurality of entropy decoders 322, the selection depending on the number of parameters defined for the corresponding symbol. The assigner 316 may be configured such that the number of parameters assigned to each symbol contains, or is, a measure for estimating a probability distribution among the possible symbol values that the corresponding symbol can take. Again, assigner 316 and selector 318 may be considered to be integrated into one block, selector 402. The sequence of characters to be recovered may be a binary alphabet, and assigner 316 may be configured such that the probability distribution estimate consists of a measure for estimating the probability a less likely or more likely bin value of the two possible binary alphabet bin values; and an identifier specifying an estimate of which of the two possible bin values represents the less likely or more likely bin value. The assigner 316 may be further configured to internally assign a context to each symbol of the character sequence to be recovered 315 based on information contained in previously recovered symbols of the character sequence to be recovered, each context having a corresponding probability distribution estimate associated with it, and adapting the probability distribution estimate for each context to the actual symbol statistics based on the symbol values of the previously recovered symbols to which the corresponding context is assigned. The context may take into account the spatial dependence or proximity of the positions to which the syntactic elements belong, such as in video or image coding, or even in tables, in the case of financial applications. Then, a measure for estimating a probability distribution for each symbol may be determined based on an estimate of a probability distribution associated with the context assigned to the corresponding symbol, for example, by quantization, or using as an index in the corresponding table, an estimate of the probability distribution associated with the context assigned with the corresponding symbol (in later embodiments, indexed by a pipe index along with a refinement index), to one of the plurality of probability distribution estimation representatives (cutting out the refinement index) to obtain a measure for estimating the probability distribution (pipe index indexes partial bitstream 312). The selector may be configured such that a bijective association is determined between a plurality of entropy encoders and a plurality of representatives of the probability distribution estimate. The selector 18 may be configured to time-vary a quantization mapping from a range of probability distribution estimates to a plurality of probability distribution estimate representatives in a predetermined manner depending on previously recovered symbols of the symbol sequence. Those. selector 318 may change the quantization step sizes, i. e. intervals of probability distributions mapped to individual probability indices bijectively associated with individual entropy decoders. The plurality of entropy decoders 322, in turn, may be configured to adapt their method of converting symbols to bitstreams in response to a change in the quantization mapping. For example, each entropy decoder 322 may be optimized, i.e. may have an optimal compression factor for some probability distribution estimate within the corresponding probability distribution estimate quantization interval, and may change its codeword/symbol sequence mapping to adapt the position of that certain probability distribution estimate within the corresponding probability distribution estimate quantization interval as the latter changes to be optimized. The selector may be configured to change the quantization mapping so that the rates at which symbols are extracted from multiple entropy decoders are made less dispersed. With regard to the binarizer 314, it is noted that it can be omitted if the syntax elements are already binary. In addition, depending on the type of decoder 322, the existence of buffers 320 is not necessary. In addition, buffers can be integrated into decoders.

Completion of finite sequences of syntax elements

In a preferred embodiment of the invention, encoding and decoding is performed on a finite set of syntax elements. Often, some amount of data is encoded, such as a still picture, a frame or field of a video sequence, an image slice, a slice of a frame or fields of a video sequence, or a plurality of consecutive audio bins, and so on. For finite sets of syntax elements, as a rule, partial bitstreams that are created on the encoder side must terminate, i.e. it is necessary to ensure that all syntax elements can be decoded from transmitted or stored partial bitstreams. After the last bin has been inserted into the corresponding bin buffer 308, the bin encoder 310 must ensure that the complete codeword is written to the partial bitstream 312. , which is stored in the bin buffer after the last bin is written to the bin buffer, may not represent a bin sequence that is associated with a codeword (ie, it may represent a prefix of two or more bin sequences that are associated with codewords). In such a case, any of the codewords associated with a bin sequence that contains the bin sequence in the bin buffer as a prefix must be written to the partial bitstream (the bin buffer must be cleared). This can be done by inserting bins with a specific or arbitrary value into the bin buffer until the codeword is written. In a preferred embodiment of the invention, the bin encoder selects one of the minimum length codewords (in addition to the property that the associated bin sequence must contain the bin sequence in the bin buffer as a prefix). On the decoder side, bin decoder 322 may decode more bins than required for the last codeword in the partial bitstream; these bins are not requested by the bin buffer selector 318 and are discarded and ignored. The decoding of a finite set of characters is driven by requests for decoded syntax elements; if no further syntax element is requested for the amount of data, decoding ends.

Transmission and multiplexing of partial bitstreams

The partial bitstreams 312 that are generated by the encoder may be transmitted separately, or they may be multiplexed into a single bitstream, or the codewords of the partial bitstreams may be interleaved in a single bitstream.

In an embodiment of the invention, each partial bit stream for a certain amount of data is recorded in one data packet. The amount of data may be an arbitrary set of syntax elements, such as a still picture, a field or frame of a video sequence, a slice of a still picture, a slice of a field or frame of a video sequence, or a frame of audio bins, and so on.

In another preferred embodiment of the invention, two or more partial bitstreams for a certain amount of data, or all partial bitstreams for a certain amount of data, are multiplexed into one data packet. The structure of a data packet that contains the multiplexed partial bitstreams is shown in FIG. 9.

The data packet 400 consists of a header and one section for the data of each partial bitstream (for the amount of data in question). The header 400 of the data packet contains instructions for dividing the (remainder) of the data packet into data segments 402 of the bitstream. In addition to splitting instructions, the header may contain additional information. In a preferred embodiment of the invention, the indications for splitting a data packet are the locations of the start of the data segments in units of bits or bytes or multiples of bits or multiples of bytes. In a preferred embodiment of the invention, the locations of the beginning of the data segments are encoded as absolute values in the header of the data packet, or relative to the beginning of the data packet, or relative to the end of the header, or relative to the beginning of the previous data packet. In another preferred embodiment of the invention, the locations of the start of the data segments are encoded differentially, i.e. only the difference between the actual start of the data segment and the prediction for the start of the data segment is encoded. The prediction may be derived based on already known or transmitted information, such as the total size of the data packet, the size of the header, the number of data segments in the data packet, the location of the beginning of the preceding data segments. In a preferred embodiment of the invention, the location of the start of the first data packet is not encoded, but is inferred based on the size of the header of the data packet. On the decoder side, the transmitted section indications are used to deduce the start of data segments. The data segments are then used as partial bit streams, and the data contained in the data segments are fed to the respective bin decoders in sequential order.

There are several alternatives for multiplexing partial bit streams into a data packet. One alternative, which may reduce the side information required, in particular for cases in which the sizes of the partial streams are very similar, is depicted in FIG. 10. The payload of the data packet, i.e. data packet 410 without header 411 is divided into segments 412 in a predetermined manner. As an example, the payload of a data packet may be divided into equally sized segments. Each segment is then associated with a partial bitstream or with the first part of the partial bitstream 413. If the partial bitstream is larger than the associated data segment, its remainder 414 is placed in unused space at the end of the other data segments. This can be done in such a way that the rest of the bit stream is inserted in reverse order (starting from the end of the data segment), which reduces the extra information. Associating the remaining portions of partial bitstreams with data segments, and when more than one remaining portion is added to a data segment, the starting point for one or more remaining portions shall be signaled within the bitstream, eg in the header of the data packet.

Variable length codeword interleaving

For some applications, the above described multiplexing of partial bitstreams (for a certain number of syntax elements) in one data packet may have the following disadvantages: in partial bitstreams, which ultimately reduces the coding efficiency. On the other hand, multiplexing may not be suitable for applications that require low latency (eg video conferencing applications). With the described multiplexing, the encoder cannot start transmitting a data packet before the partial bitstreams have been completely created, since the locations of the beginning of the sections are not known beforehand. Also, a decoder typically has to wait until it receives the start of the last data segment before it can start decoding a data packet. For videoconferencing applications, these delays can add to the additional overall multi-picture system delay (particularly for bit rates that are close to the bit rate and for encoders/decoders that require almost the time interval between two pictures to encode). /image decoding), which is critical for such applications. To overcome disadvantages for some applications, the encoder of the preferred embodiment of the invention may be configured such that codewords that are generated by two or more bin encoders are interleaved into a single bitstream. The bitstream with interleaved codewords can be directly sent to the decoder (ignoring the small buffer delay, see below). On the decoder side, two or more bin decoders read codewords directly from the bitstream in decoding order; decoding may start with the first received bit. In addition, no additional information is required for signaling the multiplexing (or interleaving) of partial bitstreams. Another way to reduce decoder complexity can be achieved when bin decoders 322 do not read variable length codewords from the global bit buffer, but instead they always read fixed length bit sequences from the global bit buffer and add these fixed length bit sequences to the local buffer. bits, where each bin decoder 322 is connected to a separate local bit buffer. The variable length codewords are then read from the local bit buffer. Therefore, parsing of variable length codewords can be performed in parallel, only access to fixed length bit sequences must be performed in a synchronized manner, but such access to fixed length bit sequences is usually very fast, so that the overall decoding complexity can be reduced for some architectures. The fixed number of bins that are sent to a particular local bit buffer may be different for different local bit buffers, and it may also vary over time depending on some parameters such as events in the bin decoder, bin buffer, or bit buffer. However, the number of bits that are read during a particular access is independent of the actual bits that are read during a particular access, which is an important difference from reading variable length codewords. Reading fixed-length bit sequences is triggered by some events in bin buffers, bin decoders, or local bit buffers. As an example, it is possible to perform a read request for a new fixed length bit sequence when the number of bits that are present in the attached bit buffer falls below a predetermined threshold, where different thresholds may be used for different bit buffers. The encoder needs to ensure that fixed-length bin sequences are inserted in the same order in the bitstream as they are read from the bitstream at the decoder side. It is also possible to combine this interleaving of fixed length sequences with low latency control like those described above. The preferred embodiment for interleaving fixed bit length sequences is described below. For additional details regarding the latest interleaving schemes, reference is made to WO2011/128268A1.

After describing embodiments according to which, even before, encoding is used to compress video data, is described as yet another embodiment for implementing embodiments of the present invention, which shows an implementation particularly efficient in the sense of a good compromise between the compression ratio on the one hand and the lookup table and computational overhead, on the other hand. In particular, the following embodiments allow the use of less computationally complex variable length codes for entropy coding of individual bitstreams, and effectively cover parts of the probability estimate. In the embodiments described below, the symbols are of a binary nature, and the VLCs (Variable Length Codes) below effectively close the probability estimate represented by, for example, R _{LPS (Least Likely Symbol)} passing within [0; 0.5].

In particular, the embodiments briefly described below describe possible implementations for the individual entropy encoders 310 and decoders 322 in FIG. 7-17 respectively. They are suitable for encoding beans, i.e. binary characters as they occur in image or video compression applications. Therefore, these embodiments are also applicable to image or video coding, where such binary symbols are split into one or more bin streams 307 to be encoded and bitstreams 324 to be decoded, respectively, where each such bin stream can be considered an implementation of a Bernoulli process. The embodiments described below use one or more of the various so-called variable-to-variable codes (v2v codes) explained below to encode the bin streams. A v2v code can be thought of as two unprefixed codes with the same number of codewords. Primary and secondary unprefixed code. Each codeword of the primary unprefixed code is associated with one codeword of the secondary unprefixed code. In accordance with the embodiments described below, at least some of the encoders 310 and decoders 322 operate as follows: bitstream 312. The same procedure is used to decode such bitstream 324, but the primary and secondary unprefixed codes are reversed. Those. to decode bitstream 324, whenever a codeword of the secondary unprefix code is read from the corresponding bitstream 324, the corresponding codeword of the primary unprefix code is written to buffer 320.

Usefully, the codes described below do not require lookup tables. The codes are realizable as state machines. The v2v codes presented here can be generated with simple construction rules, such as that there is no need to maintain large tables for codewords. Instead, a simple algorithm may be used to perform encoding or decoding. Three construction rules are described below, where two of them can be parameterized. They cover different or even non-overlapping parts of the aforementioned probability interval and are therefore particularly useful if used together, for example all three codes in parallel (each for different encoders/decoders 11 and 22) or two of them. With the construction rules described below, it is possible to develop a set of v2v codes such that, for Bernoulli processes with an arbitrary probability p, one of the codes performs well with respect to excess code length.

As discussed above, encoding and decoding of streams 312 and 324, respectively, may be performed either independently for each stream, or in an interleaved manner. This, however, is not specific to the v2v code classes presented, and therefore, only the encoding and decoding of a particular codeword is described for each of the three construction rules in the following. However, it is emphasized that all of the aforementioned embodiments regarding interleaved solutions are also suitable for combination with the currently described codes or encoders and decoders 310 and 322, respectively.

Construction Rule 1: Unary bin pipe codes or encoders/decoders 310 and 322

The entropy codes for the division of the probability interval (pipe) of unary bins are a special version of the so-called "pipe bin" codes, i.e. codes suitable for encoding any of the individual bit streams 12 and 24, each carrying binary symbol statistics belonging to some probability sub-interval of the aforementioned probability range [0; 0.5]. First, the construction of pipe bean codes is described. A bean pipe code can be built from any unprefixed code with at least three codewords. To form a v2v code, it uses an unprefixed code as a primary and secondary code, but swaps two codewords of the secondary unprefixed code. This means that, except for two codewords, the bins are written to the bitstream unchanged. With this method, only one unprefixed code needs to be stored, along with information about which two codewords are swapped, and thus memory consumption is reduced. Note that this only makes sense for permuting codewords of different lengths, since otherwise the bitstream will be the same length as the bin stream (ignoring effects that may take place at the end of the bin stream).

Because of this construction rule, a well-known property of bean pipe codes is that if the primary and secondary unprefixed code are swapped (while the codeword mapping is preserved), the resulting v2v code is identical to the original v2v code. Therefore, the encoding algorithm and the decoding algorithm are identical for the bin pipe codes.

The pipe code of unary beans is made up of a special unprefixed code. This special unprefixed code is composed as follows. First, an unprefixed code consisting of n unary codewords is generated starting from "01", "001", "0001", ... until n codewords are received. n is a parameter for the pipe code of unary beans. The trailing 1 is removed from the longest codeword. This corresponds to a truncated unary code (but without the "0" codeword). Then n-1 unary codewords are generated starting from "10", "110", "1110", ... until n-1 codewords are received. The trailing 0 is removed from the longest of these codewords. The union set of these two unprefixed codes is used as input to generate the pipe code of the unary beans. The two codewords that are swapped are one consisting of only 0's and one consisting of only 1's.

Example for n=4:

No. Primary Secondary

1 0000 111

20010001

3 001 001

4 01 01

5 10 10

6 110 110

7 111 0000

Construction rule 2: Unary-in-Rice-codes and unary-in-Rice encoders/decoders 10 and 22:

Unary-to-Rice codes use a truncated unary code as the primary code. Those. unary codewords are generated starting at "1", "01", "001", ... until ²ⁿ +1 codewords are generated and the trailing 1 is removed from the longest codeword. n is the unary-to-rice parameter -code. The secondary unprefixed code is composed of the code words of the primary unprefixed code as follows. A primary codeword consisting of only 0 is assigned a codeword "1". All other codewords consist of the concatenation of the codeword "0" with the n-bit binary representation of the number 0 of the corresponding codeword of the primary unprefixed code.

Example for n=3:

No. Primary Secondary

1 1 0000

2010001

3 001 0010

4 0001 0011

5 00001 0100

6 000001 0101

7 0000001 0110

8 00000001 0111

9 00000000 1

Note that this is identical to mapping an infinite unary code to a Rice code with a Rice parameter of 2 ⁿ .

Construction rule 3: "Three-bin" code

The three-bin code is defined as:

No. Primary Secondary

10000

2001 100

3 010 101

4 100 110

5 110 11100

6 101 11101

7 011 11110

8 111 11111

It has the property that the primary code (sequence of characters) has a fixed length (always three bins) and the codewords are sorted by ascending numbers 1.

An efficient implementation of the three-bin code is described below. The encoder and decoder for the three-bin code can be implemented without table storage as follows.

At the encoder (any one of 10), three bins are read from the bin stream (ie 7). If these three bins contain exactly one 1, the codeword "1" is written to the bitstream, followed by two bins consisting of the binary representation of position 1 (starting from the right with 00). If three bins contain exactly one 0, the codeword "111" is written to the bitstream followed by two bins consisting of the binary representation of position 0 (starting from the right with 00). The remaining code words "000" and "111" are mapped to "0" and "11111" respectively.

At the decoder (any one of 22), one bin or bit is read from the corresponding bit stream 24. If it is "0", codeword "000" is decoded into a 21 bin stream. If it is "1", two more bins are read from bitstream 24. If these two bits are not equal to "11", they are interpreted as the binary representation of a number, and two 0's and one 1's are decoded into the bitstream, so that position 1 is determined by the number . If two bits are "11", two more bits are read and interpreted as the binary representation of the number. If this number is less than 3, two 1s and one 0 are decoded, and the number specifies the position 0. If it is 3, "111" is decoded into a bin stream.

The following describes an efficient implementation of pipe codes for unary beans. The encoder and decoder for pipe codes of unary bins can be efficiently implemented through the use of a counter. Due to the structure of bean pipe codes, encoding and decoding bean pipe codes is easy to implement:

At the encoder (any of 10), if the first bin of the codeword is "0", the bins are processed until a "1" is encountered, or until n 0's have been read (including the first "0" of the codeword). If a "1" is encountered, the read bins are written to the bitstream unchanged. Otherwise, (ie, n 0 were read), n-1 1 are written to the bitstream. If the first bin of the codeword is "1", the bins are processed until "0" is encountered, or until n-1 1's have been read (including the first "1" of the codeword). If "0" is encountered, the read bins are written to the bitstream unchanged. Otherwise, (ie, n-1 1's have been read), n 0 is written to the bitstream.

The decoder (any one of 322) uses the same algorithm as the encoder since it is the same for the bin pipe codes as described above.

An efficient implementation of unary-in-Rice codes is described below. The encoder and decoder for unary-to-Rice codes can be efficiently implemented by using a counter, as described below.

At the encoder (any one of 310), bins are read from the bin stream (ie 7) until a 1 is encountered, or until 2 ⁿ 0 have been read. The number of 0's is counted. If the counted number is 2 ⁿ , the codeword "1" is written to the bitstream. Otherwise, "0" is written, followed by the binary representation of the count, written with n bits.

In the decoder (any one of 322) one bit is read. If it is "1", 2 ⁿ 0 is decoded into a bin string. If it is "0", n more bits are read and interpreted as the binary representation of the count. This number of 0s is decoded into a bin stream followed by a "1".

{0,1}. Однако возможны альтернативы.In other words, the embodiments just described describe an encoder for encoding a character sequence 303, comprising assigner 316 configured to assign multiple parameters 305 to each symbol of the character sequence based on information contained in previous symbols of the character sequence; a plurality of entropy encoders 310 each configured to convert symbols 307 sent to a respective entropy encoder 310 into a respective bitstream 312; and a selector 6 configured to direct each symbol 303 to a selected one of a plurality of entropy encoders 10, the selection depending on the number of parameters 305 assigned to the corresponding symbol 303. According to the embodiments just described, at least the first subset of entropy encoders may be a variable encoder length, configured to map variable-length character sequences in character stream 307 to variable-length codewords to be inserted into bitstream 312, respectively, wherein each of the first subset entropy encoders 310 uses a bijective mapping rule, according to which the codewords of the primary unprefixed code with ( 2n-1)≥3 codewords are mapped to codewords of a secondary prefix-free code that is identical to the primary prefix code, so that all but two of the codewords of the primary prefix-free code are mapped to identical secondary codewords of the primary and secondary prefix-free codes, while the two codewords of the primary and secondary prefix-free codes have different lengths and are alternately mapped onto each other, and entropy encoders can use different n to cover different parts of the interval of the aforementioned probability interval. The first unprefixed code can be composed so that the codewords of the first unprefixed code are (a,b) ₂ , (a,a,b) ₃ , …, (a, …, a,b) _n , (a, …, a) _n , (b,a) ₂ , (b,b,a) ₃ , …, (b, …, b,a) _n-1 , (b, …, b) _n-1 , and two codewords displayed on top of each other alternately are (a, …, a) _n and (b, …, b) _n-1 with b≠a and a,b

{0,1}. However, alternatives are possible.

{0,1}, в этом случае соответствующий энтропийный кодер выполняется с возможностью исследования следующих символов, направляемых соответствующему энтропийному кодеру, для определения, (1.1) встречается ли b с b≠a и b

{0,1} в следующих n-1 символах, следующих за первым символом, в этом случае соответствующий энтропийный кодер выполняется с возможностью записи кодового слова в соответствующий битовый поток, который равен первому символу, за которым следуют последующие символы, направляемые соответствующему энтропийному кодеру, до символа b; (1.2) не встречается ли b в следующих n-1 символах, следующих за первым символом, в этом случае соответствующий энтропийный кодер выполняется с возможностью записи кодового слова в соответствующий битовый поток, который равен (b, …, b)_n-1; или (2) равен ли первый символ b, в этом случае соответствующий энтропийный кодер выполняется с возможностью исследования последующих символов, направляемых соответствующему энтропийному кодеру, для определения, (2.1) встречается ли a в следующих n-2 символах, следующих за первым символом, в этом случае соответствующий энтропийный кодер выполняется с возможностью записи кодового слова в соответствующий битовый поток, которое равно первому символу, за которым следуют последующие символы, направляемые соответствующему энтропийному кодеру, до символа a; или (2.2) не встречается ли a в следующих n-2 символах, следующих за первым символом, в этом случае соответствующий энтропийный кодер выполняется с возможностью записи кодового слова в соответствующий битовый поток, которое равно (a, …, a)_n.In other words, each of the first subset of entropy encoders can be performed, while converting the symbols sent to the corresponding entropy encoder into the corresponding bitstream, with the possibility of examining the first symbol sent to the corresponding entropy encoder to determine if (1) the first symbol is equal to a

{0,1}, in which case the corresponding entropy encoder is configured to examine the next symbols sent to the corresponding entropy encoder to determine if (1.1) b occurs with b≠a and b

{0,1} in the next n-1 symbols following the first symbol, in which case the corresponding entropy encoder is configured to write the codeword to the corresponding bitstream, which is equal to the first symbol, followed by subsequent symbols sent to the corresponding entropy encoder, before the character b; (1.2) does b occur in the next n-1 characters following the first character, in which case the corresponding entropy encoder is configured to write the codeword to the corresponding bitstream, which is equal to (b, …, b) _n-1 ; or (2) whether the first character is equal to b, in which case the corresponding entropy encoder is configured to examine subsequent characters sent to the corresponding entropy encoder to determine, (2.1) whether a occurs in the next n-2 characters following the first character, in in this case, the corresponding entropy encoder is configured to write a codeword to the corresponding bitstream, which is equal to the first symbol followed by subsequent symbols sent to the corresponding entropy encoder up to symbol a; or (2.2) does a occur in the next n-2 characters following the first character, in which case the corresponding entropy encoder is configured to write the codeword to the corresponding bitstream, which is equal to (a, …, a) _n .

{0,1} отображаются на кодовые слова вторичного беспрефиксного кода, так что кодовое слово (bb…b) первичного усеченного унарного кода отображается на кодовое слово (c) вторичного беспрефиксного кода, и все другие кодовые слова {(a), (ba), (bba), …, (b…ba)} первичного усеченного унарного кода отображаются на кодовые слова, имеющие (d) с c≠d и c,d

{0,1} в качестве префикса и n-битовое слово в качестве суффикса, причем энтропийные кодеры используют разные n. Каждый из второго подмножества энтропийных кодеров может быть выполнен так, что n-битовое слово представляет собой n-битовое представление количества b в соответствующем кодовом слове первичного усеченного унарного кода. Однако возможны альтернативы.Additionally or alternatively, the second subset of entropy encoders 10 may be a variable length encoder configured to map variable length symbol sequences to fixed length codewords, respectively, with each of the entropy encoders of the second subset using a bijective mapping rule such that the primary truncated unary codewords code with 2 ⁿ +1 code words like {(a), (ba), (bba), …, (b…ba), (bb…b)} with b≠a and a,b

{0,1} are mapped to codewords of the secondary unprefixed code, so that codeword (bb…b) of the primary truncated unary code is mapped to codeword (c) of the secondary unprefixed code, and all other codewords {(a), (ba) , (bba), …, (b…ba)} of the primary truncated unary code are mapped to code words having (d) with c≠d and c,d

{0,1} as a prefix and an n-bit word as a suffix, with entropy encoders using different n's. Each of the second subset of entropy encoders can be configured such that an n-bit word is an n-bit representation of the number b in the corresponding codeword of the primary truncated unary code. However, alternatives are possible.

{0,1} в качестве кодового слова вторичного беспрефиксного кода в соответствующий битовый поток, и (2) если количество b меньше 2ⁿ, записи кодового слова вторичного беспрефиксного кода в соответствующий битовый поток, которое имеет (d) с c≠d и d

{0,1} в качестве префикса и n-битовое слово, определенное в зависимости от количества b, в качестве суффикса.Again, in terms of the mode of operation of the respective entropy encoder 10, each of the second subset of entropy encoders can be performed by converting the symbols sent to the corresponding entropy encoder to the corresponding bitstream, with the possibility of counting the number b in the sequence of symbols sent to the corresponding entropy encoder up to until it does, or until the number of character sequences sent to the corresponding entropy encoder reaches 2 ⁿ , where all 2 ⁿ characters in the sequence are b, and (1) if the number of b is 2 ⁿ , write c with c

{0,1} as the codeword of the secondary unprefix code to the corresponding bitstream, and (2) if the number b is less than 2 ⁿ , write the codeword of the secondary unprefix code to the corresponding bitstream, which has (d) with c≠d and d

{0,1} as a prefix and an n-bit word defined depending on the number of b as a suffix.

{0,1}, отображается на кодовое слово (с) с c

{0,1}, все три кодовых слова первичного кода, имеющие точно одну b с b≠a и b

{0,1}, отображаются на кодовые слова, имеющие (d) с c≠d и d

{0,1}, в качестве префикса и соответствующее первое 2-битовое слово из первого множества 2-битовых слов в качестве суффикса, все три кодовых слова первичного кода, имеющие точно одну a, отображаются на кодовые слова, имеющие (d) в качестве префикса и конкатенацию первого 2-битового слова, не являющегося элементом первого множества, и второго 2-битового слова из второго множества 2-битовых слов, в качестве суффикса, и в котором кодовое слово (bbb)₃ отображается на кодовое слово, имеющее (d) в качестве префикса и конкатенацию первого 2-битового слова, не являющегося элементом первого множества, и второго 2-битового слова, не являющегося элементом второго множества, в качестве суффикса. Первым 2-битовым словом кодовых слов первичного кода, имеющим точно одну b, может быть 2-битовое представление позиции b в соответствующем кодовом слове первичного кода, и вторым 2-битовым словом из кодовых слов первичного кода, имеющим точно одно a, может быть 2-битовое представление позиции a в соответствующем кодовом слове первичного кода. Однако возможны альтернативы.Also additionally or alternatively, the predefined one of the entropy encoders 10 may be a variable length encoder configured to map fixed length symbol sequences to variable length codewords, respectively, wherein the predefined entropy encoder uses a bijective mapping rule such that 2 ³ codewords of length The 3 primary code maps to the codewords of the secondary unprefixed code, so that the codeword (aaa) _{3 of} the primary code with a

{0,1}, mapped to codeword(s) with c

{0,1}, all three primary code words having exactly one b with b≠a and b

{0,1} are mapped to codewords having (d) with c≠d and d

{0,1} as a prefix and the corresponding first 2-bit word of the first set of 2-bit words as a suffix, all three codewords of the primary code having exactly one a are mapped to codewords having (d) as prefix and concatenation of the first 2-bit word not a member of the first set and the second 2-bit word of the second 2-bit word set as a suffix, and in which the codeword (bbb) ₃ is mapped to a codeword having (d ) as a prefix and the concatenation of the first 2-bit word that is not a member of the first set and the second 2-bit word that is not a member of the second set as a suffix. The first 2-bit word of primary code codewords having exactly one b may be a 2-bit representation of the position of b in the corresponding primary codeword, and the second 2-bit word of primary codewords having exactly one a may be 2 -bit representation of position a in the corresponding codeword of the primary code. However, alternatives are possible.

Again, a predefined one of the entropy encoders can be performed, while converting the symbols sent to the predefined entropy encoder into the corresponding bit stream, with the possibility of examining the symbols to the predefined entropy encoder in triplets, (1) whether the triple consists of a, in this case the predetermined entropy encoder is configured to write a codeword (c) to the corresponding bitstream, (2) whether the triple contains exactly one b, in which case the predetermined entropy encoder is configured to write a codeword having (d) as a prefix, and 2-bit representation of position b in a triple as a suffix, into the corresponding bitstream; (3) whether the triple contains exactly one a, in which case the predetermined entropy encoder is configured to write a codeword having (d) as a prefix and the concatenation of the first 2-bit word that is not a member of the first set and the 2-bit representation positions a in a triple as a suffix, into the corresponding bitstream; or (4) whether the triple consists of b, in which case the predetermined entropy encoder is configured to write a codeword having (d) as a prefix and the concatenation of the first 2-bit word that is not a member of the first set and the first 2-bit word that is not an element of the second set, as a suffix, into the corresponding bit stream.

{0,1}. Однако возможны альтернативы.On the decoding side, the embodiments just described describe a decoder for character sequence recovery 326, comprising a plurality of entropy decoders 322, each of which is configured to convert a corresponding bitstream 324 into symbols 321; assignment means 316, configured to assign multiple parameters to each symbol 326 of the character sequence to be recovered based on information contained in the previously recovered characters of the character sequence; and a selector 318 configured to extract each symbol 325 of the sequence of symbols to be recovered from a selected one of the plurality of entropy decoders, the selection depending on the number of parameters defined for the corresponding symbol. According to the embodiments just described, at least the first subset of entropy decoders 322 are variable length decoders configured to map variable length codewords onto sequences of variable length symbols, respectively, with each of the first subset entropy decoders 22 using a bijective mapping rule, according to with which codewords of a primary unprefix code with (2n-1)≥3 codewords are mapped to codewords of a secondary unprefix code that is identical to the primary prefix code, such that all but two of the codewords of the primary unprefix code are mapped to identical codewords of the secondary unprefix code , while the two codewords of the primary and secondary unprefixed codes have different lengths and are mapped onto each other alternately, with entropy encoders using different n. The first unprefixed code can be constructed so that the codewords of the first unprefixed code are (a,b) ₂ , (a,a,b) ₃ , …, (a, …, a,b) _n , (a, …, a ) _n , (b,a) ₂ , (b,b,a) ₃ , …, (b, …, b,a) _n-1 , (b, …, b) _n-1 , and two code words, mapped onto each other alternately can be (a, …, a) _n and (b, …, b) _n-1 with b≠a and a,b

{0,1}. However, alternatives are possible.

Each of the first subset of entropy encoders can be configured, when converting the corresponding bitstream into symbols, to examine the first bit of the corresponding bitstream to determine if (1) the first bit is a 0 {0,1}, in which case the corresponding entropy the encoder is configured to examine the next bits of the corresponding bitstream to determine if (1.1) b occurs with b≠a and b 0 {0,1} in the next n-1 bits following the first bit, in which case the corresponding entropy decoder is executed with the possibility of recovering the character sequence, which is equal to the first bit, followed by subsequent bits of the corresponding bitstream, up to bit b; or (1.2) does b occur in the next n-1 bits following the first bit, in which case the corresponding entropy decoder is capable of recovering a character sequence that is (b, …, b) _n-1 ; or (2) whether the first bit is equal to b, in which case the corresponding entropy decoder is configured to examine subsequent bits of the corresponding bitstream to determine (2.1) whether a occurs in the next n-2 bits following the first bit, in which case the corresponding the entropy decoder is configured to recover a character sequence that is equal to the first bit followed by subsequent bits of the corresponding bitstream up to character a; or (2.2) whether a occurs in the next n-2 bits following the first bit, in which case the corresponding entropy decoder is capable of recovering a character sequence that is equal to (a, …, a) _n .

{0,1}, так что кодовое слово (c) вторичного беспрефиксного кода отображается на кодовое слово (bb…b) первичного усеченного унарного кода, и кодовые слова, имеющие (d) с c≠d и c,d

{0,1} в качестве префикса и n-битовое слово в качестве суффикса, отображаются на соответствующее одно из других кодовых слов {(a), (ba), (bba), …, (b…ba))} первичного усеченного унарного кода, причем энтропийные декодеры используют разные n. Каждый из второго подмножества энтропийных декодеров может быть выполнен так, что n-битовое слово представляет собой n-битовое представление количества b в соответствующем кодовом слове первичного усеченного унарного кода. Однако возможны альтернативы.Additionally or alternatively, at least the second subset of entropy decoders 322 may be a variable length decoder configured to map fixed length codewords to variable length symbol sequences, respectively, wherein each of the second subset entropy decoders uses a bijective mapping rule such that the codewords of the secondary unprefixed code are mapped to codewords of the primary truncated unary code with 2 ⁿ +1 codewords like {(a), (ba), (bba), …, (b…ba), (bb…b)} with b≠a and a,b

{0,1} so that the codeword (c) of the secondary unprefixed code maps to the codeword (bb…b) of the primary truncated unary code, and codewords having (d) with c≠d and c,d

{0,1} as prefix and n-bit word as suffix, map to the corresponding one of the other codewords {(a), (ba), (bba), …, (b…ba))} of the primary truncated unary code, and entropy decoders use different n. Each of the second subset of entropy decoders may be configured such that an n-bit word is an n-bit representation of the number b in the corresponding codeword of the primary truncated unary code. However, alternatives are possible.

{0,1}, в этом случае соответствующий энтропийный декодер выполняется с возможностью восстановления последовательности символов, которая равна (bb…b)₂ ⁿ с b

{0,1}; или (2) равен ли он d с c≠d и c,d

{0,1}, в этом случае соответствующий энтропийный декодер выполняется с возможностью определения n-битового слова из n дополнительных битов соответствующего битового потока, следующих за первым битом, и восстановления из них последовательности символов, которая является типа {(a), (ba), (bba), …, (b…ba), (bb…b)} с b≠a и b

{0,1}, причем количество b зависит от n-битового слова.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, respectively, and configured, when converting the corresponding entropy decoder's bitstream into symbols, to examine the first bit of the corresponding bitstream for determining (1) whether it is equal to c with c

{0,1}, in this case the corresponding entropy decoder is performed with the possibility of recovering the symbol sequence, which is equal to (bb…b) ₂ ⁿ with b

{0,1}; or (2) is it equal to d with c≠d and c,d

{0,1}, in which case the corresponding entropy decoder is configured to determine an n-bit word from the n additional bits of the corresponding bitstream following the first bit and recover from them a character sequence that is of type {(a), (ba ), (bba), …, (b…ba), (bb…b)} with b≠a and b

{0,1}, with the number of b depending on the n-bit word.

{0,1} отображается на кодовое слово (aaa)₃ первичного кода с a

{0,1}, кодовые слова, имеющие (d) с c≠d и d

{0,1} в качестве префикса и соответствующее первое 2-битовое слово из первого множества из трех 2-битовых слов в качестве суффикса, отображаются на все три кодовые слова первичного кода, имеющих точно одну b с b≠a и b

{0,1}, кодовые слова, имеющие (d) в качестве префикса и конкатенацию первого 2-битового слова, не являющегося элементом первого множества, и второго 2-битового слова из второго множества из трех 2-битовых слов, в качестве суффикса, отображаются на все три кодовых слова первичного кода, имеющих точно одно a, и кодовое слово, имеющее (d) в качестве префикса и конкатенацию первого 2-битового слова, не являющегося элементом первого множества, и второго 2-битового слова, не являющегося элементом второго множества, в качестве суффикса, отображается на кодовое слово (bbb)₃. Первое 2-битовое слово из кодовых слов первичного кода, имеющее точно одну b, может представлять собой 2-битовое представление позиции b в соответствующем кодовом слове первичного кода, и второе 2-битовое слово из кодовых слов первичного кода, имеющее точно одну a, может представлять собой 2-битовое представление позиции a в соответствующем кодовом слове первичного кода. Однако возможны альтернативы.Additionally or alternatively, the predefined one of the entropy decoders 322 may be a variable length decoder configured to map variable length codewords to fixed length symbol sequences, respectively, wherein the predefined entropy decoder uses a bijective mapping rule such that the codewords of a secondary unprefixed code are mapped by 2 ³ codewords of length 3 of the primary code, so codeword (c) with c

{0,1} maps to codeword (aaa) _{3 of} the primary code with a

{0,1}, codewords having (d) with c≠d and d

{0,1} as a prefix and the corresponding first 2-bit word of the first set of three 2-bit words as a suffix, map to all three codewords of the primary code having exactly one b with b≠a and b

{0,1}, codewords having (d) as a prefix and the concatenation of the first 2-bit word that is not a member of the first set and the second 2-bit word from the second set of three 2-bit words as a suffix, are mapped to all three codewords of the primary code having exactly one a and a codeword having (d) as a prefix and the concatenation of the first 2-bit word that is not a member of the first set and the second 2-bit word that is not a member of the second set, as a suffix, is mapped to the code word (bbb) ₃ . The first 2-bit word of primary code codewords having exactly one b may be a 2-bit representation of the position b in the corresponding primary codeword, and the second 2-bit word of primary codewords having exactly one a may be be a 2-bit representation of the position a in the corresponding codeword of the primary code. However, alternatives are possible.

{0,1}, в этом случае заданный энтропийный декодер выполняется с возможностью восстановления последовательности символов, которая равна (aaa)₃ с a 0 {0,1}; или (2) равен ли первый бит соответствующего битового потока d с c≠d и d

{0,1}, в этом случае предварительно определенный энтропийный декодер выполняется с возможностью определения первого 2-битового слова из 2 дополнительных битов соответствующего битового потока, который следует за первым битом, и с возможностью исследования первого 2-битового слова для определения, (2.1) не является ли первое 2-битовое слово элементом первого множества из трех 2-битовых слов, в этом случае предварительно определенный энтропийный декодер выполняется с возможностью восстановления последовательности символов, которая имеет точно одну b с b≠a и b 0 {0,1}, причем позиция b в соответствующей последовательности символов зависит от первого 2-битового слова, или (2.2) является ли первое 2-битовое слово элементом первого множества, в этом случае предварительно определенный энтропийный декодер выполняется с возможностью определения второго 2-битового слова из 2 дополнительных битов соответствующего битового потока, следующих за двумя битами, из которых было определено первое 2-битовое слово, и с возможностью исследования второго 2-битового слова для определения, (3.1) не является ли второе 2-битовое слово элементом второго множества из трех 2-битовых слов, в этом случае предварительно определенный энтропийный декодер выполняется с возможностью восстановления последовательности символов, которая имеет точно одну a, причем позиция a в соответствующей последовательности символов зависит от второго 2-битового слова, или (3.2) является ли второе 2-битовое слово элементом второго множества из трех 2-битовых слов, в этом случае предварительно определенный энтропийный декодер выполняется с возможностью восстановления последовательности символов, которая равна (bbb)₃.The predetermined one of the entropy decoders may be a variable length decoder configured to map variable length codewords onto symbol sequences of three symbols each, respectively, and configured, when converting the bitstream of the corresponding entropy decoder into symbols, to examine the first bit of the corresponding bitmap. stream to determine if (1) the first bit of the corresponding bitstream c is equal to c

{0,1}, in this case, the given entropy decoder is performed with the possibility of recovering the symbol sequence, which is equal to (aaa) ₃ with a 0 {0,1}; or (2) whether the first bit of the corresponding bitstream d is equal to c≠d and d

{0,1}, in this case the predefined entropy decoder is configured to determine the first 2-bit word from the 2 additional bits of the corresponding bitstream that follows the first bit, and to examine the first 2-bit word to determine, (2.1 ) whether the first 2-bit word is an element of the first set of three 2-bit words, in which case the predefined entropy decoder is capable of recovering a character sequence that has exactly one b with b≠a and b 0 {0,1} , where the position b in the corresponding character sequence depends on the first 2-bit word, or (2.2) whether the first 2-bit word is an element of the first set, in which case the predefined entropy decoder is configured to determine the second 2-bit word from 2 additional bits of the corresponding bitstream following the two bits of which the first 2-bit was determined first word, and with the possibility of examining the second 2-bit word to determine (3.1) whether the second 2-bit word is an element of the second set of three 2-bit words, in this case, the predetermined entropy decoder is performed with the possibility of recovering the character sequence, which has exactly one a, where the position of a in the corresponding character sequence depends on the second 2-bit word, or (3.2) whether the second 2-bit word is an element of the second set of three 2-bit words, in which case the predefined entropy decoder is executed with the ability to recover the character sequence, which is equal to (bbb) ₃ .

Now, after describing the general principle of the video coding scheme, embodiments of the present invention will be described with respect to the above embodiments. In other words, the embodiments briefly described below may be implemented using the above schemes, and conversely, the above coding schemes may be implemented using and applying the embodiments briefly described below.

In the above embodiments described with respect to FIGS. 7-9, the entropy encoder and decoders of FIG. 1-6 were implemented in accordance with the PIPE principle. One particular embodiment used encoders/decoders 310 and 322 with single-probability arithmetic state. As described below, in an alternative embodiment, objects 306-310 and corresponding objects 318-322 may be replaced by a conventional entropy encoding mechanism. As an example, consider an arithmetic encoding mechanism that manages only one shared R and L state and encodes all characters into one common bitstream, thus forgoing the beneficial aspects of the present PIPE principle regarding parallel processing, but eliminating the need for partial bitstream interleaving, as further described below. By doing so, the number of probability states by which the context probabilities are estimated by updating (such as a table lookup) can be higher than the number of probability states by which the subdivision of the probability interval is performed. Those. similar to quantizing the probability interval width value before indexing into the Rtab table, the probability state index may also be quantized. The above description for a possible implementation for single encoders/decoders 310 and 322 can thus be extended to an example implementation of entropy encoders/decoders 318-322/306-310 as context-adaptive binary arithmetic coding/decoding mechanisms.

More specifically, according to an embodiment, an entropy encoder connected to the output of a parameter assigner (which serves here as a context assigner) may operate as follows:

0. The assigner 304 forwards the value of the bin along with the probability parameter. The probability is pState_current[bin].

1. Thus, the entropy encoding engine accepts: 1) valLPS, 2) bin and 3) estimate pState_current[bin] of the probability distribution. pState_current[bin] may have more states than the number of distinct probability state indices Rtab. If so, pState_current[bin] may be quantized such that, for example, by ignoring the m Least Significant Bits (LSB), where m is greater than or equal to 1, or preferably 2 or 3, to obtain p_state, i.e. an index which is then used to access the Rtab table. Quantization, however, can be excluded, i.e. p_state can be pState_current[bin].

2. R quantization is then performed (As mentioned above: either one R (and corresponding L with one common bitstream) is used/managed for all distinguishable p_state values, or one R (and corresponding L with associated partial bitstream per R/L pair ) per distinguishable p_state value, this latter case would correspond to having one encoder 310 bins per such value)

q_index=Qtab[R>>q] (or some other kind of quantization)

3. Then R _LPS and R are determined:

R _LPS =Rtab[p_state][q_index]; Rtab stored in it the precomputed values for p[p_state]⋅Q[q_index]

R=RR _LPS [i.e. R is pre-updated as if "bin" was MPS (Most Likely Symbol)]

4. Calculation of a new preliminary interval:

if (bin=1-valMPS) then

L ¬ L+R

R ¬ R _LPS

5. Renormalization of L and R, writing bits,

Likewise, an entropy decoder connected to the output of a parameter assigner (which serves here as a context assigner) can work as follows:

0. The assigner 304 forwards the value of the bin along with the probability parameter. The probability is pState_current[bin].

1. Thus, the entropy decoding engine receives a bin request along with: 1) valLPS, and 2) a probability distribution estimate pState_current[bin]. pState_current[bin] may have more states than the number of distinct probability state indices Rtab. If so, pState_current[bin] can be quantized like this, eg by neglecting m LSBs, where m is greater than or equal to 1 and preferably 2 or 3 to obtain p_state, i.e. an index which is then used to access the Rtab table. Quantization, however, can be excluded, i.e. p_state can be pState_current[bin].

2. R quantization is then performed (As mentioned above: either one R (and corresponding V with one common bitstream) is used/managed for all distinguishable p_state values, or one R (and corresponding V with associated partial bitstream per R/L pair ) per distinguishable p_state value, this last case corresponds to having one encoder 310 bins per such value)

q_index=Qtab[R>>q] (or some other kind of quantization)

3. Then R _LPS and R are determined:

R _LPS =Rtab[p_state][q_index]; Rtab retained precomputed values for p[p_state]⋅Q[q_index]

R=RR _LPS [i.e. R is pre-updated as if "bin" were MPS]

4. Definition of a bin depending on the position of the partial interval:

if(V ³ R) then

bin ¬ 1 - valMPS (bin is decoded as LPS; bin buffer selector 18 obtains the actual bin value by using this bin information and valMPS)

V¬V-R

R ¬ R _LPS

else

bin ¬ valMPS (the bin is decoded as an MPS; the actual value of the bin is obtained by using this bin information and valMPS)

5. Renormalize R, read one bit and update V,

As described above, assigner 4 assigns pState_current[bin] to each bin. The association may be performed based on context selection. Those. assigner 4 can select a context using the context index ctxIdx, which in turn has a corresponding pState_current associated with it. A probability update can be performed each time the pState_current[bin] probability has been applied to the current bin. The probability state update pState_current[bin] is performed depending on the value of the encoded bit:

If more than one context is provided, adaptation is performed by context, i.e. pState_current[ctxIdx] is used to encode and then update using the bean's current value (encoded or decoded respectively).

As discussed in more detail below, according to the embodiments now described, the encoder and decoder may optionally be implemented to operate in different modes, namely, low complexity (LC) and high efficiency (HE) mode. This is depicted mainly in relation to PIPE encoding in the following (referring to the LC and HE PIPE modes then), but the description of complexity scalability details is easily transferred to other implementations of entropy encoding/decoding mechanisms, such as the embodiment of using a single common context-adaptive arithmetic encoder/ decoder.

According to the embodiments summarized below, both entropy coding modes can share

the same syntax and semantics (for a sequence of 301 and 327 syntax elements, respectively)

the same binarization schemes for all syntax elements (currently defined for CABAC (Context Adaptive Binary Arithmetic Coding)) (i.e. binarizers can work regardless of the activated mode)

use of the same PIPE codes (i.e. bin encoders/decoders can operate regardless of the activated mode)

use of 8-bit probability model initialization values (instead of the 16-bit initialization values currently defined for CABAC)

Generally speaking, LC-PIPE differs from HE-PIPE in the complexity of processing, such as the complexity of choosing a PIPE path 312 for each bin.

For example, the LC mode can work under the following restrictions: There can be exactly one probability model for each bin (binIdx), i.e. one ctxIdx. Those. context selection/adaptation cannot be provided in LC PIPE. Specific syntax elements, such as those used to encode the remainder, may, however, be encoded using contexts, as further discussed below. In addition, all probabilistic models can be non-adaptive, i.e. all models can be initialized at the beginning of each slice with corresponding model probabilities (depending on the choice of slice type and the QP (quantization parameter) of the slice) and can be kept fixed during slice processing. For example, only 8 different probabilities can be supported models corresponding to 8 different 310/322 PIPE codes for both modeling and context encoding. Specific syntax elements for encoding the remainder, i.e. significance_coeff_flag and coeff_abs_level_greaterX (with X=1,2), the semantics of which are detailed below, may be assigned to probability models, such as (at least) groups of, for example, 4 syntax elements are encoded/decoded with the same probability of the model. Compared to CAVLC (context adaptive variable length code), the LC-PIPE mode achieves roughly the same R-D performance and the same performance.

HE-PIPE can be implemented conceptually similar to CABAC in the H.264 standard with the following differences: Binary arithmetic coding (BAC) is replaced by PIPE coding (same as in case of LC-PIPE). Each probabilistic model, i.e. each ctxIdx can be represented by pipeIdx and refineIdx, where pipeIdx, with values in the range 0-7, represents the probability of a model of 8 different PIPE codes. This change only affects the internal representation of the states, not the behavior of the state machine itself (i.e. the probability score). As discussed in more detail below, the initialization of the probability models may use 8-bit initialization values as described above. The backscan of the syntax elements coeff_abs_level_greaterX (with X=1,2), coeff_abs_level_minus3, and coeff_sign_flag (the semantics of which will become clear from the description below) can be performed along the same scan path as the forward scan (used, for example, when encoding a power map). The context derivation for encoding coeff_abs_level_greaterX (with X=1,2) can also be simplified. Compared to CABAC, the proposed HE-PIPE achieves roughly the same R-D performance with better performance.

It is easy to see that the modes just mentioned are easily generated by rendering, for example, the aforementioned context-adaptive binary arithmetic encoding/decoding mechanism, since it operates in different modes.

Thus, according to the embodiment according to the first aspect of the present invention, a decoder for decoding a data stream may be configured as shown in FIG. 11. The decoder is for decoding the data stream 401, such as the interleaved bitstream 340, into which media data, such as video data, is encoded. The decoder includes a mode switch 400 configured to activate a low complexity mode or a high efficiency mode depending on the data stream 401 . To this end, the data stream 401 may contain a syntax element, such as a binary syntax element, having a binary value of 1 in the case of a low complexity mode, which is the one to be activated, and having a binary value of 0 in the case of a high efficiency mode, which is the one to be activated. needs to be activated. Obviously, the association between a binary value and an encoding mode can be switched, and a non-binary syntax element having more than two possible values can also be used. Since the actual choice between the two modes is not yet clear before the corresponding syntax element is received, this syntax element may be contained in some forward header of the data stream 401, encoded with, for example, a fixed probability score or probability model, or written to the data stream 401 as is, i.e. .e. using bypass mode.

In addition, the decoder of FIG. 11 contains a plurality of entropy decoders 322, each of which is configured to convert the code words in the data stream 401 into partial character sequences 321. As described above, a deinterleaver 404 may be connected between the inputs of the entropy decoders 322 on the one hand and the input of the decoder of FIG. 11 where data stream 401 is being fed, on the other hand. In addition, as already described above, each of the entropy decoders 322 may be associated with a respective probability interval, with the probability intervals of the various entropy decoders together covering the entire probability interval from 0 to 1 - or 0-0.5 in the case of entropy decoders 322 dealing with with MPS and LPS, not absolute character values. Details regarding this issue have been described above. Later, the number of decoders 322 is assumed to be 8, with a PIPE index assigned to each decoder, but any other number is also possible. In addition, one of these encoders, below as an example, the one with pipe_id equal to 0, is optimized for bins having equiprobable statistics, i.e. their bin value is 1 and 0 equally likely. This decoder can simply skip bins. The corresponding encoder 310 operates in a similar manner. Even any bin manipulation can be excluded depending on the value of the most likely bin value valMPS by selectors 402 and 502 respectively. In other words, the entropy of the corresponding partial flow is already optimal.

In addition, the decoder in FIG. 11 includes a selector 402 configured to extract each symbol of a symbol sequence 326 from a selected one of a plurality of entropy decoders 322. As mentioned above, the selector 402 may be divided into a parameter assigner 316 and a selector 318. The desymbolizer 314 is configured to desymbolize the symbol sequence 326 to obtain a sequence of 327 syntax elements. The restorer 404 is configured to restore the media data 405 based on the sequence of syntax elements 327. The selector 402 is configured to make a selection depending on the activated one of the low complexity mode and the high efficiency mode, as indicated by arrow 406.

As already mentioned above, the restorer 404 may be part of a prediction block-based video decoder operating with a fixed syntax and syntax element semantics, i.e. fixed with respect to the mode selection by the mode switch 400 . Those. the design of the reducer 404 does not allow switching modes. More specifically, the restorer 404 does not increase implementation overhead due to the mode switching offered by the mode switch 400, and at least the functionality regarding residual data and prediction data remains the same regardless of the mode selected by the mode switch 400. This also applies, however, with respect to entropy decoders 322. All of these decoders 322 are reused in both modes and hence there is no additional implementation overhead, although the decoder of FIG. 11 is compatible with both modes, low complexity and high efficiency modes.

As a further aspect, it should be noted that the decoder of FIG. 11 is not only able to work with autonomous data streams either in one mode or in another mode. Instead, the decoder of FIG. 11, as well as the data stream 401, can be configured such that switching between both modes is even possible during one piece of media data, for example, during video or some piece of audio, in order, for example, to control the complexity of encoding on the decoding side depending on external or environmental conditions such as battery condition or the like. using a decoder-to-encoder feedback channel to appropriately control the mode selection in a closed loop.

Thus, the decoder of FIG. 11 works similarly in both cases, in the case when the LC mode is selected or when the HE mode is selected. The restorer 404 performs the restoration using the syntax elements and queries the current syntax element of the given syntax element type by processing or obeying some syntax structure prescription. Desymbolizer 314 requests several bins to provide a valid binarization for the syntax element requested by restorer 404. Clearly, in the case of a binary alphabet, the binarization performed by desymbolizer 314 downgrades to simply passing the corresponding bin/symbol 326 to restorer 404 as the currently requested binary syntax. element.

The selector 402, however, operates regardless of the mode selected by the mode switch 400. The mode of operation of the selector 402 tends to be more complex in the case of the high efficiency mode and less complex in the case of the low complexity mode. In addition, the following description shows that the mode of operation of the selector 402 in the low complexity mode also tends to reduce the frequency with which the selector 402 changes the selection among the entropy decoders 322 when extracting consecutive symbols from the entropy decoders 322. In other words, in the low complexity mode, there is an increased the probability that immediately subsequent symbols are extracted from the same entropy decoder among the plurality of entropy decoders 322. This, in turn, allows faster extraction of symbols from the entropy decoders 322. In high efficiency mode, in turn, the mode of operation of the selector 402 tends to result in a selection from among entropy decoders 322 where the probability interval associated with the corresponding selected entropy decoder 322 more closely matches the actual symbol statistics of the symbol currently being extracted by the selector 402, thus obtaining a better coefficient compression at the encoding side while generating the corresponding data stream in accordance with the high performance mode.

For example, the different behavior of the selector 402 in both modes can be implemented as follows. For example, selector 402 may be configured to perform, for a given symbol, a selection from among a plurality of entropy decoders 322 depending on previously extracted symbols of a symbol sequence 326 in the case of an activated high performance mode, and regardless of any previously extracted symbols of the symbol sequence in the case of an activated low complexity mode. . Dependence on previously extracted symbols of symbol sequence 326 may be from context adaptivity and/or probabilistic adaptivity. Both adaptivities may be disabled during the low complexity mode in the selector 402.

According to another embodiment, the data stream 401 may be structured into sequential parts such as slices, frames, groups of pictures, sequences of frames, or the like, and each character of the character sequence may be associated with a corresponding one of a plurality of character types. In this case, the selector 402 can be configured to change, for characters of a given character type in the current part, to select, depending on the previously retrieved characters, a sequence of characters of a given character type in the current part in the case of an activated high performance mode, and leave the selection constant in the current part. in the case of an activated low complexity mode. Those. the selector 402 may be allowed to change the selection among the entropy decoders 322 for a given character type, but these changes are limited to what happens between transitions between successive parts. By this measure, estimates of the actual symbol statistics are limited to rarely occurring transient cases, while the coding complexity is reduced for most of the time.

In addition, each character of the character sequence 326 may be associated with a corresponding one of a plurality of character types, and the selector 402 may be performed, for a given character of a given character type, to select one of a plurality of contexts depending on previously retrieved characters of the character sequence 326 and perform selecting among the entropy decoders 322 depending on the probability model associated with the selected context along with updating the probability model associated with the selected context depending on the given symbol in the case of an activated high performance mode, and performing selection of one of the plurality of contexts depending on previously extracted symbols symbol sequence 326 and performing selection among entropy decoders 322 depending on the probability model associated with the selected context, while leaving the probability model associated with the selected context constant in when the low complexity mode is activated. Those. selector 402 can use context adaptivity on some type of syntax element in both modes while suppressing probabilistic adaptation in the case of LC mode.

Alternatively, instead of completely suppressing the probabilistic adaptation, the selector 402 may simply decrease the update rate of the probabilistic adaptation of the LC mode relative to the HE mode.

In addition, in other words, possible aspects specific to LC-PIPE, ie. aspects of the LC mode can be described as follows. In particular, non-adaptive probabilistic models can be used in LC mode. A non-adaptive probabilistic model can either be hard-coded, i.e. full constant probability, or its probability is kept fixed only during slice processing and thus can be set depending on the type of slice and QP, i.e. a quantization parameter, which, for example, is signaled in the data stream 401 for each slice. Assuming that successive bins assigned to the same context adhere to a fixed probability model, it is possible to decode several of these bins in one step when they are encoded using the same pipe code, i.e. using the same entropy decoder, and the probability update after each decoded bin is omitted. Omitting probability updates saves operations during the encoding and decoding process and thus also results in a reduction in complexity and a significant simplification of the hardware design.

The non-adaptive constraint can be relaxed for all or some selected probability models such that probability updates are allowed after a number of bins have been encoded/decoded using that model. An appropriate update interval allows for probabilistic adaptation while being able to decode multiple bins at the same time.

Below is a more detailed description of the possible general and complexity-scalable aspects of the LC-pipe and HE-pipe. In particular, aspects that can be used for the LC-pipe mode and the HE-pipe mode in the same manner or with scalable complexity are described below. Scalable complexity means that the LC case is derived from the HE case by removing specific parts or by replacing them with slightly less complex ones. However, before continuing with them, it should be mentioned that the embodiment in FIG. 11 is easily portable to the above context-adaptive binary arithmetic coding/decoding embodiment: the selector 402 and the entropy decoders 322 are lumped into a context-adaptive binary arithmetic decoder that directly receives the stream 401 data and selects the context for the bean currently to be retrieved from the data stream. This is especially true for context adaptivity and/or probabilistic adaptivity. Both functionality/adaptability can be disabled, or designed to be more relaxed, during the low complexity mode.

For example, when implementing the embodiment of FIG. 11, the pipe entropy encoding stage including the entropy decoders 322 may use eight systematic variable-to-variable-codes, i. each entropy decoder 322 may be of the v2v type as described above. The principle of PIPE encoding using systematic v2v codes is simplified by limiting the number of v2v codes. In the case of a context-adaptive binary arithmetic decoder, it can manage its probabilistic states for different contexts and use it - or a quantized version of it - to subdivide the probability. Display of states of CABAC or probabilistic model, i.e. states used to update the probability in PIPE id or probability indexes to search in Rtab may be as shown in table A.

Table A: Mapping of CABAC States to PIPE Indexes

This modified coding scheme can be used as the basis for a scalable complexity video coding approach. When performing probabilistic mode adaptation, the selector 402 or the context adaptive binary arithmetic decoder respectively selects the PIPE decoder 322, i. output the pipe index to be used and the probability index in Rtab, respectively, based on the probability state index - here as an example the range is 0 to 62 - associated with the current character to be decoded - e.g. by context - using the mapping shown in table A, and updates this probability state index depending on the symbol currently being decoded, using, for example, specific table traversal transition values indicating the next probability state index to be visited in the case of MPS and LPS, respectively. In the case of LC mode, updating the latter may be excluded. Even mapping can be omitted in the case of globally fixed probabilistic models.

However, an arbitrary entropy encoding setting may be used, and the methods in this document may also be used with minor adaptations.

The above description of FIG. 11 rather referred in general terms to syntax elements and types of syntax elements. The following describes encoding with configurable complexity of transform coefficient levels.

For example, the restorer 404 may be configured to reconstruct the transform block 200 of the transform coefficient levels 202 based on a portion of the syntax element sequence regardless of whether the high performance mode or the low complexity mode is activated, wherein the portion of the syntax element sequence 327 contains, without interleaving, the syntax elements of a salience map. , defining a saliency map indicating the positions of non-zero transform coefficient levels in transform block 200, and then (followed by) defining level syntax elements defining non-zero transform coefficient levels. In particular, the following elements may be included: end position syntax elements (last_significant_pos_x, last_significant_pos_y) indicating the position of the last non-zero level of transform coefficients in the transform block; first syntax elements (coeff_significant_flag) together defining a significance map and indicating, for each position along a one-dimensional path (274) leading from the DC (direct current) position to the position of the last non-zero level of the transform coefficients in the transform block (200), as to whether whether the level of the transform coefficients in the corresponding position is non-zero or not; second syntax elements (coeff_abs_greater1) indicating, for each position of the one-dimensional path (274), where, according to the first binary syntax elements, a non-zero level of transform coefficients is located, in relation to whether the level of transform coefficients in the corresponding position is greater than one; and third syntax elements (coeff_abs_greater2, coeff_abs_minus3) indicating, for each position of the one-dimensional path where, according to the first binary syntax elements, the level of transform coefficients is greater than one, the amount by which the corresponding level of transform coefficients at the corresponding position exceeds one.

The order among the syntax elements of the end position, first, second, and third syntax elements may be the same for the high efficiency mode and the low complexity mode, and the selector 402 may be configured to perform a selection from among entropy decoders 322 for symbols from which the desymbolizer 314 obtains syntax end position elements, first syntax elements, second syntax elements, and/or third syntax elements, depending on which low complexity mode or high efficiency mode is activated.

In particular, the selector 402 may be configured, for characters of a given character type, from among the sequence of characters from which the decharacter 314 obtains first syntax elements and second syntax elements, with the possibility of selecting, for each character of the given character type, one of a plurality of contexts depending on previously retrieved characters of a given character type from among a sequence of characters, and making a selection depending on the probability model associated with the selected context in the case of the enabled high performance mode, and making the selection in a piecewise constant manner such that the selection is constant over successive contiguous subparts of the sequence in the case of the enabled mode low complexity. As described above, subparts may be measured by the number of positions that the corresponding subpart extends when measured along the one-dimensional path 274, or by the number of syntax elements of the corresponding type already encoded with the current context. Those. the binary syntax elements coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2, for example, are encoded context-adaptive with decoder 322 selection based on a probability model of the selected context in HE mode. Probabilistic adaptation is also used. In LC mode, there are also different contexts that are used for each of the binary syntax elements coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2. However, for each of these syntax elements, the context is kept static for the first part along path 274, with the context changing only when moving to the next immediately subsequent part along path 274. For example, each part can be defined to be 4, 8, 16 block 200 positions long, regardless on whether or not the corresponding syntax element is present for the corresponding position. For example, coeff_abs_greater1 and coeff_abs_greater2 are simply present for significant positions, i.e. positions where - or for which - coeff_significant_flag is equal to 1. Alternatively, each part may be defined to be 4, 8, 16 syntax elements long, regardless of whether the corresponding part thus resulting extends over more block positions. For example, coeff_abs_greater1 and coeff_abs_greater2 are simply present for meaningful positions, and thus portions of each of the four syntax elements may traverse more than 4 block positions due to positions between them along path 274 for which no such syntax element is passed, such as neither coeff_abs_greater1 , nor coeff_abs_greater2, since the corresponding level at that position is zero.

The selector 402 may be performed, for characters of a given character type in a sequence of characters from which the decharacter obtains first syntax elements and second syntax elements, with the ability to select, for each character of a given character type, one of a plurality of contexts depending on the number of previously extracted characters of a given character type in a sequence of characters that have a given character value and belong to that same subpart, or the number of previously extracted characters of a given character type in a sequence of characters that belong to that same subpart. The first alternative was true for coeff_abs_greater1 and the second alternative was true for coeff_abs_greater2 in accordance with the above specific embodiments.

In addition, the third syntax elements showing, for each position of the one-dimensional path, where, according to the first binary syntax elements, the level of the transformation coefficients is greater than one, the amount by which the corresponding level of the transformation coefficients in the corresponding position exceeds one, may contain integer syntax elements, those. coeff_abs_minus3, and the desymbolizer 314 can be configured to use a mapping function controlled by a control parameter to map the word domain of the character sequence to the integer syntax element range, and set the control parameter to the integer syntax element depending on the integer syntax elements of the previous third syntax elements, if the high efficiency mode is activated, and performing the settling in a piecewise constant manner such that the settling is constant over successive contiguous subsequences in the case of the low complexity mode enabled, wherein the selector 402 can be configured to select a given one of the entropy decoders (322) for the symbols words sequence of characters mapped to integer syntax elements that is associated with an equiprobable distribution as in high efficiency mode vnosti, and in the mode of low complexity. Those. even though the desymbolizer may operate depending on the mode selected by switch 400, as depicted by dashed line 407. Instead of setting the control parameter piecewise, the desymbolizer 314 may keep the control parameter constant during the current slice, for example, or constant globally in time.

The following describes context modeling with scalable complexity.

Evaluating the same top and left neighbor syntax element to derive a context model index is a common approach and is often used in the case of HE, for example, for the motion vector differences syntax element. However, this evaluation requires a larger buffer storage and does not allow direct encoding of the syntax element. Also, more available neighbors may be estimated to achieve higher coding performance.

In a preferred embodiment, all context modeling stage evaluation syntax elements of neighboring square or rectangular blocks or prediction units are fixed for one context model. This is equivalent to the prohibition of adaptability at the stage of choosing a context model. For this preferred embodiment, the choice of context model depending on the bin index of the bin string after binarization is not modified compared to the current design for CABAC. In another preferred embodiment, in addition to the fixed context model for the syntax elements, neighbor estimation is applied, and the fixed context model for the other bin index is also fixed. Note that the description does not include binarization and context model selection for motion vector differences and syntax elements related to encoding levels of transform coefficients.

In the preferred embodiment, only left neighbor estimation is allowed. This results in a smaller buffer in the processing chain, since the last block or string of coding units no longer needs to be stored. In another preferred embodiment, only neighbors lying in the same coding unit are evaluated.

In the preferred embodiment, all available neighbors are evaluated. For example, in addition to the top and left neighbors, the top left, top right, and bottom left neighbors are evaluated if available.

Those. selector 402 of FIG. 11 may be configured to use, for a given symbol related to a given media block, previously extracted symbols of a character sequence related to more different neighboring media blocks in the case of an activated high performance mode, to select one of a plurality of contexts and select between entropy decoders 322 depending on the probability model associated with the selected context. Those. neighboring blocks may be neighbors in time and/or space. Spatially adjacent blocks are visible, for example in FIG. 1-3. The selector 402 can then respond to the mode selection by the mode switch 400 and perform contact adaptation based on previously retrieved symbols or syntax elements related to more neighboring blocks in the case of HE mode compared to LC mode, thus reducing storage overhead as just described. .

The following describes the reduced complexity coding of motion vector differences according to the embodiment.

In the H.264/AVC video codec standard, a motion vector associated with a macroblock is transmitted by signaling a difference (motion vector difference - mvd) between the motion vector of the current macroblock and the mean motion vector predictor. When CABAC is used as an entropy encoder, mvd is encoded as follows. The integer mvd is split into an absolute and a signed part. The absolute part is binarized using a combination of a truncated unary code and a 3rd order Exponential Golomb code, referred to as the prefix and suffix of the resulting bin string. Bins related to truncated unary binarization are encoded using context models, while bins related to exponential Golomb binarization are encoded in bypass mode, i.e. with a fixed probability of 0.5 with CABAC. Unary binarization works as follows. Let the absolute integer value of mvd be n , then the resulting bin string consists of n "1s" and one trailing "0". As an example, let n=4, then the bin string is "11110". In the case of truncated unary, there is a limit, and if the value exceeds this limit, the bin string consists of n+1 "1s". For the mvd case, the limit is 9. This means that if an absolute mvd equal to or greater than 9 is encoded, resulting in 9 "1", the bin string consists of a prefix and a suffix with exponential Golomb binarization. Context modeling for the truncated unary part is done as follows. For the first bin of the bin row, the absolute mvd values from the top and left neighbor macroblocks are taken, if available (if not available, the value is assumed to be 0). If the sum for a particular component (horizontal or vertical direction) is greater than 2, the second context model is selected, if the absolute sum is greater than 32, the third context model is selected, otherwise (the absolute sum is less than 3) the first context model is selected. In addition, context models are different for each component. For the second bin in the bin string, the fourth context model is used, and the fifth context model is applied to the remaining bins of the unary part. When the absolute mvd is equal to or greater than 9, for example, all bins of the truncated unary part are "1", the difference between the absolute value of mvd and 9 is encoded in bypass mode using 3rd order exponential Golomb binarization. At the last stage, the mvd character is encoded in bypass mode.

The latest encoding method for mvd when using CABAC as an entropy encoder is specified in the current test model (HM) of the High Efficiency Video Coding (HEVC) project. In HEVC, block sizes are variable and the shape given by the motion vector is referred to as a prediction unit (PU). The top and left neighbor PU size may have different shapes and sizes than the current PU. Therefore, where appropriate, the top-left neighbor definition is now referred to as the top-left neighbor of the top-left corner of the current PU. For the encoding itself, the derivation process for the first bin may vary according to the embodiment. Instead of estimating the absolute sum of MVs from neighbors, each neighbor can be rated separately. If the neighbor's absolute MV is available and is greater than 16, the context model index may be incremented, resulting in the same number of context models for the first bin, while the encoding of the remaining absolute MVD level and sign is exactly the same as in H.264/AVC .

In the mvd encoding method described briefly above, up to 9 bins must be encoded with a context model, while the rest of the mvd value may be encoded in a low complexity traversal mode along with sign information. This present embodiment describes a method for reducing the number of bins encoded with context models resulting in an increased number of bypasses and reduces the number of context models required for mvd encoding. To do this, the cutoff value is reduced from 9 to 1 or 2. This means that only the first bin specifying whether the absolute mvd is greater than zero is encoded using the context model, or the first and second bin specifying whether the absolute mvd is greater than zero and one, is encoded using the context model, while the remaining value is encoded in bypass mode and/or using VLC code (Variable Length Code). All bins resulting from binarization using the VLC code - not using a unary or truncated unary code - are encoded using a low complexity traversal mode. In the case of PIPE, direct insertion to and from a bitstream is possible. Also, if available, a different top and left neighbor definition can be used to derive the best context model choice for the first bin.

In the preferred embodiment, Exponential Golomb codes are used to binarize the rest of the absolute MVD components. For this, the order of the exponential Golomb code is variable. The exponential Golomb code order is derived as follows. After the context model for the first bin, and therefore the index of that context model, has been derived and encoded, the index is used as an order for the exponential Golomb binarization part. In this preferred embodiment, the context model for the first bin is in the range 1-3, resulting in an index of 0-2, which is used as the exponential Golomb code. This preferred embodiment can be used for the HE case.

In an alternative to the above-described briefly method of using two times five contexts when encoding the absolute MVD to encode 9 unary code binarization bins, 14 context models (7 for each component) can also be used. For example, while the first and second bins of the unary part may be encoded with four different contexts as described previously, the fifth context may be used for the third bin and the sixth context may be used for the fourth bin, while the fifth through ninth bins are encoded with using the seventh context. Thus, in this case, even 14 contexts would be required, and just the remaining value could be encoded in a low complexity traversal mode. A method for reducing the number of bins encoded with context models, resulting in an increased number of bypasses and a decrease in the number of context models required for MVD encoding, is to reduce the cutoff value, for example, from 9 to 1 or 2. This means that only the first bin, specifying whether the absolute MVD is greater than zero will be encoded using the context model, or the first and second bins specifying whether the absolute MVD is greater than zero and one will be encoded using the appropriate context model, while the remaining value is encoded using the VLC code . All bins resulting from binarization using the VLC code are encoded using a low complexity traversal mode. In the case of PIPE, direct insertion to and from the bitstream is possible. In addition, the presented embodiment uses a different top and left neighbor definition to derive the best context model choice for the first bin. In addition, context modeling is modified such that the number of context models required for the first or first and second bins is reduced, resulting in a further reduction in memory footprint. Also, evaluation of neighbors, such as the neighbor above, may be disabled, resulting in savings in the amount of memory/row buffer required to store mvd neighbor values. Finally, the coding order of the constituents can be separated in such a way that the encoding of the prefix bins for both constituents (ie, context model encoded bins) is performed, followed by the traversal bin encoding.

In the preferred embodiment, Exponential Golomb codes are used to binarize the rest of the absolute terms mvd. For this, the order of the exponential Golomb code is variable. The exponential Golomb code order can be derived as follows. After the context model for the first bin, and therefore the index of that context model, is obtained, the index is used as the order for exponential Golomb binarization. In this preferred embodiment, the context model for the first bin is in the range 1-3, resulting in an index of 0-2, which is used as the exponential Golomb code. This preferred embodiment can be used for the HE case and the number of context models is reduced to 6. To further reduce the number of context models and therefore save memory, the horizontal and vertical components can share the same context models in another preferred embodiment. In this case, only 3 context models are required. In addition, only the left neighbor may be considered for evaluation in another preferred embodiment of the invention. In this preferred embodiment, the threshold may not be modified (eg, only a single threshold 16, resulting in an Exponential Golomb parameter of 0 or 1, or a single threshold 32, resulting in an Exponential Golomb parameter of 0 or 2). This preferred embodiment saves the line buffer required to store mvd. In another preferred embodiment, the threshold is modified to be 2 and 16. For this preferred embodiment, a total of 3 context models are required for mvd coding, and a possible exponential Golomb code parameter is in the range 0-2. In another preferred embodiment, the threshold is 16 and 32. Again, the described embodiment is suitable for the HE case.

In another preferred embodiment of the invention, the cutoff value is reduced from 9 to 2. In this preferred embodiment, the first bin and the second bin may be encoded using context models. The selection of the context model for the first bin may be performed as state of the art or modified in the manner described in the preferred embodiment above. For the second bin, a separate context model is selected, as is the state of the art. In another preferred embodiment, the context model for the second bin is selected by evaluating the mvd of the left neighbor. For this case, the context model index is the same as for the first bin, while the available context models are different than for the first bin. In total, 6 context models are required (note that the constituents share context models). Again, the exponential Golomb code parameter may depend on the index of the selected context model of the first bin. In another preferred embodiment of the invention, the exponential Golomb code parameter depends on the context model index of the second bin. The described embodiments of the invention can be used for the case of HE.

In another preferred embodiment of the invention, the context models for both bins are fixed and are not derived by evaluating either the left or top neighbors. For this preferred embodiment, the total number of context models is 2. In another preferred embodiment of the invention, the first bin and the second bin share the same context model. As a result, only one context model is required for mvd encoding. In both preferred embodiments of the invention, the exponential Golomb code parameter may be fixed and equal to 1. The described preferred embodiment of the invention is suitable for both HE and LC configurations.

In another preferred embodiment, the order of the exponential part of the Golomb code is derived independently from the context model index of the first bin. In this case, the absolute selection sum of the normal H.264/AVC context model is used to infer the order for the exponential part of the Golomb code. This preferred embodiment can be used for the HE case.

In another preferred embodiment, the order of the Exponential Golomb codes is fixed and set to 0. In another preferred embodiment, the order of the Exponential Golomb codes is fixed and set to 1. In a preferred embodiment, the order of the Exponential Golomb codes is fixed to 2. In another embodiment, the order of the Exponential Golomb codes is fixed to 2. of the Golomb codes is fixed at 3. In another embodiment, the order of exponential Golomb codes is fixed according to the shape and size of the current PU. The present preferred embodiments can be used for the LC case. Note that the fixed order part of the exponential Golomb code is considered with a reduced number of bins coded with context models.

In a preferred embodiment, neighbors are defined as follows. For the above PU, all PUs that cover the current PU are taken into account, and the PU with the highest MV is used. This also holds for the left neighbor. All PUs that close the current PU are evaluated and the PU with the highest MV is used. In another preferred embodiment, the average absolute value of the motion vector from all PUs that cover the top and left boundaries of the current PU is used to derive the first bin.

For the preferred embodiments presented above, it is possible to change the encoding order as follows. mvd must be given for horizontal and vertical direction one after the other (or vice versa). Thus, two strings of bins must be encoded. To minimize the number of mode switches for the entropy encoding mechanism (i.e. switching between bypass mode and normal mode), it is possible to encode bins encoded with context models for both components in the first step, followed by bins encoded in bypass mode in the second stage. Note that this is only a reordering.

It should be noted that bins resulting from unary or truncated unary binarization can also be represented by an equivalent fixed-length binarization of one flag per bin index specifying whether the value is greater than the current bin index. As an example, the cutoff value for the truncated unary binarization mvd is set to 2, resulting in codewords 0, 10, 11 for the values 0, 1, 2. With a corresponding fixed length binarization with one flag per bin index, one flag for bin index 0 (ie first bin) specifies whether the absolute value of mvd is greater than 0 or not, and one flag for the second bin with bin index 1 specifies whether the absolute value of mvd is greater than 1 or not. When the second flag is only encoded when the first flag is 1, this results in the same codewords 0, 10, 11.

The scalable complexity representation of the internal state of probabilistic models according to an embodiment is described below.

When HE-PIPE is set, the internal state of the probabilistic model is updated after a bean has been encoded with it. The updated state is output via a state transition table lookup using the old state and the encoded bin value. In the case of CABAC, the probabilistic model can take 63 different states, when each state corresponds to the probability of the model in the interval (0.0, 0.5). Each of these states is used to implement two model probabilities. In addition to the probability assigned to the state, 1.0 minus the probability is also used, and a flag named valMps stores whether the probability or 1.0 minus the probability is used. This results in a sum of 126 states. To use such a probabilistic model with the PIPE encoding principle, each of the 126 states must be mapped to one of the available PIPE encoders. In current implementations of PIPE encoders, this is done through the use of a lookup table. An example of such a mapping is described in Table A.

The following describes an embodiment of how the internal state of a probability model can be represented to eliminate the use of a lookup table to convert the internal state to a PIPE index. Only some simple bit masking operations are needed to extract the PIPE index from the internal state variable of the probabilistic model. This new scalable complexity representation of the internal state of a probabilistic model is designed in a two-level fashion. For applications where a low complexity operation is required, only the first level is used. It only describes the pipe index and the valMps flag, which is used to encode or decode the associated beans. In the case of the described PIPE entropy coding scheme, the first layer can be used to distinguish between 8 different model probabilities. So the first level will need 3 bits for pipeIdx, and one extra bit for the valMps flag. With the second level, each of the first level coarse probability ranges is refined into slightly smaller intervals that support the representation of probabilities at higher resolutions. This more detailed representation allows for more accurate operation of probability estimators. In general, it is suitable for coding applications that aim for high RD performance. As an example, this scalable complexity representation of the internal state of probabilistic models using PIPE is depicted as follows:

The first and second levels are stored in a single 8-bit memory. 4 bits are required to store the first level - an index that defines the PIPE index with the MPS value on the most significant bit - and the other 4 bits are used to store the second level. To implement the behavior of the CABAC probability estimator, each PIPE index has a specific number of refinement indexes allowed depending on how many CABAC states have been mapped to the PIPE index. For example, to display in table A, the number of CABAC states per PIPE index is displayed in table B.

Table B: Number of CABAC states per PIPE index for Table A example.

During the encoding or decoding process of a bin, the PIPE index and valMps can be accessed directly through the application of a simple bit mask or bit shift operations. Low complexity coding processes require 4 bits of the first layer, and high efficiency coding processes may additionally use 4 bits of the second layer to perform an update of the probability model of the CABAC probability estimator. To accomplish this update, a state transition lookup table can be designed that makes the same state transitions as the original table, but using a two-level representation with scalable state complexity. The original state transition table consists of two, multiplied by 63 elements. For each input state, it contains two output states. When using a representation with scalable complexity, the size of the state transition table does not exceed 2 times 128 elements, which is a reasonable increase in the size of the table. This increase depends on how many bits are used to represent the refinement index and accurately mimic the behavior of the CABAC probability estimator, four bits are needed. However, other probability estimators can be used that can operate on a reduced CABAC state set such that no more than 8 states are allowed per pipe index. Therefore, memory consumption can be matched with a given level of complexity of the encoding process by adapting the number of bits used to represent the refinement index. Compared to the internal probability state of a model with CABAC - where there are 64 probability state indices - the use of table lookups to map model probabilities to a specific PIPE code is eliminated, and no additional transformation is required.

The update of the context model with scalable complexity according to the embodiment is described below.

To update the context model, its probability state index may be updated based on one or more previously encoded bins. In a HE-PIPE setup, this update is performed after each bin has been encoded or decoded. Conversely, in an LC-PIPE installation, this update may never be performed.

However, it is possible to update context models with scalable complexity. Those. the decision whether to update the context model or not may be based on various aspects. For example, the encoder setting may not update only for specific context models, like, for example, the context models of the coeff_significant_flag syntax element, and always update for all other context models.

In other words, the selector 402 can be configured, for symbols of each of a plurality of given symbol types, to perform a selection among entropy decoders 322 depending on the corresponding probability model associated with the corresponding given symbol, so that the number of given symbol types is smaller in the low complexity mode. compared to high efficiency mode.

In addition, the criteria for controlling whether to update the context model or not may be, for example, the size of the bitstream packet, the number of bins decoded so far, or the update is performed only after encoding a particular fixed or variable number of bins for the context model.

With this scheme for deciding whether to update the context models or not, updating the context model with scalable complexity can be implemented. This allows you to increase or decrease the proportion of bins in the bitstream for which context model updates are performed. The greater the number of context model updates, the better the coding efficiency and the higher the computational complexity. Thus, updating the context model with scalable complexity can be achieved with the described scheme.

In the preferred embodiment, the context model update is performed on the beans of all syntax elements except for the syntax elements coeff_significant_flag, coeff_abs_greater1 and coeff_abs_greater2.

In another preferred embodiment, the context model update is performed only for the coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 syntax element beans.

In another preferred embodiment, a context model update is performed for all context models when encoding or decoding of a slice begins. After a specified number of transform blocks have been processed, updating the context model is inhibited for all context models until the end of the slice is reached.

For example, selector 402 can be configured, for symbols of a given symbol type, to perform selection from among entropy decoders 322 depending on the probability model associated with the given symbol type, with or without updating the associated probability model, such that the length of the learning phase of the symbol sequence , on which character selection of a given character type is performed along with updating, is shorter in the low complexity mode compared to the high efficiency mode.

Another preferred embodiment is identical to the previously described preferred embodiment, but uses a scalable complexity representation of the internal state of context models such that one table stores the "first part" (valMps and pipeIdx) of all context models and a second table stores the "second part" (refineIdx) of all context models. When updating the context model is disabled for all context models (as described in the previous preferred embodiment), the table storing the "second part" is no longer needed and can be dropped.

The update of the context model for a sequence of bins according to an embodiment is described below.

In the LC-PIPE configuration, bins of syntax elements of type coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 are grouped into subsets. For each subset, a single context model is used to encode its bins. In this case, updating the context model may be performed after encoding a fixed number of bins of a given sequence. This is indicated by a multibin update in the following. However, this update may differ from an update using only the last encoded bean and the internal state of the context model. For example, for each bean that has been encoded, one step of updating the context model is performed.

The following are examples for encoding an exemplary subset of 8 bins. The letter "b" denotes the decoding of the bean, and the letter "u" denotes the update of the context model. In the case of LC-PIPE, only decoding of the bins is performed without performing updates to the context model:

b b b b b b b b

In the case of HE-PIPE, after decoding each bin, the context model is updated:

b u b u b u b u b u b u b u b u

To reduce the complexity to some extent, updating the context model can be performed after a sequence of bins (in this example, after every 4 bins, updates of these 4 bins are performed):

b b b b u u u u b b b b u u u u

Those. selector 402 may be configured, for symbols of a given symbol type, to perform a selection from among entropy decoders 322 depending on the probability model associated with the given symbol type with or without updating the associated probability model such that the rate at which symbol selection is performed of a given symbol type along with an update, less in low complexity mode compared to high efficiency mode.

In this case, after decoding 4 bins, 4 update steps follow based on the 4 bins just decoded. Note that these four update steps can be performed in one single step by using a special lookup table for the lookup. This lookup table stores, for each possible combination of 4 bins and each possible internal state of the context model, the resulting new state after the four normal update steps.

In some mode, a multibin update is used for the coeff_significant_flag syntax element. For all other syntax element beans, the context model update is not used. The number of bins that are encoded before the multi-bin update step is set to n. When the number of set bins is not a multiple of n, 1-n-1 bins remain at the end of the subset after the last multi-bin update. For each of these bins, a normal one-bin update is performed after all of these bins have been encoded. The number n can be any positive number greater than 1. The other mode can be identical to the previous mode, except that the multi-bin update is performed for arbitrary combinations of coeff_significant_flag, coeff_abs_greater1, and coeff_abs_greater2 (only instead of coeff_significant_flag). Thus, this mode will be more difficult than the other. All other syntax elements (where multi-bin update is not used) can be divided into two disjoint subsets, where one of the subsets uses single-bin update and the other subset does not use context model update. Any possible non-overlapping subsets are valid (including the empty subset).

In an alternative embodiment, the multi-bin update may be based only on the last m bins that are encoded just before the multi-bin update step. m can be any natural number less than n. Thus, decoding can be done like the following:

b b b b u u b b b b u u b b b b u u b b b b …

at n=4 and m=2.

Those. selector 402 can be configured, for symbols of a given symbol type, to perform a selection from among entropy decoders 322 depending on the probability model associated with the given symbol type, along with updating the associated probability model of each nth symbol of the given symbol type based on m the most recent symbols of the given symbol type, so that the n/m ratio is higher in the low complexity mode compared to the high efficiency mode.

In another preferred embodiment, for the coeff_significant_flag syntax element, a context modeling scheme using a local template, as described above for the HE-PIPE configuration, can be used to assign context models to the bins of the syntax element. However, the context model update is not used for these beans.

In addition, the selector 402 may be configured, for symbols of a given symbol type, to select one of several contexts depending on the number of previously extracted symbols of the character sequence and perform selection from among entropy decoders 322 depending on the probabilistic model associated with the selected context, so that the number of contexts, and/or the number of previously extracted symbols, is less in the low complexity mode compared to the high efficiency mode.

Probabilistic model initialization using 8-bit initialization values

This section describes the process of initializing the internal state with scalable complexity of probabilistic models using the so-called 8-bit initialization value instead of two 8-bit values, as is the case with the current H.264/AVC video coding standard. It consists of two parts that are comparable to the initialization value pairs used for probability models in CABAC in H.264/AVC. The two parts represent the two parameters of a linear equation for calculating the initial state of a probabilistic model representing a particular probability (for example, as a PIPE index) from QP:

The first part describes slope, and it uses the internal state dependency on the quantization parameter (QP) that is used during encoding or decoding.

The second part describes the PIPE index for a given QP, as well as valMps.

Two different modes are available for initializing a probability model using a given initialization value. The first mode is referred to as QP-independent initialization. It only uses the PIPE index and valMps defined in the second part of the initialization value for all QPs. This is identical to the case where the slope is 0. The second mode is referred to as QP-dependent initialization, and it additionally uses the slope of the first part of the initialization value to modify the PIPE index and determine the refinement index. The two parts of the 8-bit initialization value are shown as follows:

It consists of two 4-bit parts. The first part contains an index that points to 1 of the 16 different slopes specified, which are stored in the array. The target slopes consist of 7 negative slopes (slope index 0-6), one slope that is zero (slope index 7), and 8 positive slopes (slope index 8-15). The slopes are shown in Table C.

Table C

All values are scaled by a factor of 256 to avoid floating point operations. The second part is the PIPE index, which represents the ascending probability valMps=1 between the probability interval p=0 and p=1. In other words, the n PIPE encoder must operate at a higher model probability than the n-1 PIPE encoder. For each probability model, one PIPE probability index is available and it identifies the PIPE encoder whose probability interval contains the probability p _valMPs=1 for QP=26.

Table D: Mapping of the second part of the initialization value to the PIPE and valMps encoders: UR - unary-to-rice-code; TB - three-bin code, BP - bin-pipe code, EP - equiprobability (not encoded)

QP and an 8-bit initialization value are required to calculate the initialization of the internal state of probabilistic models by calculating a simple linear equation in the form y=m*(QP-QPref)+256*b. Note that m defines the slope, which is taken from table C by using the slope index (the first part of the 8-bit initialization value), and b denotes the PIPE encoder at QPref=26 (the second part of the 8-bit initialization value: "PIPE Probability Index") . Then valMPS is 1 and pipeIdx is (y-2048)>>8 if y is greater than 2047. Otherwise, valMPS is 0 and pipeIdx is (2047-y)>>8. The refinement index is (((y-2048)&255)*numStates)>>8 if valMPS is 1. Otherwise, the refinement index is (((2047-y)&255)*numStates)>>8. In both cases, numStates is equal to the number of CABAC states in pipeIdx, as shown in table B.

The above scheme not only can be used in combination with PIPE encoders, but also in connection with the above mentioned CABAC schemes. In the absence of PIPE, the number of CABAC states, i.e. probabilistic states between which the state transition occurs when updating the probability (pState_current[bin]) on PIPE Idx (i.e. the corresponding most significant bits of pState_current[bin]) are then only a set of parameters that implement, in fact, piecewise linear interpolation CABAC states depending on QP. In addition, this piecewise linear interpolation can also be virtually disabled if the numStates parameter uses the same value for all PIPE Idx. For example, setting numStates to 8 for all cases gives a total of 16*8 states, and refinement index calculation simplifies to ((y-2048)&255)>>5 for valMPS equal to 1 or ((2047-y)&255)>>5 for valMPS equal to 0. For this case, it is very simple to map the representation using valMPS, PIPE Idx and refinement idx back to the representation used by the original CABAC in H.264/AVC. The CABAC state is defined as (PIPE Idx<<3)+Idx refinement. This aspect is further described below with respect to FIG. 16.

If the slope of the 8-bit initialization value is not equal to zero, or if QP is not equal to 26, then it is necessary to calculate the internal state by applying a linear equation with the QP of the encoding or decoding process. In the case of a slope equal to zero, or that the QP of the current encoding process is 26, the second part of the 8-bit initialization value can be used directly to initialize the internal state of the probabilistic model. Otherwise, the decimal part of the resulting internal state can be further used to determine the refinement index in high performance coding applications by linear interpolation between the specific PIPE encoder limits. In this preferred embodiment, linear interpolation is performed by simply multiplying the decimal part by the total number of refinement indices available for the current PIPE encoder and mapping the result to the nearest integer refinement index.

The process of initializing the internal state of probabilistic models can vary with respect to the number of states of the PIPE probability index. In particular, the double presence of the equiprobable mode using the E1 PIPE encoder, i.e. using two different PIPE indices to distinguish between MPS equal to 1 or 0 can be avoided as follows. Again, the process may be called at the start of slice data parsing, and the input of this process may be an 8-bit initialization value, as shown in Table E, which, for example, is transmitted in the bitstream for each context model to be initialized.

Table E: Setting 8 bits of initValue for a probabilistic model

The first 4 bits define the slope index and are extracted by masking bits b4-b7. For each slope index, slope(m) is specified and displayed in Table F.

Table F: Variable m values for slopeIdx

Bits b0-b3, the last 4 bits of the 8-bit initialization value, identify probIdx and describe the probability at a given QP. probIdx 0 indicates the highest probability for symbols with a value of 0 and, accordingly, probIdx 14 indicates the highest probability for symbols with a value of 1. Table G depicts, for each probIdx, the corresponding pipeCoder and its valMps.

Table G: Mapping of the last 4-bit part of the initialization value to the PIPE and valMps encoders: UR - unary-to-Rice code, TB - three-bin code, BP - bin-pipe code, EP - equiprobability (not encoded)

With both values, the calculation of the internal state can be performed by using a linear equation like y=m*x+256*b, where m denotes the slope, x denotes the QP of the current slice, and b is derived from probIdx, as shown in the following description. All values in this process are scaled by a factor of 256 to avoid floating point operations. 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 G, the internal state consists of valMPs, pipeIdx and refineIdx.

Table H: Setting the internal state of the probabilistic model

The assignment of refineIdx and pipeIdx is similar to the internal state of CABAC probabilistic models (pStateCtx) and is represented in H.

Table I: Purpose of pipeIdx, refineIdx and pStateCtx

In a preferred embodiment, probIdx is determined at QP26. Based on the 8-bit initialization value, the internal state (valMps, pipeIdx and refineIdx) of the probability model is processed as described in the following pseudocode:

As shown in the pseudocode, refineIdx is calculated by linear interpolation between the pipeIdx interval and quantization of the result into the corresponding refineIdx. The offset specifies the total number of refineIdx for each pipeIdx. The interval [7, 8) fullCtxState/256 is halved. Interval [7, 7,5) maps to pipeIdx=0 and valMps=0, and interval [7,5, 8) maps to pipeIdx=0 and valMps=1. Fig. 16 shows the internal state inference process and maps fullCtxState/256 to pStateCtx.

Note that the slope indicates the relationship between probIdx and QP. If the slopeIdx of the 8-bit initialization value is 7, the resulting internal state of the probabilistic model is the same for all slice QPs - hence the internal state initialization process is independent of the slice's current QP.

That is, the selector 402 may initialize the pipe indices to be used when decoding the next portion of the data stream, such as the full stream or the next slice, using a syntax element indicating the quantization step size QP used to quantize that portion's data, such as coefficient levels transforms contained within it using the given syntax element as an index into a table that can be shared between both modes, LC and HE. A table, such as table D, may contain pipe indices for each character type, for the corresponding QPref reference value, or other data for each character type. Depending on the actual QP of the current part, the selector can calculate the value of the pipe index using the corresponding table entry a indexed by the actual QP or by the QP itself, for example by multiplying a by (QP-QPref). The only difference in LC and HE mode: The selector only calculates the result with less precision in case of LC than in HE mode. A selector, for example, could simply use the integer part of the result of the evaluation. In HE mode, a higher precision remainder, such as a fractional part, is used to select one of the available refinement indexes for the corresponding pipe index, as indicated by the lower precision or integer part. The refinement index is used in HE mode (potentially less rarely also in LC mode) to perform probabilistic adaptation, for example, by using the above table traversal. If leaving the available indices for the current pipe index at the higher bound, then the higher pipe index is chosen next, minimizing the refinement index. If leaving the available indices for the current pipe index at a lower bound, then the next lower pipe index is chosen next, maximizing the refinement index to the maximum available for the new pipe index. The pipe index along with the refinement index determines the probability state, but to select from among partial streams, the selector simply uses the pipe index. The Refinement Index is simply for more precise probability tracking, or for higher accuracy.

The above description has also shown, however, that complexity scalability can be achieved regardless of the PIPE coding principle of FIG. 7-10 or CABAC using the decoder shown in FIG. 12. The decoder of FIG. 12 is designed to decode a data stream 601 into which media data is encoded, and includes a mode switch 600 configured to activate a low complexity mode or a high efficiency mode depending on the data stream 601, as well as a desymbolizer 602 configured to the ability to desymbolize the sequence 603 of characters obtained - either directly or by entropy decoding, for example - from the data stream 601 to obtain integer syntax elements 604, using a mapping function controlled by a control parameter to map the word definition area of the character sequence to the range of integer syntax elements. The restorer 605 is configured to restore the media data 606 based on the integer syntax elements. The desymbolizer 602 is configured to perform desymbolization such that the control parameter changes according to the data stream at the first rate in the case of the high performance mode enabled, and the control parameter is constant regardless of the data stream or changes depending on the data stream but at the second rate, which is less than the first rate, in the case of the activated low complexity mode, as shown by arrow 607. For example, the control parameter may be changed in accordance with previously desymbolized symbols.

Some of the above embodiments used an aspect of FIG. 12. The syntax elements coeff_abs_minus3 and MVD in sequence 327, for example, were binarized in the desymbolizer 314 depending on the selected mode, as indicated by 407, and the restorer 605 used these syntax elements to restore. Obviously, both aspects of FIG. 11 and 19 are easily combined, but an aspect of FIG. 12 can also be combined with other coding environments.

See, for example, the motion vector difference coding noted above. The desymbolizer 602 may be configured such that the mapping function uses a truncated unary code to perform mapping in the first domain interval of integer syntax elements below the cutoff value and a combination of a truncated unary code prefix for the cutoff value and a VLC codeword suffix in the second domain interval determining integer syntax elements, including and above cutoff values, wherein the decoder may comprise an entropy decoder 608 configured to derive the number of first bins of the truncated unary code from the data stream 601 using entropy decoding with varying probability estimation, and the number of second bins of the VLC codeword, using the bypass mode with constant equiprobability. In the HE mode, entropy coding may be more complex than in LC coding, as indicated by arrow 609. That is, context adaptiveness and/or probabilistic adaptation may be applied in the HE mode and suppressed in the LC mode, or the complexity may be scaled in other metrics as discussed above with respect to various embodiments.

An encoder corresponding to the decoder of FIG. 11 for encoding media data into a data stream is shown in FIG. 13. It may include an inserter 500 configured to signal in the data stream 501 the activation of a low complexity mode or a high efficiency mode, a constructor 504 configured to precode media data 505 into a sequence 506 of syntax elements, a symbolizer 507 configured to symbolize the sequence 506 syntax elements into a character sequence 508, a plurality of entropy encoders 310, each of which is configured to convert partial character sequences into data stream codewords, and a selector 502, configured to direct each character of the character sequence 508 to a selected one of the plurality of entropy encoders 310, wherein the selector 502 is configured to make a selection depending on which one of the low complexity mode and the high efficiency mode is activated, as indicated by arrow 511. The interleaver 510 may optionally be provided to interleave the codewords of encoders 310.

An encoder corresponding to the decoder of FIG. 12 for encoding media data into a data stream is shown in FIG. 14, comprising an inserter 700 configured to signal in the data stream 701 an activation of a low complexity mode or a high efficiency mode, a constructor 704 configured to precode media data 705 into a sequence 706 of syntax elements containing an integer syntax element, and a symbolizer 707 configured to the ability to symbolize an integer syntax element, using a mapping function controlled by a control parameter to map the domain of integer syntax elements to the range of words of a sequence of characters, and the symbolizer 707 is configured to perform symbolization, so that the control parameter changes in accordance with the data stream at a first rate in the case of high performance mode enabled, and the control parameter is constant regardless of the data flow or varies depending on the data flow, but with the second th rate, which is less than the first rate, in the case of an activated low complexity mode, as indicated by arrow 708. The symbolization result is encoded into data stream 701.

Again, it should be mentioned that the embodiment of FIG. 14 easily translates to the above embodiment of context-adaptive binary arithmetic encoding/decoding: selector 509 and entropy encoders 310 are brought together into a context-adaptive binary arithmetic encoder that will output the data stream 401 directly and select the context for the bin currently to be output. from the data stream. This is especially true for context adaptivity and/or probabilistic adaptivity. Both functionality/adaptability may be disabled, or may be designed to be more relaxed, during the low complexity mode.

It has been briefly noted above that the mode switching capability described in relation to some of the above embodiments may be omitted according to alternative embodiments. To make this clear, reference is made to FIG. 16, which summarizes the above description insofar as only the exclusion of the mode switching capability distinguishes the embodiment of FIG. 16 from the above embodiments. In addition, the following description shows the benefits resulting from initializing the context probability estimates using less precise parameters for slope and bias compared to, for example, H.264.

In particular, FIG. 16 shows a decoder for decoding video 405 from a data stream 401 for which the horizontal and vertical components of the motion vector differences are encoded using the binarizations of the horizontal and vertical components, the binarizations being equal to the truncated unary code of the horizontal and vertical components, respectively, in the first interval of the horizontal and vertical components definition domain. below the cutoff value, and the prefix combination as a truncated unary code. The cutoff value and the exponential Golomb code suffix of the horizontal and vertical components, respectively, in the second interval of the horizontal and vertical components definition area inclusive and above the cutoff value, where the cutoff value is 2, and the exponential Golomb code has an order of 1. The decoder comprises an entropy decoder 409 made , for horizontal and vertical motion vector difference components, with the ability to derive the truncated unary code from the data stream using context-adaptive binary entropy decoding with exactly one context per bin position of the truncated unary code that is common to the horizontal and vertical motion vector difference components , and exponential Golomb code, using the constant equiprobability bypass mode to obtain binarizations of motion vector differences. More specifically, as described above, entropy decoder 409 may be configured to derive the number of binarization bins 326 from data stream 401 using binary entropy decoding, such as the aforementioned CABAC scheme, or binary PIPE decoding, i. using a design including multiple entropy decoders 322 operating in parallel along with an appropriate selector/assignor. The desymbolizer 314 debinarizes the binarizations of the motion vector difference syntax elements to obtain integer values of the horizontal and vertical motion vector difference components, and the decompressor 404 reconstructs the video based on the integer values of the horizontal and vertical motion vector difference components.

To explain this in more detail, reference is made briefly to FIG. 18. Position 800 represents one motion vector difference, i. e. a vector representing the prediction residual between the predicted motion vector and the actual/recovered motion vector. Also shown are the horizontal and vertical components 802x and 802y. They may be transmitted in units of pixel positions, i.e. pixel pitch, or sub-pixel positions such as half a pixel pitch or a quarter pixel pitch or the like. The horizontal and vertical _x,y components 802 are integers. Their range extends from zero to infinity. The sign value can be handled separately and is no longer discussed here. In other words, the description summarized herein focuses on the magnitude of the motion vector differences 802x,y. The domain is shown at 804. On the right side of the domain axis 804 of FIG. 19 depicts, associated with vertically stacked positive component values 802x,y, a binarization into which the corresponding candidate value is mapped (binarized). As can be seen, below the cutoff value of 2, only the truncated unary code 806 takes place, while the binarization has, as a suffix, also the exponential Golomb code of order 808 of the possible values equal to or greater than the cutoff value of 2, in order to continue binarization for the remainder an integer value above the cutoff value minus 1. For all bins, only two contexts are provided: one for the position of the first bin of the binarizations of the horizontal and vertical components 802x,y, and another one for the position of the second bin of the truncated unary code 806 of both the horizontal and vertical components 802x, y. For the bin position of the exponential Golomb code 808, the equiprobable bypass mode is used by the entropy decoder 409. That is, both bin values are assumed to occur with equal probability. The probability score for these bins is fixed. In comparison, the probability estimate associated with the just-mentioned two bin contexts of the truncated unary code 806 adapts continuously during decoding.

Before describing in more detail, with respect to how the entropy decoder 409 can be implemented, in accordance with the above description, in order to perform the tasks just mentioned, the description now focuses on a possible implementation of the restorer 404, which uses the motion vector differences 800 and its integer values, obtained by the desymbolizer 314 by rebinarizing the code bins 106 and 108, the rebinarization being shown in FIG. 18 using the arrows 810. In particular, the restorer 404 as described above can extract from the data stream 401 information regarding the subdivision of the currently reconstructed image into blocks, among which at least some are subject to motion compensation prediction. Fig. 19 shows the image to be reconstructed representatively at 820 and the blocks of the just-mentioned sub-image 120 for which motion-compensated prediction is used to predict the image content therein at 822. As described with respect to FIG. 2A-2C, there are different possibilities for subdivision and block sizes 122. To avoid transmitting a motion vector difference 800 for each of these blocks 122, decomposer 404 can use a merge principle whereby the data stream additionally transmits merge information in addition to subdivision information. or, in the absence of division information, in addition to the fact that the division is fixed. The merge information signals the restorer 404 on which of the blocks 822 to generate merge groups. By this measure, it is possible for the restorer 404 to apply some motion vector difference 800 to the entire block merge group 822. Of course, on the coding side, the transmission of the merge information is subject to a trade-off between division transmission costs (if present), merger information transmission costs, and transmission costs. motion vector differences, which decrease as the size of the fusion groups increases. On the other hand, increasing the number of blocks per merge group reduces the adaptation of the motion vector difference for that merge group to the actual needs of the individual blocks of the corresponding merge group, thereby obtaining less accurate motion-compensated predictions of the motion vector differences of these blocks and necessitating higher transmission overhead for transmitting the prediction residual as, for example, a level of transform coefficients. Therefore, a compromise is made on the encoding side accordingly. In either case, however, the fusion principle results in motion vector differences for the fusion groups, representing less spatial cross-correlation. See, for example, FIG. 19, which depicts membership in a certain merge group by shading. Obviously, the actual movement of the image content in these blocks was so similar that the encoding side decided to merge the respective blocks. However, there is little correlation with the movement of image content in other merge groups. Therefore, the restriction to use just one context per bin of the truncated unary code 806 does not adversely affect the efficiency of entropy coding, since the fusion principle already sufficiently provides for spatial cross-correlation between the movement of the contents of neighboring images. The context may simply be selected based on the fact that the bin is part of the binarization of the _x,y component 802 of the motion vector difference and the position of the bin, which is either 1 or 2 due to the cutoff value being two. Therefore, other already decoded bins/syntax elements/constituents 802 _x,y mvd do not affect context selection.

Similarly, the restorer 404 can be configured to further reduce the information content to be transferred by motion vector differences (other than spatial and/or temporal motion vector prediction) by using a multi-hypothesis prediction principle whereby, first, a list of motion vector predictors for each a merge block or group, then explicitly or implicitly transmitting in the data stream information about the predictor index to be actually used to predict motion vector differences. See, for example, open box 122 in FIG. 20. The restorer 404 may provide different predictors for the motion vector of a given block, for example, by predicting the motion vector spatially, such as from left, from top, a combination of both, and the like, and temporally predicting the motion vector from the motion vector of the previously co-located portion. decoded video image and additional combinations of the above predictors. These predictors are sorted by the restorer 404 in a predictable manner that is predictable at the coding side. Some information is transmitted for this purpose in the data stream and used by the restorer. Those. some advice is contained in the data stream as to which predictor from a given ordered list of predictors will actually be used as a predictor for the given block's motion vector. This index may be explicitly passed in the data stream for this block. However, it is also possible that the index is first predicted and then only its prediction is transmitted. There are also other possibilities. In any case, the prediction scheme just mentioned makes it possible to obtain a very accurate prediction of the motion vector of the current block, and hence the content requirement imposed on the motion vector difference is reduced. Therefore, limiting the context adaptive entropy coding to only two bins of the truncated unary code and reducing the cutoff value to 2, as described with respect to FIG. 18, as well as setting the exponential Golomb code order to 1, has no negative effect on the coding efficiency, since the motion vector differences show, due to the high prediction efficiency, a frequency histogram, according to which the higher values of the 802x,y components of the motion vector differences are visited less frequently. . Even omitting any difference between the horizontal and vertical components is good for efficient prediction, since the prediction tends to work equally well in both directions of prediction accuracy.

It should be noted that in the above description, all the details provided with FIG. 1-15 are also transferable to the objects shown in FIG. 16, such as, for example, that relate to the functionality of the desymbolizer 314, decompressor 404, and entropy decoder 409. However, for completeness, some of these details are again briefly described below.

For a better understanding of the prediction scheme just outlined, see FIG. 20. As just described, the constructor 404 may obtain different predictors for the current block 822 or the current block merge group, these predictors being shown as solid line vectors 824. The predictors may be obtained by spatial and/or temporal prediction, and in addition, arithmetic mean operations or the like may be used so that the individual predictors may be obtained by the reconstructor 404 such that they correlate with each other. Regardless of the manner in which the vectors 826 were obtained, the restorer 404 sequentially presents or sorts these predictors 126 into an ordered list. This is represented by numbers 1-4 in Fig. 21. Preferably, the sorting process is uniquely defined so that the encoder and decoder can work in sync. Then the index just mentioned can be obtained by the restorer 404 for the current block, or merge group, from the data stream, explicitly or implicitly. For example, the second predictor "2" may be selected, and the reconstructor 404 adds the motion vector difference 800 to this selected predictor 126, thus obtaining a finally reconstructed motion vector 128, which is then used to predict, by motion compensated prediction, the contents of the current block/ merge groups. In the case of a merge group, it will be possible that the restorer 404 contains additional motion vector differences provided for the blocks of the merge group to further refine the motion vector 128 with respect to the individual blocks of the merge group.

Thus, continuing with the description of the implementations of the objects shown in FIG. 16, it may be that the entropy decoder 409 is configured to derive the truncated unary code 806 from the data stream 401 using binary arithmetic decoding or binary PIPE encoding. Both principles have been described above. In addition, the entropy decoder 409 may be configured to use different contexts for two bin positions of the truncated unary code 806, or alternatively even the same context for both bins. Entropy decoder 409 may be configured to perform a probability state update. Entropy decoder 409 can do this, for the bin currently derived from truncated unary code 806, by transitioning from the current probability state associated with the context selected for the currently derived bin to a new probability state depending on the bin derived in this moment. See the above tables Next_State_LPS and Next_State_MPS, which is table searched by the entropy decoder in addition to the other steps 0-5 listed above. In the above description, the current probability state has been referred to by pState_current. It is defined for the relevant context of interest. The entropy decoder 409 may be configured to binary arithmetic decode the bin currently to be derived from the truncated unary code 806 by quantizing the width value of the current probability interval, i. R representing the current probability interval to obtain the probability interval index, q_index, and subdivide the interval by indexing the table element among the table elements using the probability interval index and the probability state index, i.e. p_state, which in turn depends on the current probability state associated with the context selected for the bin currently being inferred, to obtain a division of the current probability interval into two partial intervals. In the above briefly described embodiments, these partial intervals were associated with the most likely and least likely symbol. As described above, entropy decoder 409 may be configured to use an eight-bit representation for the current probability interval width value R, capturing, for example, the two or three most significant bits of the eight-bit representation and quantizing the current probability interval width value. The entropy decoder 409 may further be configured to select from among the two partial bins based on an offset state value from the interior of the current probability bin, namely V, updating the probability bin width value R and the offset state value, and guessing the bin value to be output to now using the selected partial interval, and renormalizing the updated probability interval width value R and the offset state value V, including continuing to read bits from the data stream 401 . The entropy decoder 409, for example, may be configured to binary arithmetic decode a bin from the Exponential Golomb code by halving the current probability interval width value to obtain a division of the current probability interval into two partial intervals. Bisection corresponds to a probability estimate that is fixed at 0.5. It can be implemented by a simple bit shift. The entropy decoder may further be configured, for each motion vector difference, to derive a truncated unary code for the horizontal and vertical components of the corresponding motion vector difference from the data stream 401, before the exponential Golomb code of the horizontal and vertical components of the corresponding motion vector difference. Through this measure, the entropy decoder 409 can exploit that more bins together form a series of bins for which the probability score is fixed, namely 0.5. This can speed up the entropy decoding procedure. On the other hand, the entropy decoder 409 may prefer to maintain order among the motion vector differences by first deriving the horizontal and vertical components of one motion vector difference, then proceeding to simply derive the horizontal and vertical components of the next motion vector difference. By this measure, the memory requirements imposed on the decoding object are reduced, i. e. decoder in Fig. 16 because the desymbolizer 314 can continue to debinarize the motion vector differences directly without having to wait for other motion vector differences to be scanned. This is made possible by context selection: since exactly one context is available per bin position of code 806, no spatial relationship needs to be inspected.

The reconstructor 404, as described above, can spatially and/or temporally predict the horizontal and vertical components of the motion vectors to obtain predictors 126 for the horizontal and vertical components of the motion vector and reconstruct the horizontal and vertical components of the motion vectors by refining the predictors 826 using the horizontal and vertical components. motion vector differences, for example, by simply adding the motion vector difference to the corresponding predictor.

In addition, the reconstructor 404 may be configured to predict the horizontal and vertical motion vector components in different ways to obtain an ordered list of predictors for the horizontal and vertical motion vector components, obtain the index of the list from the data stream, and reconstruct the horizontal and vertical motion vector components by predictor refinement. , by the list predictor pointed to by the list index, using the horizontal and vertical components of the motion vector differences.

In addition, as already described above, the restorer 404 may be configured to reconstruct the video using motion-compensated prediction by applying the horizontal and vertical components 802x,y of the motion vectors at a spatial granularity determined by subdividing the video images into blocks, wherein the restorer 404 may use the merge syntax elements present in the data stream 401 to group the blocks into merge groups and apply the integer values of the horizontal and vertical components 802x,y of the motion vector differences obtained by the binarizer 314 in units of the merge groups.

The decompressor 404 may output the division of the video images into blocks from the portion of the data stream 401 that excludes the merge syntax elements. The restorer 404 may also adapt the horizontal and vertical components of the predetermined motion vector for all blocks of the associated merge group, or refine them by means of the horizontal and vertical components of the motion vector differences associated with the blocks of the merge group.

For completeness only, FIG. 17 shows an encoder corresponding to the decoder of FIG. 16. The encoder of FIG. 17 includes a constructor 504, a symbolizer 507, and an entropy encoder 513. The encoder includes a constructor 504 configured to predictively encode video 505 by motion compensation prediction using motion vectors, and predictively encode motion vectors by predicting motion vectors and setting integer values 506 horizontal and vertical motion vector difference components to represent the prediction error of the predicted motion vectors; a symbolizer 507 configured to binarize integer values to obtain binarizations 508 of the horizontal and vertical components of the motion vector differences, wherein the binarizations are equal to the truncated unary code of the horizontal and vertical components, respectively, in the first interval of the domain of definition of the horizontal and vertical components below the cutoff value and the prefix combination in the form of a truncated a unary code for a cutoff value and a suffix in the form of an exponential Golomb code of horizontal and vertical components, respectively, in the second interval of the definition area of the horizontal and vertical components, inclusive and above the cutoff value, where the cutoff value is two, and the exponential Golomb code has an order equal to one; and an entropy encoder 513, configured, for the horizontal and vertical motion vector difference components, to encode the truncated unary code into the data stream using context-adaptive binary entropy coding with exactly one context per bin position of the truncated unary code that is common to horizontal and the vertical components of the motion vector differences, and the exponential Golomb code, using the bypass mode with constant equiprobability. Other possible implementation details are directly transferable from the description regarding the decoder of FIG. 16 to the encoder of FIG. 17.

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

The inventive encoded signal may be stored on a digital storage medium or may be transmitted over a transmission medium such as a wireless transmission medium or a wired transmission medium such as the Internet.

Depending on certain implementation requirements, embodiments of the invention may be implemented in hardware or software. The implementation may be performed using a digital storage medium such as floppy disk, digital multifunctional disk (DVD), Blue-Ray disk, CD, read only memory (ROM), programmable ROM (PROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory having electronically readable control signals stored thereon that interact (or are capable of interacting) with a programmable computer system such that the corresponding method is performed. Therefore, the digital storage medium may be computer-readable.

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

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

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

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

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

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

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

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

A further embodiment of the invention comprises an apparatus or system capable of being sent (eg, electronically or optically) to a computer program receiver to perform one of the methods described herein. The receiver may, for example, be a computer, a mobile device, a memory device, or the like. The device or system, for example, may include a file server for sending a computer program to a receiver.

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

The above described embodiments are merely illustrative of the principles of the present invention. It is understood that modifications and changes to the devices and parts described herein are obvious to a person skilled in the art. They are therefore intended to be limited only by the scope of the pending claims and not by the specific details provided by way of describing and explaining the embodiments herein.

Claims (44)

1. A decoder for decoding video from a data stream, wherein the video is predictively decoded by motion-compensated prediction using motion vectors and motion vector differences representing a prediction error with respect to the motion vectors, said decoder comprising: entropy decoder, made for the horizontal and vertical components of each of the motion vector differences, with the ability to obtaining a truncated unary code and an exponential Golomb code from the data stream, decoding the truncated unary code using context-adaptive binary entropy decoding with exactly one context per bin position of the truncated unary code, the context being shared by the horizontal and vertical motion vector difference components, and decoding the exponential Golomb code using a constant equiprobability bypass mode to obtain horizontal and vertical motion vector difference components; and a restorer configured to restore the video based on the horizontal and vertical components of the motion vector differences. 2. The decoder of claim 1, wherein the entropy decoder is configured to use different contexts for different bin positions of the truncated unary code. 3. The decoder of claim. 1, in which the entropy decoder is configured to update the probability state for the bin currently output from the truncated unary code by transitioning from the current probability state associated with the context selected for the bin currently output , to a new probability state depending on the bin currently being output. 4. The decoder of claim 1, wherein the entropy decoder is configured to binary arithmetic decode a bin currently to be derived from the truncated unary code by quantizing a current probability interval width value representing the current probability interval to obtain a probability interval index and perform subdivision interval by indexing a table element from among table elements using a probability interval index and a probability state index depending on the current probability state associated with the context selected for the currently inferred bin to obtain a division of the current probability interval into two partial intervals. 5. The decoder of claim 4, wherein the entropy decoder is configured to use an 8-bit representation for the current probability interval width value and obtain the 2 or 3 most significant bits of the 8-bit representation by quantizing the current probability interval width value. 6. The decoder of claim 4, wherein the entropy decoder is configured to select a partial interval from said two partial intervals based on an offset state value from the interior of the current probability interval, updating the probability interval width value and the offset state value, and guessing the bin value, currently to be inferred using the selected partial interval, and renormalizing the updated probability interval width value and offset state value, including continuing to read bits from the data stream. 7. The decoder according to claim 4, in which the entropy decoder is made, in the bypass mode with constant equiprobability, with the possibility of binary arithmetic decoding of the bin from the exponential Golomb code by dividing the current probability interval width value in half to obtain a division of the current probability interval into two partial intervals. 8. The decoder according to claim 1, in which the entropy decoder is configured, for each motion vector difference, with the possibility of deriving a truncated unary code of the horizontal and vertical components of the corresponding motion vector difference from the data stream before deriving the exponential Golomb code of the horizontal and vertical components of the corresponding motion vector difference . 9. The decoder of claim. 1, in which the restorer is configured to spatially and/or temporally predict the horizontal and vertical components of the motion vectors to obtain predictors for the horizontal and vertical components of the motion vectors and restore the horizontal and vertical components of the motion vectors by refining the predictors using horizontal and vertical components of motion vector differences. 10. The decoder according to claim 1, wherein the decoder is configured to predict the horizontal and vertical components of the motion vectors in a different way to obtain an ordered list of predictors for the horizontal and vertical components of the motion vectors, to obtain from the data stream a list index corresponding to a predictor in the ordered list, and recovering the horizontal and vertical components of the motion vectors by refining the predictor indicated by the index of the list using the horizontal and vertical components of the motion vector differences. 11. The decoder of claim 9, wherein the decoder is configured to reconstruct the video using motion-compensated prediction by using the horizontal and vertical components of the motion vectors. 12. The decoder of claim 11, wherein the decoder is configured to reconstruct the video using motion-compensated prediction by applying the horizontal and vertical components of the motion vectors with a spatial granularity determined by subdividing the video images into blocks, wherein the decoder uses the fusion syntax elements present in the data stream to group blocks into merge groups and apply the horizontal and vertical components of the motion vector differences in merge group units. 13. The decoder of claim 1, wherein the data stream comprises at least a portion associated with color bins. 14. The decoder of claim 1, wherein the data stream comprises at least a portion associated with depth values related to the depth map. 15. An encoder for encoding video into a data stream, containing: a constructor configured to predictively encode video by motion-compensated prediction using motion vectors and horizontal and vertical components of motion vector differences representing a prediction error with respect to the motion vectors; and an entropy encoder designed for the horizontal and vertical components of each of the motion vector differences, with the possibility encoding into the data stream a truncated unary code encoded using context-adaptive binary entropy coding with exactly one context per bin position of the truncated unary code, the context being shared by the horizontal and vertical motion vector difference components, and encoding into the data stream of the exponential Golomb code encoded using the bypass mode with constant equiprobability. 16. The encoder of claim 15, wherein the entropy encoder is configured to use different contexts for different bin positions of the truncated unary code. 17. The encoder of claim 15, wherein the entropy encoder is configured to perform a probability state update for the bin currently being encoded from the truncated unary code by transitioning from a current probability state associated with a context selected for the bin currently being encoded. , to a new probability state depending on the bin currently being encoded. 18. The encoder of claim 15, wherein the entropy encoder is configured to binary arithmetic encode a bin currently to be encoded from the truncated unary code by quantizing a current probability interval width value representing the current probability interval to obtain a probability interval index and perform subdivision interval by indexing a table element from among table elements using a probability interval index and a probability state index depending on the current probability state associated with the context selected for the bin currently to be encoded to obtain a subdivision of the current probability interval into two partial intervals. 19. The encoder of claim 15, wherein the constructor is configured to predict the horizontal and vertical components of the motion vectors in different ways to obtain an ordered list of predictors for the horizontal and vertical components of the motion vectors, obtain from the data stream a list index corresponding to a predictor in the ordered list, and determining the horizontal and vertical components of the motion vector differences to refine the predictor indicated by the index of the list to the horizontal and vertical components of the motion vectors. 20. The encoder according to claim 15, wherein the entropy encoder is configured, for each motion vector difference, to encode a truncated unary code of the horizontal and vertical components of the corresponding motion vector difference into the data stream before encoding the exponential Golomb code of the horizontal and vertical components of the corresponding motion vector difference . 21. The encoder of claim 15, wherein the constructor is configured to spatially and/or temporally predict the horizontal and vertical components of the motion vectors to obtain predictors for the horizontal and vertical components of the motion vectors, and determine the horizontal and vertical components of the motion vector differences to refine predictors to the horizontal and vertical components of motion vectors. 22. The encoder of claim 19, wherein the entropy encoder is configured to select from among two partial intervals based on an integer value of the bin currently to be encoded, update the probability interval width value, and offset the probability interval using the selected partial interval, and performing renormalization of the probability interval width value and the probability interval offset, including continuing to write bits to the data stream. 23. The encoder of claim 15, wherein the constructor is configured to encode video using motion-compensated prediction by applying the horizontal and vertical components of the motion vectors with a spatial granularity determined by subdividing the video images into blocks, wherein the constructor is further configured to determine and inserting merge syntax elements into the data stream to group blocks into merge groups and apply horizontal and vertical components of motion vector differences in merge group units. 24. The encoder of claim 15, wherein the data stream comprises at least a portion associated with color bins. 25. The encoder of claim 15, wherein the data stream comprises at least a portion associated with depth values related to the depth map. 26. A method for decoding video from a data stream, the video being predictively encoded by motion-compensated prediction using motion vectors and motion vector differences representing a prediction error with respect to the motion vectors, said method comprising: for the horizontal and vertical components of each of the motion vector differences a truncated unary code and an exponential Golomb code are obtained from the data stream, decoding the truncated unary code using context-adaptive binary entropy decoding with exactly one context per bin position of the truncated unary code, the context being shared by the horizontal and vertical motion vector difference components, and decoding the exponential Golomb code using a constant equiprobability bypass mode to obtain horizontal and vertical motion vector difference components; and reconstructing the video based on the horizontal and vertical components of the motion vector differences. 27. A computer-readable medium storing a computer program containing program code for executing, when executed on a computer, the method of claim 26. 28. A non-transitory computer-readable storage medium associated with video, comprising: a data stream stored on a non-temporal computer-readable medium, wherein the data stream comprises encoded horizontal and vertical motion vector difference components, the video being predictively encoded by motion-compensated prediction using the motion vectors encoded in the data stream, and the horizontal and vertical difference components motion vectors represent the prediction error with respect to the motion vectors, wherein for the horizontal and vertical components of each of the motion vector differences, the truncated unary code is encoded using context-adaptive binary entropy coding with exactly one context per bin position of the truncated unary code, the context being shared by the horizontal and vertical components of the motion vector difference, and the exponential code Golomba is encoded using the constant equiprobability traversal mode.

Images