git.sesse.net Git - x264/blob - common/dct.c

   1 /*****************************************************************************
   2  * dct.c: transform and zigzag
   3  *****************************************************************************
   4  * Copyright (C) 2003-2011 x264 project
   5  *
   6  * Authors: Loren Merritt <lorenm@u.washington.edu>
   7  *          Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22  *
  23  * This program is also available under a commercial proprietary license.
  24  * For more information, contact us at licensing@x264.com.
  25  *****************************************************************************/
  26
  27 #include "common.h"
  28 #if HAVE_MMX
  29 #   include "x86/dct.h"
  30 #endif
  31 #if ARCH_PPC
  32 #   include "ppc/dct.h"
  33 #endif
  34 #if ARCH_ARM
  35 #   include "arm/dct.h"
  36 #endif
  37
  38 int x264_dct4_weight2_zigzag[2][16];
  39 int x264_dct8_weight2_zigzag[2][64];
  40
  41 static void dct4x4dc( dctcoef d[16] )
  42 {
  43     dctcoef tmp[16];
  44
  45     for( int i = 0; i < 4; i++ )
  46     {
  47         int s01 = d[i*4+0] + d[i*4+1];
  48         int d01 = d[i*4+0] - d[i*4+1];
  49         int s23 = d[i*4+2] + d[i*4+3];
  50         int d23 = d[i*4+2] - d[i*4+3];
  51
  52         tmp[0*4+i] = s01 + s23;
  53         tmp[1*4+i] = s01 - s23;
  54         tmp[2*4+i] = d01 - d23;
  55         tmp[3*4+i] = d01 + d23;
  56     }
  57
  58     for( int i = 0; i < 4; i++ )
  59     {
  60         int s01 = tmp[i*4+0] + tmp[i*4+1];
  61         int d01 = tmp[i*4+0] - tmp[i*4+1];
  62         int s23 = tmp[i*4+2] + tmp[i*4+3];
  63         int d23 = tmp[i*4+2] - tmp[i*4+3];
  64
  65         d[i*4+0] = ( s01 + s23 + 1 ) >> 1;
  66         d[i*4+1] = ( s01 - s23 + 1 ) >> 1;
  67         d[i*4+2] = ( d01 - d23 + 1 ) >> 1;
  68         d[i*4+3] = ( d01 + d23 + 1 ) >> 1;
  69     }
  70 }
  71
  72 static void idct4x4dc( dctcoef d[16] )
  73 {
  74     dctcoef tmp[16];
  75
  76     for( int i = 0; i < 4; i++ )
  77     {
  78         int s01 = d[i*4+0] + d[i*4+1];
  79         int d01 = d[i*4+0] - d[i*4+1];
  80         int s23 = d[i*4+2] + d[i*4+3];
  81         int d23 = d[i*4+2] - d[i*4+3];
  82
  83         tmp[0*4+i] = s01 + s23;
  84         tmp[1*4+i] = s01 - s23;
  85         tmp[2*4+i] = d01 - d23;
  86         tmp[3*4+i] = d01 + d23;
  87     }
  88
  89     for( int i = 0; i < 4; i++ )
  90     {
  91         int s01 = tmp[i*4+0] + tmp[i*4+1];
  92         int d01 = tmp[i*4+0] - tmp[i*4+1];
  93         int s23 = tmp[i*4+2] + tmp[i*4+3];
  94         int d23 = tmp[i*4+2] - tmp[i*4+3];
  95
  96         d[i*4+0] = s01 + s23;
  97         d[i*4+1] = s01 - s23;
  98         d[i*4+2] = d01 - d23;
  99         d[i*4+3] = d01 + d23;
 100     }
 101 }
 102
 103 static inline void pixel_sub_wxh( dctcoef *diff, int i_size,
 104                                   pixel *pix1, int i_pix1, pixel *pix2, int i_pix2 )
 105 {
 106     for( int y = 0; y < i_size; y++ )
 107     {
 108         for( int x = 0; x < i_size; x++ )
 109             diff[x + y*i_size] = pix1[x] - pix2[x];
 110         pix1 += i_pix1;
 111         pix2 += i_pix2;
 112     }
 113 }
 114
 115 static void sub4x4_dct( dctcoef dct[16], pixel *pix1, pixel *pix2 )
 116 {
 117     dctcoef d[16];
 118     dctcoef tmp[16];
 119
 120     pixel_sub_wxh( d, 4, pix1, FENC_STRIDE, pix2, FDEC_STRIDE );
 121
 122     for( int i = 0; i < 4; i++ )
 123     {
 124         int s03 = d[i*4+0] + d[i*4+3];
 125         int s12 = d[i*4+1] + d[i*4+2];
 126         int d03 = d[i*4+0] - d[i*4+3];
 127         int d12 = d[i*4+1] - d[i*4+2];
 128
 129         tmp[0*4+i] =   s03 +   s12;
 130         tmp[1*4+i] = 2*d03 +   d12;
 131         tmp[2*4+i] =   s03 -   s12;
 132         tmp[3*4+i] =   d03 - 2*d12;
 133     }
 134
 135     for( int i = 0; i < 4; i++ )
 136     {
 137         int s03 = tmp[i*4+0] + tmp[i*4+3];
 138         int s12 = tmp[i*4+1] + tmp[i*4+2];
 139         int d03 = tmp[i*4+0] - tmp[i*4+3];
 140         int d12 = tmp[i*4+1] - tmp[i*4+2];
 141
 142         dct[i*4+0] =   s03 +   s12;
 143         dct[i*4+1] = 2*d03 +   d12;
 144         dct[i*4+2] =   s03 -   s12;
 145         dct[i*4+3] =   d03 - 2*d12;
 146     }
 147 }
 148
 149 static void sub8x8_dct( dctcoef dct[4][16], pixel *pix1, pixel *pix2 )
 150 {
 151     sub4x4_dct( dct[0], &pix1[0], &pix2[0] );
 152     sub4x4_dct( dct[1], &pix1[4], &pix2[4] );
 153     sub4x4_dct( dct[2], &pix1[4*FENC_STRIDE+0], &pix2[4*FDEC_STRIDE+0] );
 154     sub4x4_dct( dct[3], &pix1[4*FENC_STRIDE+4], &pix2[4*FDEC_STRIDE+4] );
 155 }
 156
 157 static void sub16x16_dct( dctcoef dct[16][16], pixel *pix1, pixel *pix2 )
 158 {
 159     sub8x8_dct( &dct[ 0], &pix1[0], &pix2[0] );
 160     sub8x8_dct( &dct[ 4], &pix1[8], &pix2[8] );
 161     sub8x8_dct( &dct[ 8], &pix1[8*FENC_STRIDE+0], &pix2[8*FDEC_STRIDE+0] );
 162     sub8x8_dct( &dct[12], &pix1[8*FENC_STRIDE+8], &pix2[8*FDEC_STRIDE+8] );
 163 }
 164
 165 static int sub4x4_dct_dc( pixel *pix1, pixel *pix2 )
 166 {
 167     dctcoef d[16];
 168     int sum = 0;
 169
 170     pixel_sub_wxh( d, 4, pix1, FENC_STRIDE, pix2, FDEC_STRIDE );
 171
 172     sum += d[0] + d[1] + d[2] + d[3] + d[4] + d[5] + d[6] + d[7];
 173     sum += d[8] + d[9] + d[10] + d[11] + d[12] + d[13] + d[14] + d[15];
 174
 175     return sum;
 176 }
 177
 178 static void sub8x8_dct_dc( dctcoef dct[4], pixel *pix1, pixel *pix2 )
 179 {
 180     dct[0] = sub4x4_dct_dc( &pix1[0], &pix2[0] );
 181     dct[1] = sub4x4_dct_dc( &pix1[4], &pix2[4] );
 182     dct[2] = sub4x4_dct_dc( &pix1[4*FENC_STRIDE+0], &pix2[4*FDEC_STRIDE+0] );
 183     dct[3] = sub4x4_dct_dc( &pix1[4*FENC_STRIDE+4], &pix2[4*FDEC_STRIDE+4] );
 184
 185     /* 2x2 DC transform */
 186     int d0 = dct[0] + dct[1];
 187     int d1 = dct[2] + dct[3];
 188     int d2 = dct[0] - dct[1];
 189     int d3 = dct[2] - dct[3];
 190     dct[0] = d0 + d1;
 191     dct[2] = d2 + d3;
 192     dct[1] = d0 - d1;
 193     dct[3] = d2 - d3;
 194 }
 195
 196 static void add4x4_idct( pixel *p_dst, dctcoef dct[16] )
 197 {
 198     dctcoef d[16];
 199     dctcoef tmp[16];
 200
 201     for( int i = 0; i < 4; i++ )
 202     {
 203         int s02 =  dct[0*4+i]     +  dct[2*4+i];
 204         int d02 =  dct[0*4+i]     -  dct[2*4+i];
 205         int s13 =  dct[1*4+i]     + (dct[3*4+i]>>1);
 206         int d13 = (dct[1*4+i]>>1) -  dct[3*4+i];
 207
 208         tmp[i*4+0] = s02 + s13;
 209         tmp[i*4+1] = d02 + d13;
 210         tmp[i*4+2] = d02 - d13;
 211         tmp[i*4+3] = s02 - s13;
 212     }
 213
 214     for( int i = 0; i < 4; i++ )
 215     {
 216         int s02 =  tmp[0*4+i]     +  tmp[2*4+i];
 217         int d02 =  tmp[0*4+i]     -  tmp[2*4+i];
 218         int s13 =  tmp[1*4+i]     + (tmp[3*4+i]>>1);
 219         int d13 = (tmp[1*4+i]>>1) -  tmp[3*4+i];
 220
 221         d[0*4+i] = ( s02 + s13 + 32 ) >> 6;
 222         d[1*4+i] = ( d02 + d13 + 32 ) >> 6;
 223         d[2*4+i] = ( d02 - d13 + 32 ) >> 6;
 224         d[3*4+i] = ( s02 - s13 + 32 ) >> 6;
 225     }
 226
 227
 228     for( int y = 0; y < 4; y++ )
 229     {
 230         for( int x = 0; x < 4; x++ )
 231             p_dst[x] = x264_clip_pixel( p_dst[x] + d[y*4+x] );
 232         p_dst += FDEC_STRIDE;
 233     }
 234 }
 235
 236 static void add8x8_idct( pixel *p_dst, dctcoef dct[4][16] )
 237 {
 238     add4x4_idct( &p_dst[0],               dct[0] );
 239     add4x4_idct( &p_dst[4],               dct[1] );
 240     add4x4_idct( &p_dst[4*FDEC_STRIDE+0], dct[2] );
 241     add4x4_idct( &p_dst[4*FDEC_STRIDE+4], dct[3] );
 242 }
 243
 244 static void add16x16_idct( pixel *p_dst, dctcoef dct[16][16] )
 245 {
 246     add8x8_idct( &p_dst[0],               &dct[0] );
 247     add8x8_idct( &p_dst[8],               &dct[4] );
 248     add8x8_idct( &p_dst[8*FDEC_STRIDE+0], &dct[8] );
 249     add8x8_idct( &p_dst[8*FDEC_STRIDE+8], &dct[12] );
 250 }
 251
 252 /****************************************************************************
 253  * 8x8 transform:
 254  ****************************************************************************/
 255
 256 #define DCT8_1D {\
 257     int s07 = SRC(0) + SRC(7);\
 258     int s16 = SRC(1) + SRC(6);\
 259     int s25 = SRC(2) + SRC(5);\
 260     int s34 = SRC(3) + SRC(4);\
 261     int a0 = s07 + s34;\
 262     int a1 = s16 + s25;\
 263     int a2 = s07 - s34;\
 264     int a3 = s16 - s25;\
 265     int d07 = SRC(0) - SRC(7);\
 266     int d16 = SRC(1) - SRC(6);\
 267     int d25 = SRC(2) - SRC(5);\
 268     int d34 = SRC(3) - SRC(4);\
 269     int a4 = d16 + d25 + (d07 + (d07>>1));\
 270     int a5 = d07 - d34 - (d25 + (d25>>1));\
 271     int a6 = d07 + d34 - (d16 + (d16>>1));\
 272     int a7 = d16 - d25 + (d34 + (d34>>1));\
 273     DST(0) =  a0 + a1     ;\
 274     DST(1) =  a4 + (a7>>2);\
 275     DST(2) =  a2 + (a3>>1);\
 276     DST(3) =  a5 + (a6>>2);\
 277     DST(4) =  a0 - a1     ;\
 278     DST(5) =  a6 - (a5>>2);\
 279     DST(6) = (a2>>1) - a3 ;\
 280     DST(7) = (a4>>2) - a7 ;\
 281 }
 282
 283 static void sub8x8_dct8( dctcoef dct[64], pixel *pix1, pixel *pix2 )
 284 {
 285     dctcoef tmp[64];
 286
 287     pixel_sub_wxh( tmp, 8, pix1, FENC_STRIDE, pix2, FDEC_STRIDE );
 288
 289 #define SRC(x) tmp[x*8+i]
 290 #define DST(x) tmp[x*8+i]
 291     for( int i = 0; i < 8; i++ )
 292         DCT8_1D
 293 #undef SRC
 294 #undef DST
 295
 296 #define SRC(x) tmp[i*8+x]
 297 #define DST(x) dct[x*8+i]
 298     for( int i = 0; i < 8; i++ )
 299         DCT8_1D
 300 #undef SRC
 301 #undef DST
 302 }
 303
 304 static void sub16x16_dct8( dctcoef dct[4][64], pixel *pix1, pixel *pix2 )
 305 {
 306     sub8x8_dct8( dct[0], &pix1[0],               &pix2[0] );
 307     sub8x8_dct8( dct[1], &pix1[8],               &pix2[8] );
 308     sub8x8_dct8( dct[2], &pix1[8*FENC_STRIDE+0], &pix2[8*FDEC_STRIDE+0] );
 309     sub8x8_dct8( dct[3], &pix1[8*FENC_STRIDE+8], &pix2[8*FDEC_STRIDE+8] );
 310 }
 311
 312 #define IDCT8_1D {\
 313     int a0 =  SRC(0) + SRC(4);\
 314     int a2 =  SRC(0) - SRC(4);\
 315     int a4 = (SRC(2)>>1) - SRC(6);\
 316     int a6 = (SRC(6)>>1) + SRC(2);\
 317     int b0 = a0 + a6;\
 318     int b2 = a2 + a4;\
 319     int b4 = a2 - a4;\
 320     int b6 = a0 - a6;\
 321     int a1 = -SRC(3) + SRC(5) - SRC(7) - (SRC(7)>>1);\
 322     int a3 =  SRC(1) + SRC(7) - SRC(3) - (SRC(3)>>1);\
 323     int a5 = -SRC(1) + SRC(7) + SRC(5) + (SRC(5)>>1);\
 324     int a7 =  SRC(3) + SRC(5) + SRC(1) + (SRC(1)>>1);\
 325     int b1 = (a7>>2) + a1;\
 326     int b3 =  a3 + (a5>>2);\
 327     int b5 = (a3>>2) - a5;\
 328     int b7 =  a7 - (a1>>2);\
 329     DST(0, b0 + b7);\
 330     DST(1, b2 + b5);\
 331     DST(2, b4 + b3);\
 332     DST(3, b6 + b1);\
 333     DST(4, b6 - b1);\
 334     DST(5, b4 - b3);\
 335     DST(6, b2 - b5);\
 336     DST(7, b0 - b7);\
 337 }
 338
 339 static void add8x8_idct8( pixel *dst, dctcoef dct[64] )
 340 {
 341     dct[0] += 32; // rounding for the >>6 at the end
 342
 343 #define SRC(x)     dct[x*8+i]
 344 #define DST(x,rhs) dct[x*8+i] = (rhs)
 345     for( int i = 0; i < 8; i++ )
 346         IDCT8_1D
 347 #undef SRC
 348 #undef DST
 349
 350 #define SRC(x)     dct[i*8+x]
 351 #define DST(x,rhs) dst[i + x*FDEC_STRIDE] = x264_clip_pixel( dst[i + x*FDEC_STRIDE] + ((rhs) >> 6) );
 352     for( int i = 0; i < 8; i++ )
 353         IDCT8_1D
 354 #undef SRC
 355 #undef DST
 356 }
 357
 358 static void add16x16_idct8( pixel *dst, dctcoef dct[4][64] )
 359 {
 360     add8x8_idct8( &dst[0],               dct[0] );
 361     add8x8_idct8( &dst[8],               dct[1] );
 362     add8x8_idct8( &dst[8*FDEC_STRIDE+0], dct[2] );
 363     add8x8_idct8( &dst[8*FDEC_STRIDE+8], dct[3] );
 364 }
 365
 366 static void inline add4x4_idct_dc( pixel *p_dst, dctcoef dc )
 367 {
 368     dc = (dc + 32) >> 6;
 369     for( int i = 0; i < 4; i++, p_dst += FDEC_STRIDE )
 370     {
 371         p_dst[0] = x264_clip_pixel( p_dst[0] + dc );
 372         p_dst[1] = x264_clip_pixel( p_dst[1] + dc );
 373         p_dst[2] = x264_clip_pixel( p_dst[2] + dc );
 374         p_dst[3] = x264_clip_pixel( p_dst[3] + dc );
 375     }
 376 }
 377
 378 static void add8x8_idct_dc( pixel *p_dst, dctcoef dct[4] )
 379 {
 380     add4x4_idct_dc( &p_dst[0],               dct[0] );
 381     add4x4_idct_dc( &p_dst[4],               dct[1] );
 382     add4x4_idct_dc( &p_dst[4*FDEC_STRIDE+0], dct[2] );
 383     add4x4_idct_dc( &p_dst[4*FDEC_STRIDE+4], dct[3] );
 384 }
 385
 386 static void add16x16_idct_dc( pixel *p_dst, dctcoef dct[16] )
 387 {
 388     for( int i = 0; i < 4; i++, dct += 4, p_dst += 4*FDEC_STRIDE )
 389     {
 390         add4x4_idct_dc( &p_dst[ 0], dct[0] );
 391         add4x4_idct_dc( &p_dst[ 4], dct[1] );
 392         add4x4_idct_dc( &p_dst[ 8], dct[2] );
 393         add4x4_idct_dc( &p_dst[12], dct[3] );
 394     }
 395 }
 396
 397
 398 /****************************************************************************
 399  * x264_dct_init:
 400  ****************************************************************************/
 401 void x264_dct_init( int cpu, x264_dct_function_t *dctf )
 402 {
 403     dctf->sub4x4_dct    = sub4x4_dct;
 404     dctf->add4x4_idct   = add4x4_idct;
 405
 406     dctf->sub8x8_dct    = sub8x8_dct;
 407     dctf->sub8x8_dct_dc = sub8x8_dct_dc;
 408     dctf->add8x8_idct   = add8x8_idct;
 409     dctf->add8x8_idct_dc = add8x8_idct_dc;
 410
 411     dctf->sub16x16_dct  = sub16x16_dct;
 412     dctf->add16x16_idct = add16x16_idct;
 413     dctf->add16x16_idct_dc = add16x16_idct_dc;
 414
 415     dctf->sub8x8_dct8   = sub8x8_dct8;
 416     dctf->add8x8_idct8  = add8x8_idct8;
 417
 418     dctf->sub16x16_dct8  = sub16x16_dct8;
 419     dctf->add16x16_idct8 = add16x16_idct8;
 420
 421     dctf->dct4x4dc  = dct4x4dc;
 422     dctf->idct4x4dc = idct4x4dc;
 423
 424 #if HIGH_BIT_DEPTH
 425 #if HAVE_MMX
 426     if( cpu&X264_CPU_MMX )
 427     {
 428         dctf->sub4x4_dct    = x264_sub4x4_dct_mmx;
 429         dctf->sub8x8_dct    = x264_sub8x8_dct_mmx;
 430         dctf->sub16x16_dct  = x264_sub16x16_dct_mmx;
 431     }
 432     if( cpu&X264_CPU_SSE2 )
 433     {
 434         dctf->add4x4_idct     = x264_add4x4_idct_sse2;
 435         dctf->dct4x4dc        = x264_dct4x4dc_sse2;
 436         dctf->idct4x4dc       = x264_idct4x4dc_sse2;
 437         dctf->add8x8_idct     = x264_add8x8_idct_sse2;
 438         dctf->add16x16_idct   = x264_add16x16_idct_sse2;
 439         dctf->add8x8_idct_dc  = x264_add8x8_idct_dc_sse2;
 440         dctf->add16x16_idct_dc= x264_add16x16_idct_dc_sse2;
 441     }
 442     if( cpu&X264_CPU_AVX )
 443     {
 444         dctf->add4x4_idct     = x264_add4x4_idct_avx;
 445         dctf->dct4x4dc        = x264_dct4x4dc_avx;
 446         dctf->idct4x4dc       = x264_idct4x4dc_avx;
 447         dctf->add8x8_idct     = x264_add8x8_idct_avx;
 448         dctf->add16x16_idct   = x264_add16x16_idct_avx;
 449         dctf->add8x8_idct_dc  = x264_add8x8_idct_dc_avx;
 450         dctf->add16x16_idct_dc= x264_add16x16_idct_dc_avx;
 451     }
 452 #endif // HAVE_MMX
 453 #else // !HIGH_BIT_DEPTH
 454 #if HAVE_MMX
 455     if( cpu&X264_CPU_MMX )
 456     {
 457         dctf->sub4x4_dct    = x264_sub4x4_dct_mmx;
 458         dctf->add4x4_idct   = x264_add4x4_idct_mmx;
 459         dctf->add8x8_idct_dc = x264_add8x8_idct_dc_mmx;
 460         dctf->add16x16_idct_dc = x264_add16x16_idct_dc_mmx;
 461         dctf->dct4x4dc      = x264_dct4x4dc_mmx;
 462         dctf->idct4x4dc     = x264_idct4x4dc_mmx;
 463         dctf->sub8x8_dct_dc = x264_sub8x8_dct_dc_mmxext;
 464
 465 #if !ARCH_X86_64
 466         dctf->sub8x8_dct    = x264_sub8x8_dct_mmx;
 467         dctf->sub16x16_dct  = x264_sub16x16_dct_mmx;
 468         dctf->add8x8_idct   = x264_add8x8_idct_mmx;
 469         dctf->add16x16_idct = x264_add16x16_idct_mmx;
 470
 471         dctf->sub8x8_dct8   = x264_sub8x8_dct8_mmx;
 472         dctf->sub16x16_dct8 = x264_sub16x16_dct8_mmx;
 473         dctf->add8x8_idct8  = x264_add8x8_idct8_mmx;
 474         dctf->add16x16_idct8= x264_add16x16_idct8_mmx;
 475 #endif
 476     }
 477
 478     if( cpu&X264_CPU_SSE2 )
 479     {
 480         dctf->sub8x8_dct8   = x264_sub8x8_dct8_sse2;
 481         dctf->sub16x16_dct8 = x264_sub16x16_dct8_sse2;
 482         dctf->sub8x8_dct_dc = x264_sub8x8_dct_dc_sse2;
 483         dctf->add8x8_idct8  = x264_add8x8_idct8_sse2;
 484         dctf->add16x16_idct8= x264_add16x16_idct8_sse2;
 485
 486         dctf->sub8x8_dct    = x264_sub8x8_dct_sse2;
 487         dctf->sub16x16_dct  = x264_sub16x16_dct_sse2;
 488         dctf->add8x8_idct   = x264_add8x8_idct_sse2;
 489         dctf->add16x16_idct = x264_add16x16_idct_sse2;
 490         dctf->add16x16_idct_dc = x264_add16x16_idct_dc_sse2;
 491     }
 492
 493     if( (cpu&X264_CPU_SSSE3) && !(cpu&X264_CPU_SLOW_ATOM) )
 494     {
 495         dctf->sub4x4_dct    = x264_sub4x4_dct_ssse3;
 496         dctf->sub8x8_dct    = x264_sub8x8_dct_ssse3;
 497         dctf->sub16x16_dct  = x264_sub16x16_dct_ssse3;
 498         dctf->sub8x8_dct8   = x264_sub8x8_dct8_ssse3;
 499         dctf->sub16x16_dct8 = x264_sub16x16_dct8_ssse3;
 500         dctf->add8x8_idct_dc = x264_add8x8_idct_dc_ssse3;
 501         dctf->add16x16_idct_dc = x264_add16x16_idct_dc_ssse3;
 502     }
 503
 504     if( cpu&X264_CPU_SSE4 )
 505         dctf->add4x4_idct   = x264_add4x4_idct_sse4;
 506
 507     if( cpu&X264_CPU_AVX )
 508     {
 509         dctf->add4x4_idct      = x264_add4x4_idct_avx;
 510         dctf->add8x8_idct      = x264_add8x8_idct_avx;
 511         dctf->add16x16_idct    = x264_add16x16_idct_avx;
 512         dctf->add8x8_idct8     = x264_add8x8_idct8_avx;
 513         dctf->add16x16_idct8   = x264_add16x16_idct8_avx;
 514         dctf->add16x16_idct_dc = x264_add16x16_idct_dc_avx;
 515         dctf->sub8x8_dct       = x264_sub8x8_dct_avx;
 516         dctf->sub16x16_dct     = x264_sub16x16_dct_avx;
 517         dctf->sub8x8_dct8      = x264_sub8x8_dct8_avx;
 518         dctf->sub16x16_dct8    = x264_sub16x16_dct8_avx;
 519     }
 520 #endif //HAVE_MMX
 521
 522 #if HAVE_ALTIVEC
 523     if( cpu&X264_CPU_ALTIVEC )
 524     {
 525         dctf->sub4x4_dct    = x264_sub4x4_dct_altivec;
 526         dctf->sub8x8_dct    = x264_sub8x8_dct_altivec;
 527         dctf->sub16x16_dct  = x264_sub16x16_dct_altivec;
 528
 529         dctf->add4x4_idct   = x264_add4x4_idct_altivec;
 530         dctf->add8x8_idct   = x264_add8x8_idct_altivec;
 531         dctf->add16x16_idct = x264_add16x16_idct_altivec;
 532
 533         dctf->sub8x8_dct8   = x264_sub8x8_dct8_altivec;
 534         dctf->sub16x16_dct8 = x264_sub16x16_dct8_altivec;
 535
 536         dctf->add8x8_idct8  = x264_add8x8_idct8_altivec;
 537         dctf->add16x16_idct8= x264_add16x16_idct8_altivec;
 538     }
 539 #endif
 540
 541 #if HAVE_ARMV6
 542     if( cpu&X264_CPU_NEON )
 543     {
 544         dctf->sub4x4_dct    = x264_sub4x4_dct_neon;
 545         dctf->sub8x8_dct    = x264_sub8x8_dct_neon;
 546         dctf->sub16x16_dct  = x264_sub16x16_dct_neon;
 547         dctf->add8x8_idct_dc = x264_add8x8_idct_dc_neon;
 548         dctf->add16x16_idct_dc = x264_add16x16_idct_dc_neon;
 549         dctf->sub8x8_dct_dc = x264_sub8x8_dct_dc_neon;
 550         dctf->dct4x4dc      = x264_dct4x4dc_neon;
 551         dctf->idct4x4dc     = x264_idct4x4dc_neon;
 552
 553         dctf->add4x4_idct   = x264_add4x4_idct_neon;
 554         dctf->add8x8_idct   = x264_add8x8_idct_neon;
 555         dctf->add16x16_idct = x264_add16x16_idct_neon;
 556
 557         dctf->sub8x8_dct8   = x264_sub8x8_dct8_neon;
 558         dctf->sub16x16_dct8 = x264_sub16x16_dct8_neon;
 559
 560         dctf->add8x8_idct8  = x264_add8x8_idct8_neon;
 561         dctf->add16x16_idct8= x264_add16x16_idct8_neon;
 562     }
 563 #endif
 564 #endif // HIGH_BIT_DEPTH
 565 }
 566
 567 void x264_dct_init_weights( void )
 568 {
 569     for( int j = 0; j < 2; j++ )
 570     {
 571         for( int i = 0; i < 16; i++ )
 572             x264_dct4_weight2_zigzag[j][i] = x264_dct4_weight2_tab[ x264_zigzag_scan4[j][i] ];
 573         for( int i = 0; i < 64; i++ )
 574             x264_dct8_weight2_zigzag[j][i] = x264_dct8_weight2_tab[ x264_zigzag_scan8[j][i] ];
 575     }
 576 }
 577
 578
 579 #define ZIG(i,y,x) level[i] = dct[x*8+y];
 580 #define ZIGZAG8_FRAME\
 581     ZIG( 0,0,0) ZIG( 1,0,1) ZIG( 2,1,0) ZIG( 3,2,0)\
 582     ZIG( 4,1,1) ZIG( 5,0,2) ZIG( 6,0,3) ZIG( 7,1,2)\
 583     ZIG( 8,2,1) ZIG( 9,3,0) ZIG(10,4,0) ZIG(11,3,1)\
 584     ZIG(12,2,2) ZIG(13,1,3) ZIG(14,0,4) ZIG(15,0,5)\
 585     ZIG(16,1,4) ZIG(17,2,3) ZIG(18,3,2) ZIG(19,4,1)\
 586     ZIG(20,5,0) ZIG(21,6,0) ZIG(22,5,1) ZIG(23,4,2)\
 587     ZIG(24,3,3) ZIG(25,2,4) ZIG(26,1,5) ZIG(27,0,6)\
 588     ZIG(28,0,7) ZIG(29,1,6) ZIG(30,2,5) ZIG(31,3,4)\
 589     ZIG(32,4,3) ZIG(33,5,2) ZIG(34,6,1) ZIG(35,7,0)\
 590     ZIG(36,7,1) ZIG(37,6,2) ZIG(38,5,3) ZIG(39,4,4)\
 591     ZIG(40,3,5) ZIG(41,2,6) ZIG(42,1,7) ZIG(43,2,7)\
 592     ZIG(44,3,6) ZIG(45,4,5) ZIG(46,5,4) ZIG(47,6,3)\
 593     ZIG(48,7,2) ZIG(49,7,3) ZIG(50,6,4) ZIG(51,5,5)\
 594     ZIG(52,4,6) ZIG(53,3,7) ZIG(54,4,7) ZIG(55,5,6)\
 595     ZIG(56,6,5) ZIG(57,7,4) ZIG(58,7,5) ZIG(59,6,6)\
 596     ZIG(60,5,7) ZIG(61,6,7) ZIG(62,7,6) ZIG(63,7,7)\
 597
 598 #define ZIGZAG8_FIELD\
 599     ZIG( 0,0,0) ZIG( 1,1,0) ZIG( 2,2,0) ZIG( 3,0,1)\
 600     ZIG( 4,1,1) ZIG( 5,3,0) ZIG( 6,4,0) ZIG( 7,2,1)\
 601     ZIG( 8,0,2) ZIG( 9,3,1) ZIG(10,5,0) ZIG(11,6,0)\
 602     ZIG(12,7,0) ZIG(13,4,1) ZIG(14,1,2) ZIG(15,0,3)\
 603     ZIG(16,2,2) ZIG(17,5,1) ZIG(18,6,1) ZIG(19,7,1)\
 604     ZIG(20,3,2) ZIG(21,1,3) ZIG(22,0,4) ZIG(23,2,3)\
 605     ZIG(24,4,2) ZIG(25,5,2) ZIG(26,6,2) ZIG(27,7,2)\
 606     ZIG(28,3,3) ZIG(29,1,4) ZIG(30,0,5) ZIG(31,2,4)\
 607     ZIG(32,4,3) ZIG(33,5,3) ZIG(34,6,3) ZIG(35,7,3)\
 608     ZIG(36,3,4) ZIG(37,1,5) ZIG(38,0,6) ZIG(39,2,5)\
 609     ZIG(40,4,4) ZIG(41,5,4) ZIG(42,6,4) ZIG(43,7,4)\
 610     ZIG(44,3,5) ZIG(45,1,6) ZIG(46,2,6) ZIG(47,4,5)\
 611     ZIG(48,5,5) ZIG(49,6,5) ZIG(50,7,5) ZIG(51,3,6)\
 612     ZIG(52,0,7) ZIG(53,1,7) ZIG(54,4,6) ZIG(55,5,6)\
 613     ZIG(56,6,6) ZIG(57,7,6) ZIG(58,2,7) ZIG(59,3,7)\
 614     ZIG(60,4,7) ZIG(61,5,7) ZIG(62,6,7) ZIG(63,7,7)
 615
 616 #define ZIGZAG4_FRAME\
 617     ZIGDC( 0,0,0) ZIG( 1,0,1) ZIG( 2,1,0) ZIG( 3,2,0)\
 618     ZIG( 4,1,1) ZIG( 5,0,2) ZIG( 6,0,3) ZIG( 7,1,2)\
 619     ZIG( 8,2,1) ZIG( 9,3,0) ZIG(10,3,1) ZIG(11,2,2)\
 620     ZIG(12,1,3) ZIG(13,2,3) ZIG(14,3,2) ZIG(15,3,3)
 621
 622 #define ZIGZAG4_FIELD\
 623     ZIGDC( 0,0,0) ZIG( 1,1,0) ZIG( 2,0,1) ZIG( 3,2,0)\
 624     ZIG( 4,3,0) ZIG( 5,1,1) ZIG( 6,2,1) ZIG( 7,3,1)\
 625     ZIG( 8,0,2) ZIG( 9,1,2) ZIG(10,2,2) ZIG(11,3,2)\
 626     ZIG(12,0,3) ZIG(13,1,3) ZIG(14,2,3) ZIG(15,3,3)
 627
 628 static void zigzag_scan_8x8_frame( dctcoef level[64], dctcoef dct[64] )
 629 {
 630     ZIGZAG8_FRAME
 631 }
 632
 633 static void zigzag_scan_8x8_field( dctcoef level[64], dctcoef dct[64] )
 634 {
 635     ZIGZAG8_FIELD
 636 }
 637
 638 #undef ZIG
 639 #define ZIG(i,y,x) level[i] = dct[x*4+y];
 640 #define ZIGDC(i,y,x) ZIG(i,y,x)
 641
 642 static void zigzag_scan_4x4_frame( dctcoef level[16], dctcoef dct[16] )
 643 {
 644     ZIGZAG4_FRAME
 645 }
 646
 647 static void zigzag_scan_4x4_field( dctcoef level[16], dctcoef dct[16] )
 648 {
 649     memcpy( level, dct, 2 * sizeof(dctcoef) );
 650     ZIG(2,0,1) ZIG(3,2,0) ZIG(4,3,0) ZIG(5,1,1)
 651     memcpy( level+6, dct+6, 10 * sizeof(dctcoef) );
 652 }
 653
 654 #undef ZIG
 655 #define ZIG(i,y,x) {\
 656     int oe = x+y*FENC_STRIDE;\
 657     int od = x+y*FDEC_STRIDE;\
 658     level[i] = p_src[oe] - p_dst[od];\
 659     nz |= level[i];\
 660 }
 661 #define COPY4x4\
 662     CPPIXEL_X4( p_dst+0*FDEC_STRIDE, p_src+0*FENC_STRIDE );\
 663     CPPIXEL_X4( p_dst+1*FDEC_STRIDE, p_src+1*FENC_STRIDE );\
 664     CPPIXEL_X4( p_dst+2*FDEC_STRIDE, p_src+2*FENC_STRIDE );\
 665     CPPIXEL_X4( p_dst+3*FDEC_STRIDE, p_src+3*FENC_STRIDE );
 666 #define CPPIXEL_X8(dst,src) ( CPPIXEL_X4(dst,src), CPPIXEL_X4(dst+4,src+4) )
 667 #define COPY8x8\
 668     CPPIXEL_X8( p_dst+0*FDEC_STRIDE, p_src+0*FENC_STRIDE );\
 669     CPPIXEL_X8( p_dst+1*FDEC_STRIDE, p_src+1*FENC_STRIDE );\
 670     CPPIXEL_X8( p_dst+2*FDEC_STRIDE, p_src+2*FENC_STRIDE );\
 671     CPPIXEL_X8( p_dst+3*FDEC_STRIDE, p_src+3*FENC_STRIDE );\
 672     CPPIXEL_X8( p_dst+4*FDEC_STRIDE, p_src+4*FENC_STRIDE );\
 673     CPPIXEL_X8( p_dst+5*FDEC_STRIDE, p_src+5*FENC_STRIDE );\
 674     CPPIXEL_X8( p_dst+6*FDEC_STRIDE, p_src+6*FENC_STRIDE );\
 675     CPPIXEL_X8( p_dst+7*FDEC_STRIDE, p_src+7*FENC_STRIDE );
 676
 677 static int zigzag_sub_4x4_frame( dctcoef level[16], const pixel *p_src, pixel *p_dst )
 678 {
 679     int nz = 0;
 680     ZIGZAG4_FRAME
 681     COPY4x4
 682     return !!nz;
 683 }
 684
 685 static int zigzag_sub_4x4_field( dctcoef level[16], const pixel *p_src, pixel *p_dst )
 686 {
 687     int nz = 0;
 688     ZIGZAG4_FIELD
 689     COPY4x4
 690     return !!nz;
 691 }
 692
 693 #undef ZIGDC
 694 #define ZIGDC(i,y,x) {\
 695     int oe = x+y*FENC_STRIDE;\
 696     int od = x+y*FDEC_STRIDE;\
 697     *dc = p_src[oe] - p_dst[od];\
 698     level[0] = 0;\
 699 }
 700
 701 static int zigzag_sub_4x4ac_frame( dctcoef level[16], const pixel *p_src, pixel *p_dst, dctcoef *dc )
 702 {
 703     int nz = 0;
 704     ZIGZAG4_FRAME
 705     COPY4x4
 706     return !!nz;
 707 }
 708
 709 static int zigzag_sub_4x4ac_field( dctcoef level[16], const pixel *p_src, pixel *p_dst, dctcoef *dc )
 710 {
 711     int nz = 0;
 712     ZIGZAG4_FIELD
 713     COPY4x4
 714     return !!nz;
 715 }
 716
 717 static int zigzag_sub_8x8_frame( dctcoef level[64], const pixel *p_src, pixel *p_dst )
 718 {
 719     int nz = 0;
 720     ZIGZAG8_FRAME
 721     COPY8x8
 722     return !!nz;
 723 }
 724 static int zigzag_sub_8x8_field( dctcoef level[64], const pixel *p_src, pixel *p_dst )
 725 {
 726     int nz = 0;
 727     ZIGZAG8_FIELD
 728     COPY8x8
 729     return !!nz;
 730 }
 731
 732 #undef ZIG
 733 #undef COPY4x4
 734
 735 static void zigzag_interleave_8x8_cavlc( dctcoef *dst, dctcoef *src, uint8_t *nnz )
 736 {
 737     for( int i = 0; i < 4; i++ )
 738     {
 739         int nz = 0;
 740         for( int j = 0; j < 16; j++ )
 741         {
 742             nz |= src[i+j*4];
 743             dst[i*16+j] = src[i+j*4];
 744         }
 745         nnz[(i&1) + (i>>1)*8] = !!nz;
 746     }
 747 }
 748
 749 void x264_zigzag_init( int cpu, x264_zigzag_function_t *pf, int b_interlaced )
 750 {
 751     if( b_interlaced )
 752     {
 753         pf->scan_8x8   = zigzag_scan_8x8_field;
 754         pf->scan_4x4   = zigzag_scan_4x4_field;
 755         pf->sub_8x8    = zigzag_sub_8x8_field;
 756         pf->sub_4x4    = zigzag_sub_4x4_field;
 757         pf->sub_4x4ac  = zigzag_sub_4x4ac_field;
 758 #if HIGH_BIT_DEPTH
 759 #if HAVE_MMX
 760         if( cpu&X264_CPU_SSE2 )
 761             pf->scan_4x4 = x264_zigzag_scan_4x4_field_sse2;
 762         if( cpu&X264_CPU_SSE4 )
 763             pf->scan_8x8 = x264_zigzag_scan_8x8_field_sse4;
 764         if( cpu&X264_CPU_AVX )
 765             pf->scan_8x8 = x264_zigzag_scan_8x8_field_avx;
 766 #endif // HAVE_MMX
 767 #else
 768 #if HAVE_MMX
 769         if( cpu&X264_CPU_MMXEXT )
 770         {
 771             pf->scan_4x4 = x264_zigzag_scan_4x4_field_mmxext;
 772             pf->scan_8x8 = x264_zigzag_scan_8x8_field_mmxext;
 773         }
 774         if( cpu&X264_CPU_SSSE3 )
 775         {
 776             pf->sub_4x4  = x264_zigzag_sub_4x4_field_ssse3;
 777             pf->sub_4x4ac= x264_zigzag_sub_4x4ac_field_ssse3;
 778         }
 779         if( cpu&X264_CPU_AVX )
 780         {
 781             pf->sub_4x4  = x264_zigzag_sub_4x4_field_avx;
 782 #if ARCH_X86_64
 783             pf->sub_4x4ac= x264_zigzag_sub_4x4ac_field_avx;
 784 #endif
 785         }
 786 #endif // HAVE_MMX
 787 #if HAVE_ALTIVEC
 788         if( cpu&X264_CPU_ALTIVEC )
 789             pf->scan_4x4   = x264_zigzag_scan_4x4_field_altivec;
 790 #endif
 791 #endif // HIGH_BIT_DEPTH
 792     }
 793     else
 794     {
 795         pf->scan_8x8   = zigzag_scan_8x8_frame;
 796         pf->scan_4x4   = zigzag_scan_4x4_frame;
 797         pf->sub_8x8    = zigzag_sub_8x8_frame;
 798         pf->sub_4x4    = zigzag_sub_4x4_frame;
 799         pf->sub_4x4ac  = zigzag_sub_4x4ac_frame;
 800 #if HIGH_BIT_DEPTH
 801 #if HAVE_MMX
 802         if( cpu&X264_CPU_SSE2 )
 803         {
 804             pf->scan_4x4 = x264_zigzag_scan_4x4_frame_sse2;
 805             pf->scan_8x8 = x264_zigzag_scan_8x8_frame_sse2;
 806         }
 807 #if ARCH_X86_64
 808         if( cpu&X264_CPU_AVX )
 809         {
 810             pf->scan_4x4 = x264_zigzag_scan_4x4_frame_avx;
 811             pf->scan_8x8 = x264_zigzag_scan_8x8_frame_avx;
 812         }
 813 #endif // ARCH_X86_64
 814 #endif // HAVE_MMX
 815 #else
 816 #if HAVE_MMX
 817         if( cpu&X264_CPU_MMX )
 818             pf->scan_4x4 = x264_zigzag_scan_4x4_frame_mmx;
 819         if( cpu&X264_CPU_MMXEXT )
 820             pf->scan_8x8 = x264_zigzag_scan_8x8_frame_mmxext;
 821         if( cpu&X264_CPU_SSE2_IS_FAST )
 822             pf->scan_8x8 = x264_zigzag_scan_8x8_frame_sse2;
 823         if( cpu&X264_CPU_SSSE3 )
 824         {
 825             pf->sub_4x4  = x264_zigzag_sub_4x4_frame_ssse3;
 826             pf->sub_4x4ac= x264_zigzag_sub_4x4ac_frame_ssse3;
 827             pf->scan_8x8 = x264_zigzag_scan_8x8_frame_ssse3;
 828             if( cpu&X264_CPU_SHUFFLE_IS_FAST )
 829                 pf->scan_4x4 = x264_zigzag_scan_4x4_frame_ssse3;
 830         }
 831         if( cpu&X264_CPU_AVX )
 832         {
 833             pf->sub_4x4  = x264_zigzag_sub_4x4_frame_avx;
 834 #if ARCH_X86_64
 835             pf->sub_4x4ac= x264_zigzag_sub_4x4ac_frame_avx;
 836 #endif
 837             if( cpu&X264_CPU_SHUFFLE_IS_FAST )
 838                 pf->scan_4x4 = x264_zigzag_scan_4x4_frame_avx;
 839         }
 840 #endif // HAVE_MMX
 841 #if HAVE_ALTIVEC
 842         if( cpu&X264_CPU_ALTIVEC )
 843             pf->scan_4x4   = x264_zigzag_scan_4x4_frame_altivec;
 844 #endif
 845 #if HAVE_ARMV6
 846         if( cpu&X264_CPU_NEON )
 847             pf->scan_4x4 = x264_zigzag_scan_4x4_frame_neon;
 848 #endif
 849 #endif // HIGH_BIT_DEPTH
 850     }
 851
 852     pf->interleave_8x8_cavlc = zigzag_interleave_8x8_cavlc;
 853 #if HAVE_MMX
 854 #if HIGH_BIT_DEPTH
 855     if( cpu&X264_CPU_SSE2 )
 856         pf->interleave_8x8_cavlc = x264_zigzag_interleave_8x8_cavlc_sse2;
 857     if( cpu&X264_CPU_AVX )
 858         pf->interleave_8x8_cavlc = x264_zigzag_interleave_8x8_cavlc_avx;
 859 #else
 860     if( cpu&X264_CPU_MMX )
 861         pf->interleave_8x8_cavlc = x264_zigzag_interleave_8x8_cavlc_mmx;
 862     if( cpu&X264_CPU_SHUFFLE_IS_FAST )
 863         pf->interleave_8x8_cavlc = x264_zigzag_interleave_8x8_cavlc_sse2;
 864     if( cpu&X264_CPU_AVX )
 865         pf->interleave_8x8_cavlc = x264_zigzag_interleave_8x8_cavlc_avx;
 866 #endif // HIGH_BIT_DEPTH
 867 #endif
 868 }