Fador.be - H.264 - MPEG-4/AVC

I started building my own H.264 encoder of an inspiration from my work at Tampere University of Technology where I've been working with H.264 Motion Estimator.
I've used the book E. G. Richardson, Iain (2003). H.264 and MPEG-4 Video Compression: Video Coding for Next-generation Multimedia. Chichester: John Wiley & Sons Ltd.. as a reference as well as the H.264 recommendation.

Encoder features:

CAVLC	06/27/2009
"Core" 4x4 transform	06/28/2009
Hadamard 4x4/2x2 transform	06/28/2009
Quantisation	06/28/2009
4x4 Intra Prediction	07/01/2009

Source:

Tools etc
types.h	- download	- highlighted
common.h	- download	- highlighted
tables.c	- download	- highlighted
tables.h	- download	- highlighted
bitstream.c	- download	- highlighted
bitstream.h	- download	- highlighted
psnr.c	- download	- highlighted
psnr.h	- download	- highlighted
CALVC
cavlc.c	- download	- highlighted
cavlc.h	- download	- highlighted
Transform
transform.c	- download	- highlighted
transform.h	- download	- highlighted
Quantisation
quant.c	- download	- highlighted
quant.h	- download	- highlighted
Intra coding
intra.c	- download	- highlighted
intra.h	- download	- highlighted

Examples

CAVLC (Show)

Example 1

        Input
        
        bitstream stream;

        sint32 block[4*4]={0, 3,-1, 0,
                           0,-1, 1, 0,
                           1, 0, 0, 0,
                           0, 0, 0, 0};
        uint8 nC=0;

        bitstream_init(&stream);
        cavlc_code_coeff_4x4(block, &stream, nC);
    

        Output


        Reorder: 0,3,0,1,-1,-1,0,1,0,0,0,0,0,0,0,0,
        TotalCoeffs: 5
        put: 0000100 count: 7
        put: 0 count: 1
        put: 1 count: 1
        put: 1 count: 1
        levelVLC(1,0) = {1,1} val: 0
        put: 1 count: 1
        levelVLC(3,1) = {2,4} val: 4
        put: 0010 count: 4
        total_zeros: 3
        put: 111 count: 3
        run_before++
        run_before: 1 zerosleft: 3
        put: 10 count: 2
        run_before: 0 zerosleft: 2
        put: 1 count: 1
        run_before: 0 zerosleft: 2
        put: 1 count: 1
        run_before++
        put: 01 count: 2
        000010001110010111101101

Example 2

        Input

        
        bitstream stream;

        sint32 block[4*4]={-2, 4, 0,-1,
                            3, 0, 0, 0,
                           -3, 0, 0, 0,
                            0, 0, 0, 0};
        uint8 nC=0;

        bitstream_init(&stream);
        cavlc_code_coeff_4x4(block, &stream, nC);
    

        Output

        Reorder: -2,4,3,-3,0,0,-1,0,0,0,0,0,0,0,0,0,
        TotalCoeffs: 5
        put: 0000000110 count: 10
        put: 1 count: 1
        levelVLC(-2,0) = {1,4} val: 3
        put: 0001 count: 4
        levelVLC(3,1) = {2,4} val: 4
        put: 0010 count: 4
        levelVLC(4,1) = {2,5} val: 6
        put: 00010 count: 5
        levelVLC(-2,2) = {7,3} val: 3
        put: 111 count: 3
        total_zeros: 2
        put: 0011 count: 4
        run_before++
        run_before++
        run_before: 2 zerosleft: 2
        put: 00 count: 2
        000000011010001001000010111001100

Example 3

        Input
        
        bitstream stream;

        sint32 block[4*4]={ 0, 0, 1, 0,
                            0, 0, 0, 0,
                            1, 0, 0, 0,
                           -1, 0, 0, 0};
        uint8 nC=0;

        bitstream_init(&stream);
        cavlc_code_coeff_4x4(block, &stream, nC);
    
        Output
        
        Reorder: 0,0,0,1,0,1,0,0,0,-1,0,0,0,0,0,0,
        TotalCoeffs: 3
        put: 00011 count: 5
        put: 1 count: 1
        put: 0 count: 1
        put: 0 count: 1
        total_zeros: 7
        put: 011 count: 3
        run_before++
        run_before++
        run_before++
        run_before: 3 zerosleft: 7
        put: 100 count: 3
        run_before++
        put: 10 count: 2
        0001110001110010

Complete transform (Show)

Example 1 (same as in the book page 197)

        Code

        //QP is 10
        uint8 QP = 10;
        sint32 block2[4*4]={ 5, 11,  8, 10,
                             9,  8,  4, 12,
                             1, 10, 11,  4,
                            19,  6, 15,  7};

        sint32 block3[4*4];
        
        init_quant();
        transform_4x4(&block2, &block3);

        quant_4x4(&block3, &block2,QP, 0);

        rescale_4x4(&block2, &block3, QP);

        itransform_4x4(&block3, &block2);        
        //Divide block2 by 64 to post-scale


        Results
        Original:
         5, 11,  8, 10,
         9,  8,  4, 12,
         1, 10, 11,  4,
        19,  6, 15,  7
        
        Transformed:
         140, -1, -6,  7,
        -19,-39,  7,-92,
         22, 17,  8, 31,
        -27,-32,-59,-21,

        Quantized:
         17,  0, -1,  0,
         -1, -2,  0, -5,
          3,  1,  1,  2,
         -2, -1, -5, -1,


         Rescaled:
        544,    0,  -32,    0,
        -40, -100,    0, -250,
         96,   40,   32,   80,
        -80,  -50, -200,  -50

        Inverse transformed and post-scaled:
          4, 13,  8, 10,
          8,  8,  4, 12,
          1, 10, 10,  3,
         18,  5, 14,  7,

Transformed foreman QP 0-50:

NO INTRA PREDICTIONS USED!

CAVLC byte value is just 4x4 blocks coded with CAVLC, first value is with nC=0 and second value is with predicted nC as in the recommendation.

QP: 0 PSNR: 66.08 CAVLC: 97512 / 89269 bytes	QP 10 PSNR: 45.63 CAVLC: 72910 / 66383 bytes

QP 20 PSNR: 35.63 CAVLC: 53567 / 50512 bytes	QP 30 PSNR: 31.88 CAVLC: 50381 / 49146 bytes

QP 40 PSNR: 27.32 CAVLC: 19664 / 19114 bytes	QP 50 PSNR: 20.45 CAVLC: 7776 / 7775 bytes

Transformed foreman 2 QP 0-50:

WITH FORCED 4x4 INTRA PREDICTIONS!
4 bits added to each 4x4 block for mode cost

QP: 0 PSNR: 66.03 CAVLC: 91528 bytes	QP 10 PSNR: 41.15 CAVLC: 58439 bytes

QP 20 PSNR: 35.20 CAVLC: 23794 bytes	QP 30 PSNR: 31.45 CAVLC: 9072 bytes

QP 40 PSNR: 28.52 CAVLC: 4780 bytes	QP 50 PSNR: 23.73 CAVLC: 4064 bytes