Method and apparatus for encoding and decoding a video.

1 . Technical field

A method and an apparatus for encoding a video into a bitstream are disclosed. Corresponding decoding method and apparatus are further disclosed.

2. Background

For coding a picture of a video sequence, video compression methods usually divide the picture into a set of blocks of pixels. Each block is then predicted using information already reconstructed, corresponding to the blocks previously encoded / decoded in the current picture. The coding of a current block is performed using an intra or inter prediction of the current block, and a prediction residual or "residual block" corresponding to a difference between the current block and the predicted block is computed. The resulting residual block is then converted, for example by using a transform such as a DCT (discrete cosine transform) type transform. The coefficients of the transformed residual block are then quantized and encoded by entropy coding and transmitted to a decoder.

In an HEVC video compression standard ( "ITU-T H.265 Telecommunication standardization sector of ITU (10/2014), series H: audiovisual and multimedia systems, infrastructure of audiovisual services - coding of moving video, High efficiency video coding, Recommendation ITU-T H.265"), a picture is divided into Coding Tree Units (CTU), which size may be 64x64, 128x128 or 256x256 pixels. Each CTU may be further subdivided using a quad-tree division, where each leaf of the quad-tree is called a Coding Unit (CU). Each CU is then given some Intra or Inter prediction parameters. To do so, a CU is spatially partitioned into one or more Prediction Units (PU), a PU may have a square or a rectangular shape. Each PU is assigned some prediction information, such as for example motion information, spatial intra prediction. According to the HEVC video compression standard, each CU may be further subdivided into Transform Units (TU) for performing the transform of the prediction residual. However, only square supports transform are defined in the HEVC video compression standard, as disclosed on figure 1 A. On figure 1 A, solid lines indicate CU boundaries and dotted lines indicate TU boundaries.

A Quad-Tree plus Binary-Tree (QTBT) coding tool ("Algorithm Description of Joint Exploration Test Model 3", Document JVET-C1001_v3, Joint Video Exploration Team of ISO/I EC JTC1/SC29/WG1 1, 3rd meeting, 26th May- 1st June 2015, Geneva, CH) provides a more flexible CTU representation than the CU/PU/TU arrangement of the HEVC standard. The Quad-Tree plus Binary-Tree (QTBT) coding tool consists in a coding tree where coding units can be split both in a quad-tree and in a binary-tree fashion. Such coding tree representation of a Coding Tree Unit is illustrated on Fig. 1 B, where solid lines indicate quad-tree partitioning and dotted lines indicate binary partitioning of a CU.

The splitting of a coding unit is decided on the encoder side through a rate distortion optimization procedure, which consists in determining the QTBT representation of the CTU with minimal rate distortion cost. In the QTBT representation, a CU has either a square or a rectangular shape. The size of coding unit is always a power of 2, and typically goes from 4 to 128. The QTBT decomposition of a CTU is made of two stages: first the CTU is split in a quadtree fashion, then each quad-tree leaf can be further divided in a binary fashion or in a quadtree fashion, as illustrated on fig. 1 C, where solid lines represent the quad-tree decomposition phase and dotted lines represent the binary decomposition that is spatially embedded in the quad-tree leaves. With the QTBT representation, a CU is not anymore partitioned into PU or TU. With the QTBT representation, the transform of the prediction residual is performed on blocks of size expressed as a power of 2 and existing separable transform and fast implementation of such transform usually used for square blocks can be re-used. However, such a QTBT representation does not allow for asymmetric splitting of a CU.

3. Summary

According to an aspect of the disclosure, a method for encoding a video is disclosed. Such a method comprises, for at least one block having a size N which is not a power of 2 along at least one dimension:

- determining a predicted block for said at least one block,

- obtaining a residual block from said at least one block and said predicted block,

- performing block transform of said residual block, said residual block having a size N,

- encoding said transformed residual block.

According to an embodiment, N is a multiple of 3.

According to another embodiment, performing block transform of said residual block comprises at least performing butterfly operations converting from a spatial domain to a transform domain a sample vector of size 3, wherein said butterfly operations implement a transform matrix of size 3x3, said sample vector comprising:

- samples of said residual block along said at least one dimension in the case where N equals 3, and

- linear combinations of samples of said residual block taken along said at least one dimension in the case where N is higher than 3.

According to another embodiment, said block transform is based on a transform matrix A _N represented by:

^{An =} J W ^{x cos} {^^^k e^N-i] , with k an integer k≥ 0, c(fc) =

^ h 1 1 if ^lf k ^{k ~} 0 °'| ). According to a variant, said method further comprising, for TV > 3:

- performing butterfly operations converting from a spatial domain to a transform domain a sample vector of size N/2, wherein said butterfly operations implement a complementary matrix transform X _N represented by:

Λ _Ν — COS _{2 N} )k,je[0,N/2] ■

This embodiment allows providing a fast implementation of the transform when N is higher than 3. Therefore, computational resources are saved.

According to another embodiment, butterfly operations converting from a spatial domain to a transform domain a sample vector of size 3 are represented by:

^2 ^{= x} l ~ ^x 3 i

t = (E ₁ + x ₂ ) x A ₃ (l,l),

t ₂ = E ₂ x . ₃ (2,1),

t ₃ = E ₁ X A ₃ (3,l) - x ₂ , where represents said sample vector of size 3 from said spatial domain, represents a resulting sample vector of size 3 from said transform domain, E _x and E ₂ represent intermediate values for butterfly design used for computing samples from said transform domain, A ₃ (k,j) represent corresponding values of said transform matrix.

Such an implementation allows reducing the number of multiplications needed for performing the transform of the residual block. Thus, complexity is reduced.

According to another embodiment, butterfly operations converting from a spatial domain to a transform domain a sample vector of size 6, comprises at least the following operations: E ₁ = Z ₆ (l,l) x ^ + ₆ (3,l) x ^,

E ₂ = Χ ₆ (2,ϊ) ν ₂ ,

E ₃ = X ₆ (3,l) x v ₁ + X ₆ (l,l) x v ₃ , u2 = E ₁ — E ₂ — E ₃

u ₃ =—E ₂ + E ₃ where is obtained from said sample vector of size 6 from said spatial domain,

E _t , E ₂ and £ ₃ represent intermediate values for butterfly design further used for computing transformed samples from said transformed residual block, X ₆ (k,j) represent corresponding values of the complementary matrix transform and is the resulting vector of samples in

the transform domain.

According to another embodiment, for N > 3 , a butterfly implementation of said matrix transform A _N is based on a matrix P _; (A _N ) corresponding to a matrix wherein N/2 first lines of Pi (A _N ) corresponds to odd lines of A _N and N/2 last lines of P _; (A _N ) corresponds to even lines of A _N .

According to this embodiment, the butterfly implementation for transforming data of blocks having a size N in at least one dimension which is a multiple of 3 takes advantage of the symmetry which is present in the transform matrix A _N . Therefore, a butterfly implementation of the transform matrix for a size N/2 can be re-used for the size N.

According trix P _l (A _N ) is represented by:

P _l (A _N ) = , where Α _Ν/2 represents a vertically flipped version

of the matrix A _N/2 , and -X _N represents the opposite of the vertically flipped version of said complementary matrix transform X _N .

According to this embodiment, it is thus possible to re-use the butterfly implementation designed for the matrix A _N/2 .

According to another embodiment, the transform process through matrix P _l (A _N ) is performed as 2 sub-transforms A _N/2 ard X _N , respectively applied on sub-vectors derived from input spatial samples (x; + -

According to a further embodiment, the two sub-transforms are performed through butterfly operations of matrix A _N/2 applied on a sub-vector _> leading to a transformed sub-vector (b{) _{i=1 N/2} on one side, and butterfly operations of matrix X _N applie _> leading to a transformed sub- vector

According to a further embodiment, a final transform vector (t{) _{i=1 N} is obtained as an interleaving of said transformed sub-vectors w =

(£>i) ΐ½) b ₂ , u ₂ , ... , b _N j ₂ , u _W/ i ₂ )

According to another aspect of the disclosure, a method for decoding a video is disclosed. Such a method comprises, for at least one block having a size N which is not a power of 2 along at least one dimension :

- decoding a transformed residual block, -performing inverse block transform of said transformed residual block, said residual block having a size N,

-determining a predicted block for said at least one block,

- reconstructing said at least one block from said inverse transformed residual block and said predicted block.

Thus, the present principle allows performing inverse transformation of a transformed residual block on a support of a same size as the support for prediction. Thus, asymmetric partitioning of blocks can be coupled to fast inverse transformation of data of such blocks, yielding to better compression efficiency and reducing computational complexity.

According to an embodiment, N is a multiple of 3.

According to another embodiment, performing inverse block transform of said transformed residual block comprises at least performing butterfly operations converting from a transform domain to a spatial domain a sample vector of size 3, wherein said butterfly operations implement a transform matrix of size 3x3, said sample vector comprising:

- samples of said transformed residual block along said at least one dimension in the case where N equals 3, and

- linear combinations of samples of said transformed residual block taken along said at least one dimension in the case where N is higher than 3.

According to another embodiment, said inverse block transform is based on a transform matrix S _N represented by: with k an integer k≥ 0, c(/c) =

j= ₂ if k = 0,

l if k > 0

According to another embodiment, butterfly operations converting from a transform domain to a spatial domain a sample vector of size 3 are represented by:

= X S ₃ (1,1),

E ₂ = t ₂ 5 ₃ (l,2),

Es = t ₃ X S ₃ (1,3),

*1 = Ei + E ₂ + E ₃ ,

*2 = Ei - t ₃ ,

*3 = Ei - E ₂ + E ₃ , where represents a resulting sample vector of size 3 from said spatial domain, represents said sample vector of size 3 from said transform domain, E _t , E ₂ and E ₃ represent intermediate values for butterfly design used for computing samples from said spatial domain, S ₃ (j, k) represent corresponding values of the transform matrix.

Such an implementation allows reducing the number of multiplications needed for performing the inverse transform of the residual block. Thus, complexity is reduced.

According to another embodiment, said method further comprising, for iV > 3 :

- performing butterfly operations converting from a transform domain to a spatial domain a sample vector of size N/2, wherein said butterfly operations implement a complementary matrix transform X _N represented by:

Λ _Ν — COS _2N )k,je[0,N/2] ■

This embodiment allows providing a fast implementation of the inverse transform when N is higher than 3. Therefore, computational resources are saved.

According to another embodiment, butterfly operations converting from a transform domain to a spatial domain a sample vector of size 6, are represented by:

E _{1 =} X ₆ (l,l) x ¾ + X ₆ (3,1) x u ₃ ,

E ₂ = ¾ (2,l) x ¾ ,

E ₃ = X ₆ (3,l) X + X ₆ (l,l) X u ₃ ,

v ₁ = E ₁ + E ₂ v ₃ 3 =— E: where represents said sample vector of size 3 from said transform domain, E ₁ , E ₂ and E ₃

represent intermediate values for butterfly design further used for computing transformed samples from said transformed residual block, X ₆ (k,j) represent corresponding values of the

complementary matrix transform and is the resulting vector of samples in the spatial domain.

According to another embodiment, said butterfly operations implementing said matrix transform X _N uses linear combinations of columns from said matrix transform X _N . This embodiment takes advantage of the properties of the matrix transform X _N .

According to another embodiment, for N > 3 , a butterfly implementation of said matrix transform S _N is based on a matrix P _c (S _N ) corresponding to a matrix wherein N/2 first column of P _c (SJV) corresponds to odd columns of S _N and N/2 last columns of P _c (S _N ) corresponds to even columns of S _N .

According to this embodiment, the butterfly implementation for transforming data of blocks having a size N in at least one dimension which is a multiple of 3 takes advantage of the symmetry which is present in the transform matrix S _N . Therefore, a butterfly implementation of the transform matrix for a size N/2 can be re-used for the size N.

According to another embodiment, said matrix P _c (S _N ) is represented by: , where S _N/2 represents an horizontally flipped version

the matrix S _N/2 , and ⁼ ¾ represents the opposite of the horizontally flipped version of said complementary matrix transform X _N . According to this embodiment, it is thus possible to reuse the butterfly implementation designed for the matrices X _{N 2} and X _N .

According to this embodiment, it is thus possible to re-use the butterfly implementation designed for the matrix S _N/2 .

According to another embodiment, the transform process through matrix P _c (S _N ) is performed as 2 sub-transforms S _N/2 and X _N , respectively applied on sub-vectors derived from input transform samples (ti)i=i,..,w/ ₂ and (t^ .jv .

According to a further embodiment, the two sub-transforms are performed through butterfly operations of matrix S _N/2 applied on a sub-vector . leading to a sub-vector ( ^α 'ί) _ί =ι,..,Ν/ ₂ ^{on one} side, and butterfly operations of matrix X _N applied on a sub-vector (ti) _{i =} N _{+ 1 N} leading to a sub-vector (x'd _{i = 1} ,... _N/2 .

According to a further embodiment, a final inverse transformed vector (xi)i=i w is obtained by recombining said sub-vectors _N = ( ^α ί + ^χ ι) ( ^a ₂ + x ₂ ) ... (CL' + X' ) (a - x[) ( ₂ - x ₂ ) ... (a _N ' _/2 - x _N ' _/2 )

According to another aspect of the disclosure, an apparatus for encoding a video is disclosed. Such an apparatus comprises, for at least one block having a size N which is not a power of 2 along at least one dimension:

- means for determining a predicted block for said at least one block,

- means for obtaining a residual block from said at least one block and said predicted block,

- means for performing block transform of said residual block, said residual block having a size N,

- means for encoding said transformed residual block.

According to another aspect of the disclosure, an apparatus for decoding a video is also disclosed. Such an apparatus comprises, for at least one block having a size N which is not a power of 2 along at least one dimension: - means for decoding a transformed residual block,

- means for performing inverse block transform of said transformed residual block, said residual block having a size N,

- means for determining a predicted block for said at least one block,

- means for reconstructing said at least one block from said inverse transformed residual block and said predicted block.

The present disclosure also provides a computer readable storage medium having stored thereon instructions for encoding a video according to any one of the embodiments described in the disclosure.

The present disclosure also provides a computer readable storage medium having stored thereon instructions for decoding a video according to any one of the embodiments described in the disclosure.

According to one implementation, the different steps of the method for coding a video or decoding a video as described here above are implemented by one or more software programs or software module programs comprising software instructions intended for execution by a data processor of an apparatus for encoding/decoding a video, these software instructions being designed to command the execution of the different steps of the methods according to the present principles.

A computer program is also disclosed that is capable of being executed by a computer or by a data processor, this program comprising instructions to command the execution of the steps of a method for encoding a video or of the steps of a method for decoding a video as mentioned here above.

This program can use any programming language whatsoever and be in the form of source code, object code or intermediate code between source code and object code, such as in a partially compiled form or any other desirable form whatsoever.

The information carrier can be any entity or apparatus whatsoever capable of storing the program. For example, the carrier can comprise a storage means such as a ROM, for example a CD ROM or a microelectronic circuit ROM or again a magnetic recording means, for example a floppy disk or a hard disk drive.

Again, the information carrier can be a transmissible carrier such as an electrical or optical signal which can be conveyed via an electrical or optical cable, by radio or by other means. The program according to the present principles can be especially uploaded to an Internet type network. As an alternative, the information carrier can be an integrated circuit into which the program is incorporated, the circuit being adapted to executing or to being used in the execution of the methods in question.

According to one embodiment, the methods/apparatus may be implemented by means of software and/or hardware components. In this respect, the term "module" or "unit" can correspond in this document equally well to a software component and to a hardware component or to a set of hardware and software components.

A software component corresponds to one or more computer programs, one or more sub-programs of a program or more generally to any element of a program or a piece of software capable of implementing a function or a set of functions as described here below for the module concerned. Such a software component is executed by a data processor of a physical entity (terminal, server, etc) and is capable of accessing hardware resources of this physical entity (memories, recording media, communications buses, input/output electronic boards, user interfaces, etc).

In the same way, a hardware component corresponds to any element of a hardware unit capable of implementing a function or a set of functions as described here below for the module concerned. It can be a programmable hardware component or a component with an integrated processor for the execution of software, for example an integrated circuit, a smartcard, a memory card, an electronic board for the execution of firmware, etc,

4. Brief description of the drawings

Figure 1 A illustrates an exemplary CTU partitioning into coding units and transform units according to an HEVC video compression standard,

Figure 1 B illustrates an exemplary CTU partitioning according to the quad-tree and binary tree based method (QTBT),

Figure 1 C illustrates an exemplary tree representation of a CTU partitioning according to the quad-tree and binary tree based method (QTBT),

Figure 2 illustrates a block diagram of an exemplary encoder according to an embodiment of the present principles,

Figure 3 illustrates example of partitioning of a CU into sub-CUs according to the present principles,

Figure 4 illustrates a diagram of a butterfly implementation of a one-dimensional transform with size equal to 3, according to an embodiment of the present principles, Figure 5 illustrates another diagram of a butterfly implementation of a one-dimensional transform with size equal to 3, according to an embodiment of the present principles, Figure 6 illustrates a diagram of a butterfly implementation of a one-dimensional inverse transform with size equal to 3, according to an embodiment of the present principles, Figure 7 illustrates a diagram of a butterfly implementation of a one-dimensional complementary transform with size equal to 3 used for performing a one-dimensional fast transform with size equal to 6, according to an embodiment of the present principles, Figure 8 illustrates a diagram of a butterfly implementation of a one-dimensional transform with size equal to 6, according to an embodiment of the present principles,

Figure 9 illustrates the relationships between lines and columns of Xi ₂ exploited in the fast implementation of Xi ₂ .

Figure 10 illustrates a diagram of a one-dimensional transform implementation with size equal to 12 according to an embodiment of the present principles,

Figure 1 1 illustrates a diagram of a butterfly implementation of a one-dimensional complementary transform with size equal to 6 used for performing a one-dimensional fast transform with size equal to 12, according to an embodiment of the present principles, Figure 12 illustrates a diagram of a one-dimensional transform implementation with size equal to 24 according to an embodiment of the present principles,

Figure 13 illustrates a diagram of a one-dimensional transform implementation with size equal to N according to an embodiment of the present principles,

Figure 14 illustrates a block diagram of an exemplary decoder according to an embodiment of the present principles,

Figure 15 illustrates a flow diagram of an exemplary method for encoding a video according to an embodiment of the present principles,

Figure 16 illustrates a flow diagram of an exemplary method for decoding a video according to an embodiment of the present principles,

Figure 17 illustrates an exemplary encoder that may be used in one embodiment of the present principles,

Figure 18 illustrates an exemplary decoder that may be used in one embodiment of the present principles.

5. Description of embodiments

It is to be understood that the figures and descriptions have been simplified to illustrate elements that are relevant for a clear understanding of the present principles, while eliminating, for purposes of clarity, many other elements found in typical encoding and/or decoding devices. It will be understood that, although the terms first and second may be used herein to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. Various methods are described above, and each of the methods comprises one or more steps or actions for achieving the described method. Unless a specific order of steps or actions is required for proper operation of the method, the order and/or use of specific steps and/or actions may be modified or combined. A picture is an array of luma samples in monochrome format or an array of luma samples and two corresponding arrays of chroma samples in 4:2:0, 4:2:2, and 4:4:4 colour format. Generally, a "block" addresses a specific area in a sample array (e.g., luma Y), and a "unit" includes the collocated block of all encoded color components (Y, Cb, Cr, or monochrome). However, the term "block" is used herein to refer to a block (e.g. a CB, a CTB) or a unit (e.g. a CU, a CTU).

In the following sections, the word "reconstructed" and "decoded" can be used interchangeably. Usually but not necessarily "reconstructed" is used on the encoder side while "decoded" is used on the decoder side.

Figure 2 illustrates a block diagram of an exemplary encoder according to an embodiment of the present principles. The video encoder 20 disclosed here below may be conforming to any video or still picture encoding schemes. The encoding and decoding processes described below are for illustration purposes. According to some embodiments, encoding or decoding modules may be added, or removed or may vary from the following modules. However, the principle disclosed herein could still be applied to these variants.

Classically, the video encoder 20 may include several modules for block-based video encoding, as illustrated in figure 2. A picture I to be encoded is input to the encoder 20. The picture I is first subdivided into a set of blocks by a subdividing module. Each block BLK of the picture I is then processed for encoding. A block BLK may have size ranging from 4x4 to 128x128 pixels. Usually but not necessarily, the size of a block BLK is a power of 2.

The encoder 20 performs encoding of each block BLK of the picture I as follows. The encoder 20 comprises a mode selection unit for selecting a coding mode for a block BLK of the picture to be coded, e.g. based on a rate/distorsion optimization. Such a mode selection unit comprising:

- a motion estimation module for estimating motion between one current block of the picture to be coded and reference pictures,

- a motion compensation module for predicting the current block using the estimated motion,

- an intra prediction module for spatially predicting the current block.

The mode selection unit may also decide whether splitting of the block is needed according to rate/distorsion optimization for instance. In that case, the mode selection unit then operates on each subblock of the block BLK. Each subblock of the block BLK may also be further split into subblocks. Once a coding mode is selected for the current block BLK or coding modes for subblocks of the current block BLK are selected, the mode selection unit delivers a predicted block PRED and corresponding syntax elements to be coded in the bitstream for performing the same block prediction at a decoder. When the current block BLK has been split, the predicted block PRED is formed by the set of predicted subblocks delivered by the mode selection unit for each subblocks.

A residual block RES is then obtained by substracting the predicted block PRED from the original block BLK.

The residual block RES is then transformed by a transform processing module delivering a transform block TCOEF of transformed coefficients. The transform block TCOEF is then quantized by a quantization module delivering a quantized transform block QCOEF of quantized residual transform coefficients.

The syntax elements and quantized residual transform coefficients of the block QCOEF are then input to an entropy coding module to deliver coded data to form the coded bitstream STR.

The quantized residual transform coefficients of the quantized transform block QCOEF are processed by an inverse quantization module delivering a block TCOEF' of unquantized transform coefficients. The block TCOEF' is passed to an inverse transform module for reconstructing a block of residual prediction RES'.

A reconstructed version REC of the block BLK is then obtained by adding the prediction block PRED to the reconstructed residual prediction block RES'.

The reconstructed block REC is stored in memory for use by a picture reconstruction module. The picture reconstruction module performs reconstruction of a decoded version Γ of the picture I from the reconstructed blocks REC. The reconstructed picture Γ is then stored in a reference picture memory for later use as a reference picture for encoding the following pictures of the set of pictures to code or for encoding subsequent blocks of the picture I.

According to an embodiment of the present principles, when determining a coding mode for coding a block BLK, the block BLK or subblocks of the block BLK may be asymmetrically split as illustrated by figure 3. Such splittings result in blocks having rectangular shapes. These shapes consist in sizes equal to 3x2 ^N in width and/or height. Furthermore, a block or subblock having a size multiple of 3 in width or height can be further split in a binary fashion, i.e. horizontally or vertically. As a consequence, a square block of size (w, h , where w is the width of the block, and h is its height, that is split through one of the asymmetric binary splitting modes would lead for example to 2 subblocks with respective rectangular sizes (w, ^ and ( ^w _< )- According to this embodiment, blocks or subblocks having a width and/or height equal to 3x2 ^N , may then be determined by the coding mode selection unit and used at the encoder. In such a case, Intra prediction or Inter prediction process is performed on such rectangular blocks or subblocks having of a size multiple of 3.

According to the present principle, the transform processing module is configured to operate on such rectangular shapes by applying a 2D transform with size 3 ^■ 2 ⁿ in width or height. Such process does not exist in known video coding standards because only square transforms are allowed. According to the present principles, the transform processing module is thus configured to operate on a block having a same shape and size as the shape and size of the prediction block used for predicting the block. Therefore, no more partitioning into transform unit is needed.

The present principle allows providing a fast implementation of the 2D transform to apply on blocks having a size multiple of 3 in at least one dimension (width, height) is disclosed below. According to the present principle, a fast implementation of the 2D inverse transform to apply on blocks having a size multiple of 3 in at least one dimension (width, height) is also disclosed below. The inverse transform module disclosed above is configured to apply such a fast 2D transform to the blocks having a size multiple of 3 in at least one dimension.

The 2D transform applied on a block in standard video codec is a 2D DCT like transform. The 2D DCT applied on a block in standard video codec involves the separable application of two 1 D transforms onto the considered 2D block, in horizontal and vertical directions.

If we defined the following matrix A _N for a given size N, as follows:

Then the 2D separable DCT of an input square block X with size N x N can be written as follows:

DCT(X) = A ^■ X ^■ A _N , with A being the transposed version of the matrix A _N .

Thus it consists in applying the one-dimensional DCT transform successively on each line and each column of the input two-dimensional block.

The one-dimensional DCT transform of a one-dimensional vector X _N e ^N is given by:

DCT _1D (X _N ) N

The straightforward implementation of this 1 D DCT transform under the form of the multiplication of a matrix by a vector involves N multiplications and N— 1 additions, which is a significant amount of operations when the input vector is of large size such as for example 32, 64, 128, 256. To limit the complexity of integer DCT transform implementation, it is advantageous to design a fast implementation of such transform. A fast implementation of the 1 D- DCT transform is disclosed for block sizes equal to 3 ^■ 2 ⁿ , n≥ 0, i.e. for blocks having a size multiple of 3 in at least one dimension (width, height).

The DCT matrix for a vector size equal to 3 is given by:

A ₃ (l,l) Α ₃ (2,ϊ) A ₃ 3,l)

So, A ₃ = A ₃ (l,2) A ₃ (2,2) A ₃ (3,2) can be re-written as:

A ₃ (l,3) _4 ₃ (2,3) A ₃ (3,3)

where c¾ represents the value of cos(-).

Butterfly implementations for matrix transform and inverse matrix transform with size 3

Therefore, a butterfly implementation of the one-dimension DCT with size 3 is shown on figure 4.

On figure 4, the graph nodes on the left correspond to input samples, and the nodes on the right are the resulting transform DCT coefficients. The values associated with each edge represent a multiplicative factor, which are called edge factors. Moreover, edges that arrive at a same right side node are summed together. Where the same multiplicative factor is applied on some edges that go to same right-side node, then the addition is done before the multiplication by the edge factor.

An equivalent, slightly less compact view of the same butterfly implementation of figure 4 is illustrated on figure 5.

Therefore, a fast implementation of the 1 D DCT with size 3 is as follows:

· E l) = x ₁ + x ₃

• E 2) = x ₁ - x ₃

• t ₁ = E l) + x ₂ ) x A ₃ (l,l)

• t ₂ = E(2) A ₃ (2,l)

• t ₃ = E(l) x A ₃ (3,1) - x ₂ , where E(1 ) and E(2) represent intermediate nodes on the butterfly diagram shown on figure 5. Such a butterfly implementation involves 4 additions and 3 multiplications, while a classical matrix-based DCT implementation involves 6 additions and 9 multiplications.

Below, a butterfly diagram for computing the inverse transform 1 D DCT with size equal to 3 is shown. The DCT matrix is orthogonal, which implies that the inverse transform matrix S3 can be computed from the transform matrix A ₃ as follows:

A butterfly implementation for S3 is shown on figure 6. On figure 6, terms of matrix A are referred to while 4 ₃ (l,l) = S ₃ (l,l), A ₃ (2,l) = S ₃ (l,2) and 4 ₃ (3,1) = S ₃ (l,3).

Therefore, a fast implementation of the 1 D inverse DCT with size 3 is as follows:

• F(l) = i ₁ x5 ₃ (l,l)

• £(2) = t ₂ xS ₃ (1,2)

• £(3) = t ₃ xS ₃ (1,3)

• x ₁ =£(l)+£(2) + £(3)

• x ₂ = Ε(ϊ) - 2 X £(3) = Ε(ϊ) - t ₃

• x ₃ = £(1) - £(2) + £(3)

Such a butterfly implementation involves 5 additions and 3 multiplications, instead of 6 additions and 9 multiplications for the classical matrix-based implementation.

Butterfly implementations for matrix transform and inverse matrix transform with size 6

Below, butterfly implementations equivalent to matrix transform and inverse matrix transform with a size equal to 6 are disclosed.

The matrix transform corresponding to the 1 D DCT with size 6 based on the matrix AN is as

A ₆ can also be written as follows:

It appears from A ₆ that the odd lines of A ₆ comprises the coefficients of A ₃ discussed above. Therefore, a matrix Pi can be written as follows by permutating lines of A ₆ :

In the matrix P^e), the first 3 lines correspond to odd lines of A ₆ and the last 3 lines correspond to even lines of A ₆ .

Pi (A ₆ ) can thus be re-written using A ₃ and a complementary matrix transform X ₆ , as: where A ₃ represents a vertically flipped version of the matrix A ₃ , and X ₆ is defined as follows -4 ₆ (2,1) A _b {2,2) A ₆ (2,3)

X ₆ = ₆ (4,1) ₆ (4,2) ₆ (4,3) ] =

6(6,l) _4 ₆ (6,2) A ₆ (6,3)

Therefore, the 1 D DCT of size 6 applied to a 1 D sampl of size 6 with can be expressed as follows:

with .

with Y ₂ corresponding to a horizontally flipped version of Y ₂ .

Thus, it appears that computing the 1 D DCT of size 6 can be performed by performing the computation of the fast 1 D DCT with size 3 disclosed above applied to a linear combination of samples of the input vector X and by performing a fast computation of a product of the matrix X ₆ by a 3 x 1 vector comprising linear combination of samples of the input vector X. The application of 1 D-DCT with size 3 provides odd lines of the final transform vector, i.e. h h

Below is disclosed a fast implementation of such multiplication of the matrix X ₆ by a 3 x 1 vector - A way of implementing the product of X ₆ by a vector V=[v _t v ₂ v ₃ Y is:

• _Ul = X ₆ (l,l) * V! + X ₆ (2,l) * v ₂ + X ₆ (3,l) * v ₃

• u ₂ = (v ₁ - v ₂ - v ₃ ) * X ₆ (2,l)

• u ₃ = ¾(3,1) * v ₁ - ¾(2,1) * v ₂ + X ₆ (l,l) * v ₃ where [ι½ u ₂ ιι ₃ Υ is the destination vector.

Such an implementation leads to 7 multiplications and 6 additions.

It can be noted that:

Therefore, the following relationship between the values of the cosinus function can be define:

(cos (^) ^■ a + cos ^■ b) - (cos (¾) ^■ « + cos (^) ^■ b) = cos Q ^■ a - COS Q ^■ b

Such a relationship can be advantageously exploited for computing the product:

X ₆ ^■ [v ₁ v ₂ v ₃ Y as disclosed by the butterfly diagram shown on the left part of figure 7. Such a butterfly diagram is designed to implement the following computational steps:

0(1) = C n_ ^■ V _t + Csn ^■ v = X ₆ l,l) ^■ v _t + X ₆ (3,l) ^■ v ₃ ,

0(Ζ) = επ · ν ₂ = Χ ₆ (2,1) · ν ₂ ,

0(3) = csn ^■ v ₁ + c _IL - v ₃ = ¾(3,1) ^■ v ₁ + X ₆ l,l) ^■ v ₃

12 12

The fast implementation of X ₆ disclosed above can be advantageously used in the computation of the second part of the transform matrix A ₆ ( X ₆ ^■ Y - X ₆ ^■ Y ₂ ), as follows: • 0(1) = C n_ ^■ v + Csn ^■ v ₃ = X ₆ l,l) ^■ v ₁ + X ₆ (3,l) ^■ v ₃

• 0(Z) = c* - v ₂ = X ₆ (2,l) - v ₂

• 0(3) = Csn ^■ v ₁ + C n_ ^■ v = X ₆ (3,l) ^■ v ₁ + X ₆ l,l) ^■ v ₃

• ! = 0(1) + 0(2)

· u ₂ = 0(1) - 0(2) - 0(3)

• u ₃ = -0(2) + 0(3) where [v ₁ v ₂ v ₃ f corresponds to linear combinations of the input vector X with

^V l ^{= X} l ~ ^X 6

V2 ^{= X} 2 ~ ^X 5

v ₃ = x ₃ — x ₄ , with the input vector X =[x^ x x ₃ x ₄ X5 x ₆ ] and u ₂ u ₃ ] is the destination vector. The butterfly steps disclosed above generate even lines of the transformed vector:

[t ₂ t ₄ t ₆ ] = [ i u ₂ u ₃ ]

This fast butterfly version of the transform matrix X ₆ leads to 5 multiplications and 6 additions, instead of 9 multiplications and 6 additions for the straightforward matrix product.

The overall butterfly design for the one-dimension DCT with size 6 is shown on figure 8.

On figure 8, it appears that the fast implementation of the transform A ₆ can be performed using the fast implementation of the transform for size 3 (A ₃ ) applied to linear combinations of the input signal (xi , x ₂ , X3, x ₄ , xs, xe) ¹ to obtain odd lines (ti , t ₃ , t ₅ ) of the transformed vector and the fast implementation of the complementary matrix X ₆ applied to linear combinations of the input signal (xi , x ₂ , X3, x ₄ , xs, xe) ¹ to obtain even lines (t ₂ , t ₄ , t ₆ ) of the transformed signal.

A similar reasoning can be applied for computing the inverse transform S ₆ for size 6. As A ₆ orthogonal: A ₆ ^_1 = A^, so:

s„ = A _f r ¹ = I-

From S ₆ , it appears that the odd columns of S ₆ comprises the coefficients of A ₃

permutating columns in the matrix S ₆ , we obtain:

P _C (S ₆ ) comprises the matrix . ₃ ⁱ on the top-left 3x3 sub-matrix and the matrix X ₆ in the 3x3 top-right sub-matrix. Thus:

where S ₃ represents the matrix S ₃ in a horizontally flipped version and -X ₆ is the opposite of the horizontally flipped version of X ₆ . Therefore:

J - YI -X6 - Y ₂ ) s 3 - YI -X6 - Y ₂ )

Thus, the fast implementation of the inverse DCT with size 6 can simply re-use the fast implementation of the inverse DCT with size 3 and the fast implementation of the product by matrix x ₆ disclosed above.

Once these sub-processes are performed, two resulting sub-vectors are obtained: the inverse transform for size 6 is obtained by gathering the sub-vectors as follows:

P _C DCT- X)) = a + x ) {a! ₂ + x ₂ ') a ₃ ' + x ₃ ') a - x ) {a! ₂ - x ₂ ') a ₃ ' - x ₃ ')f

Therefore, a fast implementation of the 1 D inverse DCT with size 6, applied on a vector (ti, t ₂ , t ₃ , t ₄ , t ₅ , te) ¹ in the transform domain , is as follows :

^• £(l) = t ₁ x5 ₆ (l,l)

• £(2) = t ₂ x5 ₆ (l,3)

• £(3) = t ₃ x5 ₆ (l,5)

• a = E(X) + E(Z) +E 3

• a' ₃ =E(X)-E 2 + E(3)

• 0(1) =X ₆ l,l)-t ₄ + X ₆ (3,l)-t ₆

• 0(2)=X ₆ (2,l)-t ₅ • 0(3) = ¾(3,l) - t ₄ + ¾(U) ' t ₆

• x = 0(1) + 0(2)

• x' ₂ = 0(1) - 0(2) - 0(3)

• x = -0(2) + 0(3)

Butterfly implementations for matrix transform and inverse matrix transform with size 12 Below, butterfly implementations for matrix transform and inverse matrix transform with a size equal to 12 are disclosed.

The 1 D DCT as applied on a 12x1 vector is obtained through the matrix:

By grouping odd lines on one side and even lines on the other side, and by permutating lines of the matrix Ai ₂ , one obtains:

where the complementary matrix X ₁₂ is defined by:

In other words, X ₁₂ is the matrix of cosine values applied on the values contained in the following matrix:

Such a matrix can be simplified as:

if the cosine of a matrix M = (ran ) _r , is defined as the matrix cos( ) =

To implement a fast version of the product X ₁₂ x [^ν ₂ ·· · ν·^]*, we exploit the following relationships of the cosine function : cos { ) = cos g) ^■ (cos (g) + cos (g))

cos (g) = cos g) ^■ (cos + cos (£)) cos (g) = cos g) ^■ (cos (£) - cos

c ^os = ^cos G) ^■ ( ^cos (S) - ^cos (£))

cos (g) = cos g) ^■ (cos (g) - COS (g))

cos (g) = cos g) ^■ (cos (g) + COS (g))

Therefore, these properties are used to establish relationships between the lines and columns of X ₁₂ , as illustrated on figure 9. From the above equations, one can deduce how some lines of matrix X ₁₂ can be expressed as a linear combination of other lines of Xi ₂ . On figure 9, the signs on the top of the matrix indicate if the linear combination is multiplied by -1 or not to obtain the destination value.

The relationships between the lines of Xi ₂ illustrated on figure 9 are further disclosed below:

• vi e {1,4,5}, x ₁₂ (l, Q = (Xi2 (3, + Xi2 (4, )

• Vi e {2,3,6}, X ₁₂ (1, 0 = - ^ ( i2 (3, 0 + i2 (4, 0)

• Vi e {1,4,5}, X ₁₂ (6, i) = (X ₁₂ (3, i) - X ₁₂ (4, i))

• Vi e {2,3,6}, X ₁₂ (6, i) = - (X ₁₂ (3, i) - X ₁₂ (4, i))

• Vi e {1,4,5}, X ₁₂ (2, i) = (1 + V2)Z ₁₂ (5, i)

• Vi e {2,3,6}, X ₁₂ (5, i) = -(1 + V2)X ₁₂ (2,0

Therefore, a fast implementation of the product of ₁₂ by a 6x1 vector 7 = [v ₁ v ₂ v ₃ v ₄ v _s v ₆ ] ^t comprises the following operations:

· 0(5) =X ₁₂ (2,2)- (v ₂ -v ₃ -v ₆ ) =A ₁₂ (4,2)-(v ₂ -v ₃ -v ₆ )

• 0(6) = X ₁₂ 2,2 ^■ (i¾ -v ₄ - v ₅ ) = A ₁₂ (A,2) ^■ - ¾ - ν ₅ )

• u ₃ = 0(l) + 0(2)

• u ₄ = 0(3) + 0(4)

• 00(1) = 0(1) + 0(3)

· 00(2) = 0(2) + 0(4)

• 00(3) = 0(1) - 0(3)

• 00(4) = 0(2) - 0(4)

• _Ul =^(00(1) -00(2))

• u ₆ =^(00(3) -00(4))

· u ₂ = 0(5) + (l + V2)0(6)

• u ₅ = 0(6)-(l + V2)0(5)

A compact view of such computations is provided under the form of a butterfly diagram and illustrated on figure 10.

Therefore, a fast implementation of the transform A12, as illustrated on figure 11, can be performed using a fast implementation of the transform for size 6 (A ₆ ) applied to linear combinations of the input signal (xi, X2, X3, x ₄ , xs, xe, x ₇ , xs, xg, xio, xn, x^) ¹ to obtain odd lines (ti, t ₃ , t ₅ , t ₇ , tg, tn ) of the transformed vector and the fast implementation of the complementary matrix X12 disclosed above applied to linear combinations of the input signal (xi, x ₂ , X3, x ₄ , xs, x ₆ , x ₇ , xs, xg, X10, X11, X12) ¹ to obtain even lines (t ₂ , t ₄ , t ₆ ,ts, tio, ti ₂ ) of the transformed signal, with t ₂ , t ₆ , tio,t ₄ , ts, ti2 corresponding respectively to the output signal (ui, u ₂ , u ₃ , u ₄ , u ₅ , u ₆ ) product of Xi ₂ disclosed above.

In the same way as for the inverse DCT with size 6, the inverse DCT for size 12 is obtained with the following matrix:

$12 ⁼ ^12 ^{1 =} ^12*

In the same way as disclosed above, it can be shown that: where P _C (S ₁₂ ) represents a permutation of the columns of matrix S ₁₂ , basically grouping odd columns on one side, and even columns on the other side. Thus the implementation of a fast inverse DCT with size 12 can be determined recursively by re-using the fast implementation of the inverse DCT with size 6 and the previously described multiplication by matrix X ₁₂ . Once these sub-processes at size 6 are done the inverse transform at size 12 is obtained by combining the resulting sub-results with size 6 in the same way as already presented for the butterfly implementation of the inverse transform with size 6:

P^DCT-^X)) = P _C (S ₁₂ X X) = [ a + x ) ... {a ₆ ' + x ₆ ') a - x ) ... {a ₆ ' - x ₆ ')Y

Where:

(a ... a ₆ ' = j2/6.A' ₆ . t ₁ , t ₃ , t ₅ , t ₇ , t ₉ , t _ii y

(x ... x ₆ ' = J2/6. ₁₂ .. (t ₂ , t ₄ , t ₆ , t ₈ , t ₁₀ , ΐ ₁₂ )*

Butterfly implementations for matrix transform and inverse matrix transform with size 12

Below the fast implementation of the DCT transform with size 24, according to the present invention is disclosed. A compact view of such computations is illustrated on figure 12.

The butterfly version of DCT with size 24 is constructed in a similar way as for the size 12. First, if the DCT matrix for size 24 is noted: l (c(/ ) - cos ( ⁽²⁷ + ^1)/C7r

feje[0,23]

Then it can be shown that:

where the 12x12 matrix Χ _?Λ is defined as:

The matrix X ₂₄ can be written as X ₂₄ = COS if we define the cosine of a matrix M = (ma)

l ^]J i,je _r [l,n _η ] as the matrix cos( ) = (cosim;,)) _{r η} .

^ ^l J J J i,je[l,n\

Linear relationship that exist between lines and columns in the matrix X ₂₄ are identified as follows:

^{• C0S} (¾ ^=C0S © ^' ( ^C0S © ^{+ C0S} (¾)

^{• cos} O ^=cos ©-( ^cos (S) ^+cos (¾)

^{• cos} (S) ^=cos ©-( ^cos O ^+cos (¾)

^{• cos} (¾) ^=cos © ^■ ( ^cos (S) - ^cos (¾)

^{• cos} © ^=cos ©-( ^cos (¾ ^+cos (¾)

^{• cos} O ^=cos ©-( ^cos (S) ^+cos (¾)

The following linear dependencies between lines and columns are advantageously used to perform the DCT with size 24 as follows:

• 7 ⁺ = {1,4,5,8,9,12}

• /- = {2,3,6,7,10,11}

• L _idx = {1,2,3,10,11,12}

• ; EL _idx , l _pos (j) =∑ _ieI+ X ₁₂ (j, i) ^■ v _t Vy e L _idx , l _neg (/) =∑ _ie/ - X ₁₂ (j, 0 ^■

~ (.{lpos(3) + 'pos(lO)) ^— ( neg(3) + 'ne,g(10)))

^ (('pos(2) + 'pos(ll)) ^— ( neg(2) + 'ne,g(ll)))

(('pos(l) + 'pos(l2)) ^— ( neg(l) + 'ne,g(l2)))

l_final(7) = - = ((l_pos(l) - Z_pos(12)) - (Z_ne#(l) - Z_ne#(12))) l_final(8) -

lfinal(9) ⁼ ^ (('pos(3) ^— 'pos(lO)) ^— i}-neg{3) ~ 'ne^ClO)))

V ^e ^idx < '/ίπαί Ο) — lpos (j + ^neg U

A similar construction as for the inverse DCT with size 12 can be used for determining the inverse DCT transform with size 24. It can thus be shown that:

Thus, the fast inverse DCT transform with size 24 can be designed in a recursive fashion by re-using the inverse DCT butterfly method for size 12 and the method provided above for the X ₂ 4 matrix operator.

General butterfly implementation

The principle has been disclosed above for fast DCT transform with size equals to 3, 6, 12 and 24. In a more general case, a fast integer DCT transform implementation for block sizes equal to 3 ^■ 2 ⁿ , n≥ 0, i.e. for blocks having a size multiple of 3 in at least one dimension (width, height), can be designed in a recursive way, as illustrated on figure 13.

Such fast integer DCT transform implementation for blocks having a size N multiple of 3 in at least one dimension can be designed in a general case, for N > 3 , using a butterfly implementation of the transform matrix A _N . Such a butterfly implementation illustrated on figure 13 is based on a matrix P _; (A _N ) wherein the N/2 first lines of P _; (A _N ) corresponds to odd lines of A _N and N/2 last lines of P _; (A _N ) corresponds to even lines of A _N .

Furthermore, the matrix P _; (A _N ) can be represented by:

P _l (A _N ) = , where A _N/2 represents a vertically flipped version

of the matrix A _N/2 , and -X _N represents the opposite of the vertically flipped version of a complementary matrix transform X _N . Thus, it is possible to re-use the butterfly implementation designed for the matrix A _N/2 by applying the fast implementation of the transform for size N/2 (AN/2) applied to linear combinations of the input signal (χ,) ¹ ί=ι ,N-I to obtain odd lines of the transformed vector.

The complementary matrix transform X _N is represented by:

Λ _Ν — COS _2n )k,je[0,N/2] ■

Thanks to the properties of the cosine function, dependencies between lines and columns of the matrix X _N can be determined and advantageously used for designing a fast implementation of XN to be applied to linear combinations of the input signal (Χ ^-Ι ,Ν-Ι to obtain odd lines of the transformed signal.

These linear dependencies between lines and columns of X _N result from the following generic relationship:

(2; + 1)ΤΓ (2/c + l)(2y + 1)π

= COS I - h

4 2N

(2; + 1)ττ (2/c + l)(2y + 1)ττ (2fc + l)(2; + l)7r

= COS cos + sin

4 2N 2iV

(2; + 1)ττ (2/c + l)(2y + 1)ττ (JV - (2/c + l)(2y + 1))TT

= cos cos + cos

2N 2~/V

Since N is even and (2/c + l)(2y + 1) is odd, (N - (2/c + l)(2y + 1)) is also odd, thus the term cos ^ ^jV~(2fc+ ^ ² -' ^'+1)7T ^ corresponds to a member of matrix X _N located on a line different from (k + ^ .

Figure 14 illustrates a block diagram of an exemplary decoder according to an embodiment of the present principles. A bitstream representative of a coded image or video comprises coded data representative of at least one block of said image or video, wherein said block has been coded according to an embodiment of the present principles.

The coded data is passed to the video decoding modules of the video decoder 30. As illustrated in figure 14, coded data is passed to an entropy decoding module that performs entropy decoding and delivers quantized coefficients QCOEF' to an inverse quantization module and syntax elements to a prediction module.

The quantized coefficients QCOEF' are inverse quantized by the inverse quantization module and inverse transformed by an inverse transform module delivering residual blocks data RES'. A block to be reconstructed may have been coded with a size equal to 3x2 ^N in at least one dimension. According to the present principle, the inverse transform module is configured to operate on such blocks by applying a 2D transform with size 3 ^■ 2 ⁿ in width or height. The inverse transform module is thus configured to implement one of the fast inverse 1 D DCT transform as disclosed above according to the size of the block.

The prediction module builds prediction blocks PRED according to the syntax element and using a motion compensation module if a current block has been inter-predicted or an intra prediction module if the current block has been spatially predicted.

A reconstructed picture Γ is obtained by adding prediction blocks PRED and residual blocks RES'. The reconstructed picture Γ is stored in a reference frame memory for later use as reference frame. The reconstructed picture Γ is then outputted by the video decoder 30. The decoder 30 may be implemented as hardware or software or a combination of hardware and software thereof.

Figure 15 illustrates a flow diagram of an exemplary method for encoding a video according to an embodiment of the present principles. According to this embodiment, at least one block BLK of a picture of the video has a size N which is not a power of 2 along at least one dimension.

According to a particular embodiment, N is a multiple of 3 and can be written as 3 ^■ 2 ⁿ , n≥ 0. In step 40, a predicted block is determined for the current block BLK. The predicted block can be determined according to classical block prediction method (intra or inter prediction).

According to the embodiment disclosed herein, the predicted block size's is equal to the size of the block BLK.

In step 41 , a residual block is obtained by computing a difference between the current block BLK and the predicted block. The residual block, thus, has a size N along at least one dimension.

In step 42, block transform of the residual block is performed. The block transform is performed by applying a 2D separable DCT transform, i.e. by applying a 1 D DCT transform on the lines of the residual block, and then 1 D DCT transform on the columns of the residual block. If the lines, respectively columns, of the residual block have a size equal to 3 ^■ 2 ⁿ , n > 0 , a fast 1 D DCT transform implementation as disclosed above is used. Otherwise, if the lines, respectively columns, of the residual block have a size equal to a power of 2, known fast 1 D DCT transform implementations are used.

In step 43, the transformed residual block is then quantized and entropy coded.

Figure 16 illustrates a flow diagram of an exemplary method for decoding a video according to an embodiment of the present principles. According to this embodiment, at least one block BLK of a picture of the video has a size N which is not a power of 2 along at least one dimension.

According to a particular embodiment, N is a multiple of 3 and can be written as 3 ^■ 2 ⁿ , n≥ 0. The current block BLK is reconstructed as follows.

In step 50, a transformed residual block is entropy decoded from a bitstream and inverse quantized. The transformed residual block size's is equal to the size of the current block BLK and comprises decoded data for the current block BLK to reconstruct.

In step 51 , inverse block transform is performed on the transformed residual block. The inverse block transform is performed by applying a 2D separable inverse DCT transform, i.e. by applying a 1 D inverse DCT transform on the lines of the transformed residual block, and then a 1 D inverse DCT transform on the columns of the transformed residual block. If the lines, respectively columns, of the transformed residual block have a size equal to 3 ^■ 2 ⁿ , n≥ 0, a fast 1 D inverse DCT transform implementation as disclosed above is used. Otherwise, if the lines, respectively columns, of the transformed residual block have a size equal to a power of 2, known fast 1 D inverse DCT transform implementations are used.

Inverse block transform delivers a residual block with a size equals to the size of the transformed residual block.

In step 52, a predicted block is determined for the current block BLK to reconstruct. The predicted block can be determined according to classical block prediction method (intra ou inter prediction). According to the embodiment disclosed herein, the predicted block has a same size as the current block BLK.

In step 53, the current block BLK is reconstructed by adding the predicted block to the residual block.

Figure 17 illustrates an exemplary encoder that may be used in one embodiment of the present principles. Such an apparatus for encoding a video is configured to implement the method for encoding a video according to the present principles. The encoder apparatus of figure 17 may be as an example the encoder 20 as described in figure 2.

In the example shown in figure 17, the encoder apparatus comprises a processing unit PROC equipped for example with a processor and driven by a computer program PG stored in a memory MEM and implementing the method for encoding a video according to the present principles.

At initialization, the code instructions of the computer program PG are for example loaded into a RAM (not shown) and then executed by the processor of the processing unit PROC. The processor of the processing unit PROC implements the steps of the method for encoding a video which has been described here above, according to the instructions of the computer program PG.

Optionally, the encoder apparatus 20 comprises a communications unit COM to transmit an encoded bitstream to a decoder.

The encoder apparatus 20 also comprises an interface for receiving a picture to be coded, or a video.

Figure 18 illustrates an exemplary decoder that may be used in one embodiment of the present principles. Such an apparatus for decoding a video is configured to implement the method for decoding a video according to the present principles. The decoder apparatus of figure 18 may be as an example the decoder 30 as described in figure 14.

In the example shown in figure 18, the decoder apparatus comprises a processing unit PROC equipped for example with a processor and driven by a computer program PG stored in a memory MEM and implementing the method for decoding a video according to the present principles.

At initialization, the code instructions of the computer program PG are for example loaded into a RAM (not shown) and then executed by the processor of the processing unit PROC. The processor of the processing unit PROC implements the steps of the method for decoding a video which has been described here above, according to the instructions of the computer program PG.

Optionally, the decoder apparatus 30 comprises a communications unit COM to receive an encoded bitstream from an encoder.

The decoder apparatus 30 also comprises an interface for displaying a reconstructed picture or a reconstructed video.