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

   1 /*****************************************************************************
   2  * dct.c: h264 encoder library
   3  *****************************************************************************
   4  * Copyright (C) 2003 Laurent Aimar
   5  * $Id: dct.c,v 1.1 2004/06/03 19:27:06 fenrir Exp $
   6  *
   7  * Authors: 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_STDINT_H
  25 #include <stdint.h>
  26 #else
  27 #include <inttypes.h>
  28 #endif
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31
  32 #include "x264.h"
  33
  34 #include "dct.h"
  35 #ifdef HAVE_MMXEXT
  36 #   include "i386/dct.h"
  37 #endif
  38 #ifdef ARCH_PPC
  39 #   include "ppc/dct.h"
  40 #endif
  41
  42
  43 static inline int clip_uint8( int a )
  44 {
  45     if (a&(~255))
  46         return (-a)>>31;
  47     else
  48         return a;
  49 }
  50
  51 /*
  52  * XXX For all dct dc : input could be equal to output so ...
  53  */
  54
  55 static void dct2x2dc( int16_t d[2][2] )
  56 {
  57     int tmp[2][2];
  58
  59     tmp[0][0] = d[0][0] + d[0][1];
  60     tmp[1][0] = d[0][0] - d[0][1];
  61     tmp[0][1] = d[1][0] + d[1][1];
  62     tmp[1][1] = d[1][0] - d[1][1];
  63
  64     d[0][0] = tmp[0][0] + tmp[0][1];
  65     d[0][1] = tmp[1][0] + tmp[1][1];
  66     d[1][0] = tmp[0][0] - tmp[0][1];
  67     d[1][1] = tmp[1][0] - tmp[1][1];
  68 }
  69
  70 static void dct4x4dc( int16_t d[4][4] )
  71 {
  72     int16_t tmp[4][4];
  73     int s01, s23;
  74     int d01, d23;
  75     int i;
  76
  77     for( i = 0; i < 4; i++ )
  78     {
  79         s01 = d[i][0] + d[i][1];
  80         d01 = d[i][0] - d[i][1];
  81         s23 = d[i][2] + d[i][3];
  82         d23 = d[i][2] - d[i][3];
  83
  84         tmp[0][i] = s01 + s23;
  85         tmp[1][i] = s01 - s23;
  86         tmp[2][i] = d01 - d23;
  87         tmp[3][i] = d01 + d23;
  88     }
  89
  90     for( i = 0; i < 4; i++ )
  91     {
  92         s01 = tmp[i][0] + tmp[i][1];
  93         d01 = tmp[i][0] - tmp[i][1];
  94         s23 = tmp[i][2] + tmp[i][3];
  95         d23 = tmp[i][2] - tmp[i][3];
  96
  97         d[0][i] = ( s01 + s23 + 1 ) >> 1;
  98         d[1][i] = ( s01 - s23 + 1 ) >> 1;
  99         d[2][i] = ( d01 - d23 + 1 ) >> 1;
 100         d[3][i] = ( d01 + d23 + 1 ) >> 1;
 101     }
 102 }
 103
 104 static void idct4x4dc( int16_t d[4][4] )
 105 {
 106     int16_t tmp[4][4];
 107     int s01, s23;
 108     int d01, d23;
 109     int i;
 110
 111     for( i = 0; i < 4; i++ )
 112     {
 113         s01 = d[0][i] + d[1][i];
 114         d01 = d[0][i] - d[1][i];
 115         s23 = d[2][i] + d[3][i];
 116         d23 = d[2][i] - d[3][i];
 117
 118         tmp[0][i] = s01 + s23;
 119         tmp[1][i] = s01 - s23;
 120         tmp[2][i] = d01 - d23;
 121         tmp[3][i] = d01 + d23;
 122     }
 123
 124     for( i = 0; i < 4; i++ )
 125     {
 126         s01 = tmp[i][0] + tmp[i][1];
 127         d01 = tmp[i][0] - tmp[i][1];
 128         s23 = tmp[i][2] + tmp[i][3];
 129         d23 = tmp[i][2] - tmp[i][3];
 130
 131         d[i][0] = s01 + s23;
 132         d[i][1] = s01 - s23;
 133         d[i][2] = d01 - d23;
 134         d[i][3] = d01 + d23;
 135     }
 136 }
 137
 138 static void sub4x4_dct( int16_t dct[4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
 139 {
 140     int16_t d[4][4];
 141     int16_t tmp[4][4];
 142     int y, x;
 143     int i;
 144
 145     for( y = 0; y < 4; y++ )
 146     {
 147         for( x = 0; x < 4; x++ )
 148         {
 149             d[y][x] = pix1[x] - pix2[x];
 150         }
 151         pix1 += i_pix1;
 152         pix2 += i_pix2;
 153     }
 154
 155     for( i = 0; i < 4; i++ )
 156     {
 157         const int s03 = d[i][0] + d[i][3];
 158         const int s12 = d[i][1] + d[i][2];
 159         const int d03 = d[i][0] - d[i][3];
 160         const int d12 = d[i][1] - d[i][2];
 161
 162         tmp[0][i] =   s03 +   s12;
 163         tmp[1][i] = 2*d03 +   d12;
 164         tmp[2][i] =   s03 -   s12;
 165         tmp[3][i] =   d03 - 2*d12;
 166     }
 167
 168     for( i = 0; i < 4; i++ )
 169     {
 170         const int s03 = tmp[i][0] + tmp[i][3];
 171         const int s12 = tmp[i][1] + tmp[i][2];
 172         const int d03 = tmp[i][0] - tmp[i][3];
 173         const int d12 = tmp[i][1] - tmp[i][2];
 174
 175         dct[0][i] =   s03 +   s12;
 176         dct[1][i] = 2*d03 +   d12;
 177         dct[2][i] =   s03 -   s12;
 178         dct[3][i] =   d03 - 2*d12;
 179     }
 180 }
 181
 182 static void sub8x8_dct( int16_t dct[4][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
 183 {
 184     sub4x4_dct( dct[0], &pix1[0], i_pix1, &pix2[0], i_pix2 );
 185     sub4x4_dct( dct[1], &pix1[4], i_pix1, &pix2[4], i_pix2 );
 186     sub4x4_dct( dct[2], &pix1[4*i_pix1+0], i_pix1, &pix2[4*i_pix2+0], i_pix2 );
 187     sub4x4_dct( dct[3], &pix1[4*i_pix1+4], i_pix1, &pix2[4*i_pix2+4], i_pix2 );
 188 }
 189
 190 static void sub16x16_dct( int16_t dct[16][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
 191 {
 192     sub8x8_dct( &dct[ 0], pix1, i_pix1, pix2, i_pix2 );
 193     sub8x8_dct( &dct[ 4], &pix1[8], i_pix1, &pix2[8], i_pix2 );
 194     sub8x8_dct( &dct[ 8], &pix1[8*i_pix1], i_pix1, &pix2[8*i_pix2], i_pix2 );
 195     sub8x8_dct( &dct[12], &pix1[8*i_pix1+8], i_pix1, &pix2[8*i_pix2+8], i_pix2 );
 196 }
 197
 198
 199 static void add4x4_idct( uint8_t *p_dst, int i_dst, int16_t dct[4][4] )
 200 {
 201     int16_t d[4][4];
 202     int16_t tmp[4][4];
 203     int x, y;
 204     int i;
 205
 206     for( i = 0; i < 4; i++ )
 207     {
 208         const int s02 =  dct[i][0]     +  dct[i][2];
 209         const int d02 =  dct[i][0]     -  dct[i][2];
 210         const int s13 =  dct[i][1]     + (dct[i][3]>>1);
 211         const int d13 = (dct[i][1]>>1) -  dct[i][3];
 212
 213         tmp[i][0] = s02 + s13;
 214         tmp[i][1] = d02 + d13;
 215         tmp[i][2] = d02 - d13;
 216         tmp[i][3] = s02 - s13;
 217     }
 218
 219     for( i = 0; i < 4; i++ )
 220     {
 221         const int s02 =  tmp[0][i]     +  tmp[2][i];
 222         const int d02 =  tmp[0][i]     -  tmp[2][i];
 223         const int s13 =  tmp[1][i]     + (tmp[3][i]>>1);
 224         const int d13 = (tmp[1][i]>>1) -   tmp[3][i];
 225
 226         d[0][i] = ( s02 + s13 + 32 ) >> 6;
 227         d[1][i] = ( d02 + d13 + 32 ) >> 6;
 228         d[2][i] = ( d02 - d13 + 32 ) >> 6;
 229         d[3][i] = ( s02 - s13 + 32 ) >> 6;
 230     }
 231
 232
 233     for( y = 0; y < 4; y++ )
 234     {
 235         for( x = 0; x < 4; x++ )
 236         {
 237             p_dst[x] = clip_uint8( p_dst[x] + d[y][x] );
 238         }
 239         p_dst += i_dst;
 240     }
 241 }
 242
 243 static void add8x8_idct( uint8_t *p_dst, int i_dst, int16_t dct[4][4][4] )
 244 {
 245     add4x4_idct( p_dst, i_dst,             dct[0] );
 246     add4x4_idct( &p_dst[4], i_dst,         dct[1] );
 247     add4x4_idct( &p_dst[4*i_dst+0], i_dst, dct[2] );
 248     add4x4_idct( &p_dst[4*i_dst+4], i_dst, dct[3] );
 249 }
 250
 251 static void add16x16_idct( uint8_t *p_dst, int i_dst, int16_t dct[16][4][4] )
 252 {
 253     add8x8_idct( &p_dst[0], i_dst, &dct[0] );
 254     add8x8_idct( &p_dst[8], i_dst, &dct[4] );
 255     add8x8_idct( &p_dst[8*i_dst], i_dst, &dct[8] );
 256     add8x8_idct( &p_dst[8*i_dst+8], i_dst, &dct[12] );
 257 }
 258
 259 /****************************************************************************
 260  * 8x8 transform:
 261  ****************************************************************************/
 262
 263 static inline void dct8_1d( int16_t src[8][8], int16_t dst[8][8] )
 264 {
 265     int i;
 266     for( i = 0; i < 8; i++ )
 267     {
 268         const int s07 = src[i][0] + src[i][7];
 269         const int s16 = src[i][1] + src[i][6];
 270         const int s25 = src[i][2] + src[i][5];
 271         const int s34 = src[i][3] + src[i][4];
 272
 273         const int a0 = s07 + s34;
 274         const int a1 = s16 + s25;
 275         const int a2 = s07 - s34;
 276         const int a3 = s16 - s25;
 277
 278         const int d07 = src[i][0] - src[i][7];
 279         const int d16 = src[i][1] - src[i][6];
 280         const int d25 = src[i][2] - src[i][5];
 281         const int d34 = src[i][3] - src[i][4];
 282
 283         const int a4 = d16 + d25 + (d07 + (d07>>1));
 284         const int a5 = d07 - d34 - (d25 + (d25>>1));
 285         const int a6 = d07 + d34 - (d16 + (d16>>1));
 286         const int a7 = d16 - d25 + (d34 + (d34>>1));
 287
 288         dst[0][i] =  a0 + a1;
 289         dst[1][i] =  a4 + (a7>>2);
 290         dst[2][i] =  a2 + (a3>>1);
 291         dst[3][i] =  a5 + (a6>>2);
 292         dst[4][i] =  a0 - a1;
 293         dst[5][i] =  a6 - (a5>>2);
 294         dst[6][i] = (a2>>1) - a3;
 295         dst[7][i] = (a4>>2) - a7;
 296     }
 297 }
 298
 299 static void sub8x8_dct8( int16_t dct[8][8], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
 300 {
 301     int16_t d[8][8];
 302     int16_t tmp[8][8];
 303     int y, x;
 304
 305     for( y = 0; y < 8; y++ )
 306     {
 307         for( x = 0; x < 8; x++ )
 308         {
 309             d[y][x] = pix1[x] - pix2[x];
 310         }
 311         pix1 += i_pix1;
 312         pix2 += i_pix2;
 313     }
 314
 315     dct8_1d( d, tmp );
 316     dct8_1d( tmp, dct );
 317 }
 318
 319 static void sub16x16_dct8( int16_t dct[4][8][8], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
 320 {
 321     sub8x8_dct8( dct[0],  pix1,             i_pix1,  pix2,             i_pix2 );
 322     sub8x8_dct8( dct[1], &pix1[8],          i_pix1, &pix2[8],          i_pix2 );
 323     sub8x8_dct8( dct[2], &pix1[8*i_pix1],   i_pix1, &pix2[8*i_pix2],   i_pix2 );
 324     sub8x8_dct8( dct[3], &pix1[8*i_pix1+8], i_pix1, &pix2[8*i_pix2+8], i_pix2 );
 325 }
 326
 327 static inline void idct8_1d( int16_t src[8][8], int16_t dst[8][8] )
 328 {
 329     int i;
 330     for( i = 0; i < 8; i++ )
 331     {
 332         const int a0 =  src[i][0] + src[i][4];
 333         const int a2 =  src[i][0] - src[i][4];
 334         const int a4 = (src[i][2]>>1) - src[i][6];
 335         const int a6 = (src[i][6]>>1) + src[i][2];
 336
 337         const int b0 = a0 + a6;
 338         const int b2 = a2 + a4;
 339         const int b4 = a2 - a4;
 340         const int b6 = a0 - a6;
 341
 342         const int a1 = -src[i][3] + src[i][5] - src[i][7] - (src[i][7]>>1);
 343         const int a3 =  src[i][1] + src[i][7] - src[i][3] - (src[i][3]>>1);
 344         const int a5 = -src[i][1] + src[i][7] + src[i][5] + (src[i][5]>>1);
 345         const int a7 =  src[i][3] + src[i][5] + src[i][1] + (src[i][1]>>1);
 346
 347         const int b1 = (a7>>2) + a1;
 348         const int b3 =  a3 + (a5>>2);
 349         const int b5 = (a3>>2) - a5;
 350         const int b7 =  a7 - (a1>>2);
 351
 352         dst[0][i] = b0 + b7;
 353         dst[7][i] = b0 - b7;
 354         dst[1][i] = b2 + b5;
 355         dst[6][i] = b2 - b5;
 356         dst[2][i] = b4 + b3;
 357         dst[5][i] = b4 - b3;
 358         dst[3][i] = b6 + b1;
 359         dst[4][i] = b6 - b1;
 360     }
 361 }
 362
 363 static void add8x8_idct8( uint8_t *p_dst, int i_dst, int16_t dct[8][8] )
 364 {
 365     int16_t d[8][8];
 366     int16_t tmp[8][8];
 367     int y, x;
 368
 369     idct8_1d( dct, tmp );
 370     idct8_1d( tmp, d );
 371
 372     for( y = 0; y < 8; y++ )
 373     {
 374         for( x = 0; x < 8; x++ )
 375         {
 376             p_dst[x] = clip_uint8( p_dst[x] + ((d[y][x] + 32) >> 6) );
 377         }
 378         p_dst += i_dst;
 379     }
 380 }
 381
 382 static void add16x16_idct8( uint8_t *p_dst, int i_dst, int16_t dct[4][8][8] )
 383 {
 384     add8x8_idct8( &p_dst[0],         i_dst, dct[0] );
 385     add8x8_idct8( &p_dst[8],         i_dst, dct[1] );
 386     add8x8_idct8( &p_dst[8*i_dst],   i_dst, dct[2] );
 387     add8x8_idct8( &p_dst[8*i_dst+8], i_dst, dct[3] );
 388 }
 389
 390
 391 /****************************************************************************
 392  * x264_dct_init:
 393  ****************************************************************************/
 394 void x264_dct_init( int cpu, x264_dct_function_t *dctf )
 395 {
 396     dctf->sub4x4_dct    = sub4x4_dct;
 397     dctf->add4x4_idct   = add4x4_idct;
 398
 399     dctf->sub8x8_dct    = sub8x8_dct;
 400     dctf->add8x8_idct   = add8x8_idct;
 401
 402     dctf->sub16x16_dct  = sub16x16_dct;
 403     dctf->add16x16_idct = add16x16_idct;
 404
 405     dctf->sub8x8_dct8   = sub8x8_dct8;
 406     dctf->add8x8_idct8  = add8x8_idct8;
 407
 408     dctf->sub16x16_dct8  = sub16x16_dct8;
 409     dctf->add16x16_idct8 = add16x16_idct8;
 410
 411     dctf->dct4x4dc  = dct4x4dc;
 412     dctf->idct4x4dc = idct4x4dc;
 413
 414     dctf->dct2x2dc  = dct2x2dc;
 415     dctf->idct2x2dc = dct2x2dc;
 416
 417 #ifdef HAVE_MMXEXT
 418     if( cpu&X264_CPU_MMXEXT )
 419     {
 420         dctf->sub4x4_dct    = x264_sub4x4_dct_mmxext;
 421         dctf->sub8x8_dct    = x264_sub8x8_dct_mmxext;
 422         dctf->sub16x16_dct  = x264_sub16x16_dct_mmxext;
 423
 424         dctf->add4x4_idct   = x264_add4x4_idct_mmxext;
 425         dctf->add8x8_idct   = x264_add8x8_idct_mmxext;
 426         dctf->add16x16_idct = x264_add16x16_idct_mmxext;
 427
 428         dctf->dct4x4dc  = x264_dct4x4dc_mmxext;
 429         dctf->idct4x4dc = x264_idct4x4dc_mmxext;
 430     }
 431 #endif
 432 #ifdef ARCH_PPC
 433     if( cpu&X264_CPU_ALTIVEC )
 434     {
 435         dctf->sub4x4_dct    = x264_sub4x4_dct_altivec;
 436         dctf->sub8x8_dct    = x264_sub8x8_dct_altivec;
 437         dctf->sub16x16_dct  = x264_sub16x16_dct_altivec;
 438     }
 439 #endif
 440 }
 441