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

   1 /*****************************************************************************
   2  * mc.c: h264 encoder library (Motion Compensation)
   3  *****************************************************************************
   4  * Copyright (C) 2003 Laurent Aimar
   5  * $Id: mc.c,v 1.1 2004/06/03 19:27:07 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 #include "common.h"
  25
  26 #ifdef HAVE_MMX
  27 #include "x86/mc.h"
  28 #endif
  29 #ifdef ARCH_PPC
  30 #include "ppc/mc.h"
  31 #endif
  32
  33
  34 static inline int x264_tapfilter( uint8_t *pix, int i_pix_next )
  35 {
  36     return pix[-2*i_pix_next] - 5*pix[-1*i_pix_next] + 20*(pix[0] + pix[1*i_pix_next]) - 5*pix[ 2*i_pix_next] + pix[ 3*i_pix_next];
  37 }
  38 static inline int x264_tapfilter1( uint8_t *pix )
  39 {
  40     return pix[-2] - 5*pix[-1] + 20*(pix[0] + pix[1]) - 5*pix[ 2] + pix[ 3];
  41 }
  42
  43 static inline void pixel_avg( uint8_t *dst,  int i_dst_stride,
  44                               uint8_t *src1, int i_src1_stride,
  45                               uint8_t *src2, int i_src2_stride,
  46                               int i_width, int i_height )
  47 {
  48     int x, y;
  49     for( y = 0; y < i_height; y++ )
  50     {
  51         for( x = 0; x < i_width; x++ )
  52         {
  53             dst[x] = ( src1[x] + src2[x] + 1 ) >> 1;
  54         }
  55         dst  += i_dst_stride;
  56         src1 += i_src1_stride;
  57         src2 += i_src2_stride;
  58     }
  59 }
  60
  61 static inline void pixel_avg_wxh( uint8_t *dst, int i_dst, uint8_t *src, int i_src, int width, int height )
  62 {
  63     int x, y;
  64     for( y = 0; y < height; y++ )
  65     {
  66         for( x = 0; x < width; x++ )
  67         {
  68             dst[x] = ( dst[x] + src[x] + 1 ) >> 1;
  69         }
  70         dst += i_dst;
  71         src += i_src;
  72     }
  73 }
  74
  75 #define PIXEL_AVG_C( name, width, height ) \
  76 static void name( uint8_t *pix1, int i_stride_pix1, \
  77                   uint8_t *pix2, int i_stride_pix2 ) \
  78 { \
  79     pixel_avg_wxh( pix1, i_stride_pix1, pix2, i_stride_pix2, width, height ); \
  80 }
  81 PIXEL_AVG_C( pixel_avg_16x16, 16, 16 )
  82 PIXEL_AVG_C( pixel_avg_16x8,  16, 8 )
  83 PIXEL_AVG_C( pixel_avg_8x16,  8, 16 )
  84 PIXEL_AVG_C( pixel_avg_8x8,   8, 8 )
  85 PIXEL_AVG_C( pixel_avg_8x4,   8, 4 )
  86 PIXEL_AVG_C( pixel_avg_4x8,   4, 8 )
  87 PIXEL_AVG_C( pixel_avg_4x4,   4, 4 )
  88 PIXEL_AVG_C( pixel_avg_4x2,   4, 2 )
  89 PIXEL_AVG_C( pixel_avg_2x4,   2, 4 )
  90 PIXEL_AVG_C( pixel_avg_2x2,   2, 2 )
  91
  92
  93 /* Implicit weighted bipred only:
  94  * assumes log2_denom = 5, offset = 0, weight1 + weight2 = 64 */
  95 #define op_scale2(x) dst[x] = x264_clip_uint8( (dst[x]*i_weight1 + src[x]*i_weight2 + (1<<5)) >> 6 )
  96 static inline void pixel_avg_weight_wxh( uint8_t *dst, int i_dst, uint8_t *src, int i_src, int width, int height, int i_weight1 ){
  97     int y;
  98     const int i_weight2 = 64 - i_weight1;
  99     for(y=0; y<height; y++, dst += i_dst, src += i_src){
 100         op_scale2(0);
 101         op_scale2(1);
 102         if(width==2) continue;
 103         op_scale2(2);
 104         op_scale2(3);
 105         if(width==4) continue;
 106         op_scale2(4);
 107         op_scale2(5);
 108         op_scale2(6);
 109         op_scale2(7);
 110         if(width==8) continue;
 111         op_scale2(8);
 112         op_scale2(9);
 113         op_scale2(10);
 114         op_scale2(11);
 115         op_scale2(12);
 116         op_scale2(13);
 117         op_scale2(14);
 118         op_scale2(15);
 119     }
 120 }
 121
 122 #define PIXEL_AVG_WEIGHT_C( width, height ) \
 123 static void pixel_avg_weight_##width##x##height( \
 124                 uint8_t *pix1, int i_stride_pix1, \
 125                 uint8_t *pix2, int i_stride_pix2, int i_weight1 ) \
 126 { \
 127     pixel_avg_weight_wxh( pix1, i_stride_pix1, pix2, i_stride_pix2, width, height, i_weight1 ); \
 128 }
 129
 130 PIXEL_AVG_WEIGHT_C(16,16)
 131 PIXEL_AVG_WEIGHT_C(16,8)
 132 PIXEL_AVG_WEIGHT_C(8,16)
 133 PIXEL_AVG_WEIGHT_C(8,8)
 134 PIXEL_AVG_WEIGHT_C(8,4)
 135 PIXEL_AVG_WEIGHT_C(4,8)
 136 PIXEL_AVG_WEIGHT_C(4,4)
 137 PIXEL_AVG_WEIGHT_C(4,2)
 138 PIXEL_AVG_WEIGHT_C(2,4)
 139 PIXEL_AVG_WEIGHT_C(2,2)
 140 #undef op_scale2
 141 #undef PIXEL_AVG_WEIGHT_C
 142
 143 typedef void (*pf_mc_t)(uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height );
 144
 145 static void mc_copy( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
 146 {
 147     int y;
 148
 149     for( y = 0; y < i_height; y++ )
 150     {
 151         memcpy( dst, src, i_width );
 152
 153         src += i_src_stride;
 154         dst += i_dst_stride;
 155     }
 156 }
 157 static inline void mc_hh( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
 158 {
 159     int x, y;
 160
 161     for( y = 0; y < i_height; y++ )
 162     {
 163         for( x = 0; x < i_width; x++ )
 164         {
 165             dst[x] = x264_clip_uint8( ( x264_tapfilter1( &src[x] ) + 16 ) >> 5 );
 166         }
 167         src += i_src_stride;
 168         dst += i_dst_stride;
 169     }
 170 }
 171 static inline void mc_hv( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
 172 {
 173     int x, y;
 174
 175     for( y = 0; y < i_height; y++ )
 176     {
 177         for( x = 0; x < i_width; x++ )
 178         {
 179             dst[x] = x264_clip_uint8( ( x264_tapfilter( &src[x], i_src_stride ) + 16 ) >> 5 );
 180         }
 181         src += i_src_stride;
 182         dst += i_dst_stride;
 183     }
 184 }
 185 static inline void mc_hc( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
 186 {
 187     uint8_t *out;
 188     uint8_t *pix;
 189     int x, y;
 190
 191     for( x = 0; x < i_width; x++ )
 192     {
 193         int tap[6];
 194
 195         pix = &src[x];
 196         out = &dst[x];
 197
 198         tap[0] = x264_tapfilter1( &pix[-2*i_src_stride] );
 199         tap[1] = x264_tapfilter1( &pix[-1*i_src_stride] );
 200         tap[2] = x264_tapfilter1( &pix[ 0*i_src_stride] );
 201         tap[3] = x264_tapfilter1( &pix[ 1*i_src_stride] );
 202         tap[4] = x264_tapfilter1( &pix[ 2*i_src_stride] );
 203
 204         for( y = 0; y < i_height; y++ )
 205         {
 206             tap[5] = x264_tapfilter1( &pix[ 3*i_src_stride] );
 207
 208             *out = x264_clip_uint8( ( tap[0] - 5*tap[1] + 20 * tap[2] + 20 * tap[3] -5*tap[4] + tap[5] + 512 ) >> 10 );
 209
 210             /* Next line */
 211             pix += i_src_stride;
 212             out += i_dst_stride;
 213             tap[0] = tap[1];
 214             tap[1] = tap[2];
 215             tap[2] = tap[3];
 216             tap[3] = tap[4];
 217             tap[4] = tap[5];
 218         }
 219     }
 220 }
 221
 222 static void hpel_filter( uint8_t *dsth, uint8_t *dstv, uint8_t *dstc, uint8_t *src,
 223                          int stride, int width, int height )
 224 {
 225     mc_hh( src, stride, dsth, stride, width, height );
 226     mc_hv( src, stride, dstv, stride, width, height );
 227     mc_hc( src, stride, dstc, stride, width, height );
 228 }
 229
 230 static const int hpel_ref0[16] = {0,1,1,1,0,1,1,1,2,3,3,3,0,1,1,1};
 231 static const int hpel_ref1[16] = {0,0,0,0,2,2,3,2,2,2,3,2,2,2,3,2};
 232
 233 static void mc_luma( uint8_t *dst,    int i_dst_stride,
 234                      uint8_t *src[4], int i_src_stride,
 235                      int mvx, int mvy,
 236                      int i_width, int i_height )
 237 {
 238     int qpel_idx = ((mvy&3)<<2) + (mvx&3);
 239     int offset = (mvy>>2)*i_src_stride + (mvx>>2);
 240     uint8_t *src1 = src[hpel_ref0[qpel_idx]] + offset + ((mvy&3) == 3) * i_src_stride;
 241
 242     if( qpel_idx & 5 ) /* qpel interpolation needed */
 243     {
 244         uint8_t *src2 = src[hpel_ref1[qpel_idx]] + offset + ((mvx&3) == 3);
 245         pixel_avg( dst, i_dst_stride, src1, i_src_stride,
 246                    src2, i_src_stride, i_width, i_height );
 247     }
 248     else
 249     {
 250         mc_copy( src1, i_src_stride, dst, i_dst_stride, i_width, i_height );
 251     }
 252 }
 253
 254 static uint8_t *get_ref( uint8_t *dst,   int *i_dst_stride,
 255                          uint8_t *src[4], int i_src_stride,
 256                          int mvx, int mvy,
 257                          int i_width, int i_height )
 258 {
 259     int qpel_idx = ((mvy&3)<<2) + (mvx&3);
 260     int offset = (mvy>>2)*i_src_stride + (mvx>>2);
 261     uint8_t *src1 = src[hpel_ref0[qpel_idx]] + offset + ((mvy&3) == 3) * i_src_stride;
 262
 263     if( qpel_idx & 5 ) /* qpel interpolation needed */
 264     {
 265         uint8_t *src2 = src[hpel_ref1[qpel_idx]] + offset + ((mvx&3) == 3);
 266         pixel_avg( dst, *i_dst_stride, src1, i_src_stride,
 267                    src2, i_src_stride, i_width, i_height );
 268         return dst;
 269     }
 270     else
 271     {
 272         *i_dst_stride = i_src_stride;
 273         return src1;
 274     }
 275 }
 276
 277 /* full chroma mc (ie until 1/8 pixel)*/
 278 static void mc_chroma( uint8_t *dst, int i_dst_stride,
 279                        uint8_t *src, int i_src_stride,
 280                        int mvx, int mvy,
 281                        int i_width, int i_height )
 282 {
 283     uint8_t *srcp;
 284     int x, y;
 285
 286     const int d8x = mvx&0x07;
 287     const int d8y = mvy&0x07;
 288
 289     const int cA = (8-d8x)*(8-d8y);
 290     const int cB = d8x    *(8-d8y);
 291     const int cC = (8-d8x)*d8y;
 292     const int cD = d8x    *d8y;
 293
 294     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
 295     srcp = &src[i_src_stride];
 296
 297     for( y = 0; y < i_height; y++ )
 298     {
 299         for( x = 0; x < i_width; x++ )
 300         {
 301             dst[x] = ( cA*src[x]  + cB*src[x+1] +
 302                        cC*srcp[x] + cD*srcp[x+1] + 32 ) >> 6;
 303         }
 304         dst  += i_dst_stride;
 305
 306         src   = srcp;
 307         srcp += i_src_stride;
 308     }
 309 }
 310
 311 #define MC_COPY(W) \
 312 static void mc_copy_w##W( uint8_t *dst, int i_dst, uint8_t *src, int i_src, int i_height ) \
 313 { \
 314     mc_copy( src, i_src, dst, i_dst, W, i_height ); \
 315 }
 316 MC_COPY( 16 )
 317 MC_COPY( 8 )
 318 MC_COPY( 4 )
 319
 320 static void plane_copy( uint8_t *dst, int i_dst,
 321                         uint8_t *src, int i_src, int w, int h)
 322 {
 323     while( h-- )
 324     {
 325         memcpy( dst, src, w );
 326         dst += i_dst;
 327         src += i_src;
 328     }
 329 }
 330
 331 void prefetch_fenc_null( uint8_t *pix_y, int stride_y,
 332                          uint8_t *pix_uv, int stride_uv, int mb_x )
 333 {}
 334
 335 void prefetch_ref_null( uint8_t *pix, int stride, int parity )
 336 {}
 337
 338 void x264_mc_init( int cpu, x264_mc_functions_t *pf )
 339 {
 340     pf->mc_luma   = mc_luma;
 341     pf->get_ref   = get_ref;
 342     pf->mc_chroma = mc_chroma;
 343
 344     pf->avg[PIXEL_16x16]= pixel_avg_16x16;
 345     pf->avg[PIXEL_16x8] = pixel_avg_16x8;
 346     pf->avg[PIXEL_8x16] = pixel_avg_8x16;
 347     pf->avg[PIXEL_8x8]  = pixel_avg_8x8;
 348     pf->avg[PIXEL_8x4]  = pixel_avg_8x4;
 349     pf->avg[PIXEL_4x8]  = pixel_avg_4x8;
 350     pf->avg[PIXEL_4x4]  = pixel_avg_4x4;
 351     pf->avg[PIXEL_4x2]  = pixel_avg_4x2;
 352     pf->avg[PIXEL_2x4]  = pixel_avg_2x4;
 353     pf->avg[PIXEL_2x2]  = pixel_avg_2x2;
 354
 355     pf->avg_weight[PIXEL_16x16]= pixel_avg_weight_16x16;
 356     pf->avg_weight[PIXEL_16x8] = pixel_avg_weight_16x8;
 357     pf->avg_weight[PIXEL_8x16] = pixel_avg_weight_8x16;
 358     pf->avg_weight[PIXEL_8x8]  = pixel_avg_weight_8x8;
 359     pf->avg_weight[PIXEL_8x4]  = pixel_avg_weight_8x4;
 360     pf->avg_weight[PIXEL_4x8]  = pixel_avg_weight_4x8;
 361     pf->avg_weight[PIXEL_4x4]  = pixel_avg_weight_4x4;
 362     pf->avg_weight[PIXEL_4x2]  = pixel_avg_weight_4x2;
 363     pf->avg_weight[PIXEL_2x4]  = pixel_avg_weight_2x4;
 364     pf->avg_weight[PIXEL_2x2]  = pixel_avg_weight_2x2;
 365
 366     pf->copy[PIXEL_16x16] = mc_copy_w16;
 367     pf->copy[PIXEL_8x8]   = mc_copy_w8;
 368     pf->copy[PIXEL_4x4]   = mc_copy_w4;
 369
 370     pf->plane_copy = plane_copy;
 371     pf->hpel_filter = hpel_filter;
 372
 373     pf->prefetch_fenc = prefetch_fenc_null;
 374     pf->prefetch_ref  = prefetch_ref_null;
 375     pf->memcpy_aligned = memcpy;
 376
 377 #ifdef HAVE_MMX
 378     x264_mc_init_mmx( cpu, pf );
 379 #endif
 380 #ifdef ARCH_PPC
 381     if( cpu&X264_CPU_ALTIVEC )
 382         x264_mc_altivec_init( pf );
 383 #endif
 384 }
 385
 386 void x264_frame_filter( x264_t *h, x264_frame_t *frame, int mb_y, int b_end )
 387 {
 388     const int b_interlaced = h->sh.b_mbaff;
 389     const int stride = frame->i_stride[0] << b_interlaced;
 390     const int width = frame->i_width[0];
 391     int start = (mb_y*16 >> b_interlaced) - 8; // buffer = 4 for deblock + 3 for 6tap, rounded to 8
 392     int height = ((b_end ? frame->i_lines[0] : mb_y*16) >> b_interlaced) + 8;
 393     int offs = start*stride - 8; // buffer = 3 for 6tap, aligned to 8 for simd
 394     int x, y;
 395
 396     if( mb_y & b_interlaced )
 397         return;
 398
 399     for( y=0; y<=b_interlaced; y++, offs+=frame->i_stride[0] )
 400     {
 401         h->mc.hpel_filter(
 402             frame->filtered[1] + offs,
 403             frame->filtered[2] + offs,
 404             frame->filtered[3] + offs,
 405             frame->plane[0] + offs,
 406             stride, width + 16, height - start );
 407     }
 408
 409     /* generate integral image:
 410      * frame->integral contains 2 planes. in the upper plane, each element is
 411      * the sum of an 8x8 pixel region with top-left corner on that point.
 412      * in the lower plane, 4x4 sums (needed only with --partitions p4x4). */
 413
 414     if( frame->integral )
 415     {
 416         if( start < 0 )
 417         {
 418             memset( frame->integral - PADV * stride - PADH, 0, stride * sizeof(uint16_t) );
 419             start = -PADV;
 420         }
 421         if( b_end )
 422             height += PADV-8;
 423         for( y = start; y < height; y++ )
 424         {
 425             uint8_t  *ref  = frame->plane[0] + y * stride - PADH;
 426             uint16_t *line = frame->integral + (y+1) * stride - PADH + 1;
 427             uint16_t v = line[0] = 0;
 428             for( x = 1; x < stride-1; x++ )
 429                 line[x] = v += ref[x] + line[x-stride] - line[x-stride-1];
 430             line -= 8*stride;
 431             if( y >= 9-PADV )
 432             {
 433                 uint16_t *sum4 = line + stride * (frame->i_lines[0] + PADV*2);
 434                 for( x = 1; x < stride-8; x++, line++, sum4++ )
 435                 {
 436                     sum4[0] =  line[4+4*stride] - line[4] - line[4*stride] + line[0];
 437                     line[0] += line[8+8*stride] - line[8] - line[8*stride];
 438                 }
 439             }
 440         }
 441     }
 442 }
 443
 444 void x264_frame_init_lowres( x264_t *h, x264_frame_t *frame )
 445 {
 446     // FIXME: tapfilter?
 447     const int i_stride = frame->i_stride[0];
 448     const int i_stride2 = frame->i_stride_lowres;
 449     const int i_width2 = frame->i_width_lowres;
 450     int x, y, i;
 451     for( y = 0; y < frame->i_lines_lowres - 1; y++ )
 452     {
 453         uint8_t *src0 = &frame->plane[0][2*y*i_stride];
 454         uint8_t *src1 = src0+i_stride;
 455         uint8_t *src2 = src1+i_stride;
 456         uint8_t *dst0 = &frame->lowres[0][y*i_stride2];
 457         uint8_t *dsth = &frame->lowres[1][y*i_stride2];
 458         uint8_t *dstv = &frame->lowres[2][y*i_stride2];
 459         uint8_t *dstc = &frame->lowres[3][y*i_stride2];
 460         for( x = 0; x < i_width2 - 1; x++ )
 461         {
 462             dst0[x] = (src0[2*x  ] + src0[2*x+1] + src1[2*x  ] + src1[2*x+1] + 2) >> 2;
 463             dsth[x] = (src0[2*x+1] + src0[2*x+2] + src1[2*x+1] + src1[2*x+2] + 2) >> 2;
 464             dstv[x] = (src1[2*x  ] + src1[2*x+1] + src2[2*x  ] + src2[2*x+1] + 2) >> 2;
 465             dstc[x] = (src1[2*x+1] + src1[2*x+2] + src2[2*x+1] + src2[2*x+2] + 2) >> 2;
 466         }
 467         dst0[x] = (src0[2*x  ] + src0[2*x+1] + src1[2*x  ] + src1[2*x+1] + 2) >> 2;
 468         dstv[x] = (src1[2*x  ] + src1[2*x+1] + src2[2*x  ] + src2[2*x+1] + 2) >> 2;
 469         dsth[x] = (src0[2*x+1] + src1[2*x+1] + 1) >> 1;
 470         dstc[x] = (src1[2*x+1] + src2[2*x+1] + 1) >> 1;
 471     }
 472     for( i = 0; i < 4; i++ )
 473         memcpy( &frame->lowres[i][y*i_stride2], &frame->lowres[i][(y-1)*i_stride2], i_width2 );
 474
 475     for( y = 0; y < 16; y++ )
 476         for( x = 0; x < 16; x++ )
 477             frame->i_cost_est[x][y] = -1;
 478
 479     x264_frame_expand_border_lowres( frame );
 480 }
 481