Merge remote-tracking branch 'x264/master'
authorPhillip Blucas <pblucas@gmail.com>
Mon, 16 Jan 2012 02:06:31 +0000 (20:06 -0600)
committerPhillip Blucas <pblucas@gmail.com>
Mon, 16 Jan 2012 02:06:31 +0000 (20:06 -0600)
Conflicts:
common/bitstream.h
common/dct.c
common/dct.h
common/quant.h
common/set.c
common/x86/quant-a.asm
encoder/encoder.c
encoder/macroblock.c

17 files changed:
1  2 
Makefile
common/bitstream.h
common/common.h
common/dct.c
common/dct.h
common/quant.c
common/quant.h
common/x86/predict-a.asm
common/x86/predict.h
common/x86/quant-a.asm
configure
encoder/analyse.c
encoder/encoder.c
encoder/macroblock.c
encoder/rdo.c
tools/checkasm.c
x264.c

diff --cc Makefile
+++ b/Makefile
@@@ -2,10 -2,13 +2,15 @@@
  
  include config.mak
  
+ vpath %.c $(SRCPATH)
+ vpath %.h $(SRCPATH)
+ vpath %.S $(SRCPATH)
+ vpath %.asm $(SRCPATH)
  all: default
  
 +CLIS = x264$(EXE)
 +
  SRCS = common/mc.c common/predict.c common/pixel.c common/macroblock.c \
         common/frame.c common/dct.c common/cpu.c common/cabac.c \
         common/common.c common/osdep.c common/rectangle.c \
@@@ -56,8 -56,9 +56,9 @@@ typedef struct bs_
  typedef struct
  {
      int     last;
 -    dctcoef level[16];
 -    uint8_t run[16];
+     int     mask;
 +    dctcoef level[64];
 +    uint8_t run[64];
  } x264_run_level_t;
  
  extern const vlc_t x264_coeff0_token[6];
@@@ -65,22 -66,7 +66,21 @@@ extern const vlc_t x264_coeff_token[6][
  extern const vlc_t x264_total_zeros[15][16];
  extern const vlc_t x264_total_zeros_2x2_dc[3][4];
  extern const vlc_t x264_total_zeros_2x4_dc[7][8];
- extern const vlc_t x264_run_before[7][16];
  
 +/* MPEG-2 */
 +extern const vlc_t x264_mb_addr_inc[34];
 +extern const vlc_t x264_cbp[64];
 +extern const vlc_t x264_i_frame_mb_type[2];
 +extern const vlc_t x264_i_mb_type[3][2];
 +extern const vlc_t x264_p_mb_type[2][2][2];
 +extern const vlc_t x264_b_mb_type[3][2][2];
 +extern const vlc_large_t x264_dc_luma_code[12];
 +extern const vlc_large_t x264_dc_chroma_code[12];
 +extern const vlc_t x264_dmvector[3];
 +extern const vlc_large_t x264_motion_code[33];
 +extern const vlc_large_t dct_vlcs[2][41][32];
 +extern const uint8_t dct_vlc_largest_run[41];
 +
  typedef struct
  {
      uint8_t *(*nal_escape) ( uint8_t *dst, uint8_t *src, uint8_t *end );
diff --cc common/common.h
Simple merge
diff --cc common/dct.c
  #   include "arm/dct.h"
  #endif
  
- uint16_t x264_dct4_weight2_zigzag[2][16];
- uint16_t x264_dct8_weight2_zigzag[2][64];
+ /* the inverse of the scaling factors introduced by 8x8 fdct */
+ /* uint32 is for the asm implementation of trellis. the actual values fit in uint16. */
+ #define W(i) (i==0 ? FIX8(1.0000) :\
+               i==1 ? FIX8(0.8859) :\
+               i==2 ? FIX8(1.6000) :\
+               i==3 ? FIX8(0.9415) :\
+               i==4 ? FIX8(1.2651) :\
+               i==5 ? FIX8(1.1910) :0)
+ const uint32_t x264_dct8_weight_tab[64] = {
+     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1)
+ };
+ #undef W
+ #define W(i) (i==0 ? FIX8(1.76777) :\
+               i==1 ? FIX8(1.11803) :\
+               i==2 ? FIX8(0.70711) :0)
+ const uint32_t x264_dct4_weight_tab[16] = {
+     W(0), W(1), W(0), W(1),
+     W(1), W(2), W(1), W(2),
+     W(0), W(1), W(0), W(1),
+     W(1), W(2), W(1), W(2)
+ };
+ #undef W
+ /* inverse squared */
+ #define W(i) (i==0 ? FIX8(3.125) :\
+               i==1 ? FIX8(1.25) :\
+               i==2 ? FIX8(0.5) :0)
+ const uint32_t x264_dct4_weight2_tab[16] = {
+     W(0), W(1), W(0), W(1),
+     W(1), W(2), W(1), W(2),
+     W(0), W(1), W(0), W(1),
+     W(1), W(2), W(1), W(2)
+ };
+ #undef W
+ #define W(i) (i==0 ? FIX8(1.00000) :\
+               i==1 ? FIX8(0.78487) :\
+               i==2 ? FIX8(2.56132) :\
+               i==3 ? FIX8(0.88637) :\
+               i==4 ? FIX8(1.60040) :\
+               i==5 ? FIX8(1.41850) :0)
+ const uint32_t x264_dct8_weight2_tab[64] = {
+     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
+     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1)
+ };
+ #undef W
++#define W(i) (i==0 ? FIX8(0.25) :0)
++const uint32_t x264_mpeg2_weight_tab[64] = {
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0)
++};
++#undef W
++
++#define W(i) (i==0 ? FIX8(0.015625) :0)
++const uint32_t x264_mpeg2_weight2_tab[64] = {
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
++    W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0)
++};
++#undef W
  
  static void dct4x4dc( dctcoef d[16] )
  {
diff --cc common/dct.h
  #ifndef X264_DCT_H
  #define X264_DCT_H
  
- /* the inverse of the scaling factors introduced by 8x8 fdct */
- #define W(i) (i==0 ? FIX8(1.0000) :\
-               i==1 ? FIX8(0.8859) :\
-               i==2 ? FIX8(1.6000) :\
-               i==3 ? FIX8(0.9415) :\
-               i==4 ? FIX8(1.2651) :\
-               i==5 ? FIX8(1.1910) :0)
- static const uint16_t x264_dct8_weight_tab[64] = {
-     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
-     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
+ extern const uint32_t x264_dct4_weight_tab[16];
+ extern const uint32_t x264_dct8_weight_tab[64];
+ extern const uint32_t x264_dct4_weight2_tab[16];
+ extern const uint32_t x264_dct8_weight2_tab[64];
  
-     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
-     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1)
- };
- #undef W
- #define W(i) (i==0 ? FIX8(1.76777) :\
-               i==1 ? FIX8(1.11803) :\
-               i==2 ? FIX8(0.70711) :0)
- static const uint16_t x264_dct4_weight_tab[16] = {
-     W(0), W(1), W(0), W(1),
-     W(1), W(2), W(1), W(2),
-     W(0), W(1), W(0), W(1),
-     W(1), W(2), W(1), W(2)
- };
- #undef W
- /* inverse squared */
- #define W(i) (i==0 ? FIX8(3.125) :\
-               i==1 ? FIX8(1.25) :\
-               i==2 ? FIX8(0.5) :0)
- static const uint16_t x264_dct4_weight2_tab[16] = {
-     W(0), W(1), W(0), W(1),
-     W(1), W(2), W(1), W(2),
-     W(0), W(1), W(0), W(1),
-     W(1), W(2), W(1), W(2)
- };
- #undef W
- #define W(i) (i==0 ? FIX8(1.00000) :\
-               i==1 ? FIX8(0.78487) :\
-               i==2 ? FIX8(2.56132) :\
-               i==3 ? FIX8(0.88637) :\
-               i==4 ? FIX8(1.60040) :\
-               i==5 ? FIX8(1.41850) :0)
- static const uint16_t x264_dct8_weight2_tab[64] = {
-     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
-     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
-     W(0), W(3), W(4), W(3),  W(0), W(3), W(4), W(3),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1),
-     W(4), W(5), W(2), W(5),  W(4), W(5), W(2), W(5),
-     W(3), W(1), W(5), W(1),  W(3), W(1), W(5), W(1)
- };
- #undef W
- #define W(i) (i==0 ? FIX8(0.25) :0)
- static const uint16_t x264_mpeg2_weight_tab[64] = {
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0)
- };
- #undef W
- #define W(i) (i==0 ? FIX8(0.015625) :0)
- static const uint16_t x264_mpeg2_weight2_tab[64] = {
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0),
-     W(0), W(0), W(0), W(0),  W(0), W(0), W(0), W(0)
- };
- #undef W
- extern uint16_t x264_dct4_weight2_zigzag[2][16]; // [2] = {frame, field}
- extern uint16_t x264_dct8_weight2_zigzag[2][64];
++extern const uint32_t x264_mpeg2_weight_tab[64];
++extern const uint32_t x264_mpeg2_weight2_tab[64];
 +
  typedef struct
  {
      // pix1  stride = FENC_STRIDE
diff --cc common/quant.c
@@@ -420,8 -391,19 +423,20 @@@ level_run(4
  level_run(8)
  level_run(15)
  level_run(16)
 +level_run(64)
  
+ #if ARCH_X86_64
+ #define INIT_TRELLIS(cpu)\
+     pf->trellis_cabac_4x4 = x264_trellis_cabac_4x4_##cpu;\
+     pf->trellis_cabac_8x8 = x264_trellis_cabac_8x8_##cpu;\
+     pf->trellis_cabac_4x4_psy = x264_trellis_cabac_4x4_psy_##cpu;\
+     pf->trellis_cabac_8x8_psy = x264_trellis_cabac_8x8_psy_##cpu;\
+     pf->trellis_cabac_dc = x264_trellis_cabac_dc_##cpu;\
+     pf->trellis_cabac_chroma_422_dc = x264_trellis_cabac_chroma_422_dc_##cpu;
+ #else
+ #define INIT_TRELLIS(...)
+ #endif
  void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf )
  {
      pf->quant_8x8 = quant_8x8;
      pf->coeff_level_run[  DCT_LUMA_AC] = x264_coeff_level_run15;
      pf->coeff_level_run[ DCT_LUMA_4x4] = x264_coeff_level_run16;
  
 +    pf->coeff_level_run[ DCT_LUMA_8x8] = x264_coeff_level_run64;
 +    pf->dequant_mpeg2_intra = dequant_mpeg2_intra;
 +    pf->dequant_mpeg2_inter = dequant_mpeg2_inter;
 +
  #if HIGH_BIT_DEPTH
  #if HAVE_MMX
+     INIT_TRELLIS( sse2 );
      if( cpu&X264_CPU_MMX2 )
      {
  #if ARCH_X86
diff --cc common/quant.h
@@@ -56,8 -56,16 +56,19 @@@ typedef struc
      int (*coeff_level_run4)( dctcoef *dct, x264_run_level_t *runlevel );
      int (*coeff_level_run8)( dctcoef *dct, x264_run_level_t *runlevel );
  
 +    void (*dequant_mpeg2_intra)( dctcoef dct[64], int dequant_mf[64], int precision );
 +    void (*dequant_mpeg2_inter)( dctcoef dct[64], int dequant_mf[64] );
++
+ #define TRELLIS_PARAMS const int *unquant_mf, const uint8_t *zigzag, int lambda2,\
+                        int last_nnz, dctcoef *coefs, dctcoef *quant_coefs, dctcoef *dct,\
+                        uint8_t *cabac_state_sig, uint8_t *cabac_state_last,\
+                        uint64_t level_state0, uint16_t level_state1
+     int (*trellis_cabac_4x4)( TRELLIS_PARAMS, int b_ac );
+     int (*trellis_cabac_8x8)( TRELLIS_PARAMS, int b_interlaced );
+     int (*trellis_cabac_4x4_psy)( TRELLIS_PARAMS, int b_ac, dctcoef *fenc_dct, int psy_trellis );
+     int (*trellis_cabac_8x8_psy)( TRELLIS_PARAMS, int b_interlaced, dctcoef *fenc_dct, int psy_trellis );
+     int (*trellis_cabac_dc)( TRELLIS_PARAMS, int num_coefs );
+     int (*trellis_cabac_chroma_422_dc)( TRELLIS_PARAMS );
  } x264_quant_function_t;
  
  void x264_quant_init( x264_t *h, int cpu, x264_quant_function_t *pf );
Simple merge
Simple merge
@@@ -1394,12 -1373,12 +1373,12 @@@ cglobal coeff_level_run%1,0,
      LZCOUNT t3d, t5d, 0x1f
  %ifdef HIGH_BIT_DEPTH
      mov    t2d, [t0+t4*4]
-     mov   [t1+t6  +4+64*4], t3b
-     mov   [t1+t6*4+ 4], t2d
 -    mov   [t1+t6+8+16*4], t3b
++    mov   [t1+t6+8+64*4], t3b
+     mov   [t1+t6*4+ 8], t2d
  %else
      mov    t2w, [t0+t4*2]
-     mov   [t1+t6  +4+64*2], t3b
-     mov   [t1+t6*2+ 4], t2w
 -    mov   [t1+t6+8+16*2], t3b
++    mov   [t1+t6+8+64*2], t3b
+     mov   [t1+t6*2+ 8], t2w
  %endif
      inc    t3d
      shl    t5d, t3b
diff --cc configure
Simple merge
Simple merge
@@@ -1338,19 -1173,11 +1342,15 @@@ x264_t *x264_encoder_open( x264_param_
      x264_predict_8x16c_init( h->param.cpu, h->predict_8x16c );
      x264_predict_8x8_init( h->param.cpu, h->predict_8x8, &h->predict_8x8_filter );
      x264_predict_4x4_init( h->param.cpu, h->predict_4x4 );
-     if( h->param.b_cabac )
-         x264_cabac_init( h );
-     else
-         x264_cavlc_init();
 +    x264_predict_8x8_mpeg2_init( h->param.cpu, &h->predict_8x8_mpeg2 );
      x264_pixel_init( h->param.cpu, &h->pixf );
 -    x264_dct_init( h->param.cpu, &h->dctf );
 -    x264_zigzag_init( h->param.cpu, &h->zigzagf_progressive, &h->zigzagf_interlaced );
 -    memcpy( &h->zigzagf, PARAM_INTERLACED ? &h->zigzagf_interlaced : &h->zigzagf_progressive, sizeof(h->zigzagf) );
 -    x264_mc_init( h->param.cpu, &h->mc );
 +    x264_dct_init( h->param.cpu, &h->dctf, MPEG2 );
 +    x264_zigzag_init( h->param.cpu, &h->zigzagf_progressive, &h->zigzagf_interlaced, MPEG2 );
 +    if( MPEG2 )
 +        memcpy( &h->zigzagf, h->param.b_alternate_scan ? &h->zigzagf_interlaced : &h->zigzagf_progressive, sizeof(h->zigzagf) );
 +    else
 +        memcpy( &h->zigzagf, PARAM_INTERLACED ? &h->zigzagf_interlaced : &h->zigzagf_progressive, sizeof(h->zigzagf) );
 +    x264_mc_init( h->param.cpu, &h->mc, MPEG2 );
      x264_quant_init( h, h->param.cpu, &h->quantf );
      x264_deblock_init( h->param.cpu, &h->loopf, PARAM_INTERLACED );
      x264_bitstream_init( h->param.cpu, &h->bsf );
@@@ -1369,12 -1086,11 +1369,12 @@@ void x264_noise_reduction_update( x264_
      h->nr_offset = h->nr_offset_denoise;
      h->nr_residual_sum = h->nr_residual_sum_buf[0];
      h->nr_count = h->nr_count_buf[0];
 -    for( int cat = 0; cat < 3 + CHROMA444; cat++ )
 +    for( int cat = 0; cat < count; cat++ )
      {
 -        int dct8x8 = cat&1;
 +        int dct8x8 = MPEG2 ? 1 : cat&1;
          int size = dct8x8 ? 64 : 16;
-         const uint16_t *weight = MPEG2 ? x264_mpeg2_weight2_tab :
 -        const uint32_t *weight = dct8x8 ? x264_dct8_weight2_tab : x264_dct4_weight2_tab;
++        const uint32_t *weight = MPEG2 ? x264_mpeg2_weight2_tab :
 +                                 dct8x8 ? x264_dct8_weight2_tab : x264_dct4_weight2_tab;
  
          if( h->nr_count[cat] > (dct8x8 ? (1<<16) : (1<<18)) )
          {
diff --cc encoder/rdo.c
Simple merge
Simple merge
diff --cc x264.c
Simple merge