Merge commit '7a03145ed7cb4f1ce794b5126559dd6f38029243'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 19 Feb 2013 11:32:04 +0000 (12:32 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 19 Feb 2013 11:32:12 +0000 (12:32 +0100)
* commit '7a03145ed7cb4f1ce794b5126559dd6f38029243':
  x86: dsputil: int --> ptrdiff_t for ff_put_pixels16_mmxext line_size param

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/x86/dsputil_mmx.c

@@@ -3,23 -3,23 +3,23 @@@
   * Copyright (c) 2000, 2001 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
 - *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + *
 + * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
   */
  
  #include "libavutil/attributes.h"
  #include "libavcodec/h264dsp.h"
  #include "libavcodec/mpegvideo.h"
  #include "libavcodec/simple_idct.h"
 +#include "libavcodec/videodsp.h"
  #include "dsputil_mmx.h"
  #include "idct_xvid.h"
 +#include "diracdsp_mmx.h"
  
  //#undef NDEBUG
  //#include <assert.h>
@@@ -149,7 -147,7 +149,7 @@@ void ff_avg_pixels8_xy2_3dnow(uint8_t *
  
  void ff_put_pixels8_mmxext(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h);
  static void ff_put_pixels16_mmxext(uint8_t *block, const uint8_t *pixels,
-                                    int line_size, int h)
+                                    ptrdiff_t line_size, int h)
  {
      ff_put_pixels8_mmxext(block,     pixels,     line_size, h);
      ff_put_pixels8_mmxext(block + 8, pixels + 8, line_size, h);
@@@ -470,7 -468,7 +470,7 @@@ void ff_add_pixels_clamped_mmx(const in
  }
  
  static void put_pixels8_mmx(uint8_t *block, const uint8_t *pixels,
 -                            int line_size, int h)
 +                            ptrdiff_t line_size, int h)
  {
      __asm__ volatile (
          "lea   (%3, %3), %%"REG_a"      \n\t"
  }
  
  static void put_pixels16_mmx(uint8_t *block, const uint8_t *pixels,
 -                             int line_size, int h)
 +                             ptrdiff_t line_size, int h)
  {
      __asm__ volatile (
          "lea   (%3, %3), %%"REG_a"      \n\t"
@@@ -689,7 -687,7 +689,7 @@@ static void draw_edges_mmx(uint8_t *buf
              : "+r"(ptr)
              : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)
              );
 -    } else {
 +    } else if(w==16){
          __asm__ volatile (
              "1:                                 \n\t"
              "movd            (%0), %%mm0        \n\t"
              : "+r"(ptr)
              : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)
              );
 +    } else {
 +        av_assert1(w == 4);
 +        __asm__ volatile (
 +            "1:                             \n\t"
 +            "movd            (%0), %%mm0    \n\t"
 +            "punpcklbw      %%mm0, %%mm0    \n\t"
 +            "punpcklwd      %%mm0, %%mm0    \n\t"
 +            "movd           %%mm0, -4(%0)   \n\t"
 +            "movd      -4(%0, %2), %%mm1    \n\t"
 +            "punpcklbw      %%mm1, %%mm1    \n\t"
 +            "punpckhwd      %%mm1, %%mm1    \n\t"
 +            "punpckhdq      %%mm1, %%mm1    \n\t"
 +            "movd           %%mm1, (%0, %2) \n\t"
 +            "add               %1, %0       \n\t"
 +            "cmp               %3, %0       \n\t"
 +            "jb                1b           \n\t"
 +            : "+r"(ptr)
 +            : "r"((x86_reg)wrap), "r"((x86_reg)width), "r"(ptr + wrap * height)
 +            );
      }
  
      /* top and bottom (and hopefully also the corners) */
@@@ -1190,15 -1169,10 +1190,15 @@@ void ff_avg_rv40_qpel16_mc33_mmx(uint8_
    avg_pixels16_xy2_mmx(dst, src, stride, 16);
  }
  
 -static void gmc_mmx(uint8_t *dst, uint8_t *src,
 -                    int stride, int h, int ox, int oy,
 -                    int dxx, int dxy, int dyx, int dyy,
 -                    int shift, int r, int width, int height)
 +typedef void emulated_edge_mc_func(uint8_t *dst, const uint8_t *src,
 +                                   ptrdiff_t linesize, int block_w, int block_h,
 +                                   int src_x, int src_y, int w, int h);
 +
 +static av_always_inline void gmc(uint8_t *dst, uint8_t *src,
 +                                 int stride, int h, int ox, int oy,
 +                                 int dxx, int dxy, int dyx, int dyy,
 +                                 int shift, int r, int width, int height,
 +                                 emulated_edge_mc_func *emu_edge_fn)
  {
      const int w    = 8;
      const int ix   = ox  >> (16 + shift);
      const uint16_t dxy4[4] = { dxys, dxys, dxys, dxys };
      const uint16_t dyy4[4] = { dyys, dyys, dyys, dyys };
      const uint64_t shift2 = 2 * shift;
 +#define MAX_STRIDE 4096U
 +#define MAX_H 8U
 +    uint8_t edge_buf[(MAX_H + 1) * MAX_STRIDE];
      int x, y;
  
      const int dxw = (dxx - (1 << (16 + shift))) * (w - 1);
      const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);
      const int dxh = dxy * (h - 1);
      const int dyw = dyx * (w - 1);
 +    int need_emu =  (unsigned)ix >= width  - w ||
 +                    (unsigned)iy >= height - h;
 +
      if ( // non-constant fullpel offset (3% of blocks)
          ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |
           (oy ^ (oy + dyw)) | (oy ^ (oy + dyh)) | (oy ^ (oy + dyw + dyh))) >> (16 + shift)
          // uses more than 16 bits of subpel mv (only at huge resolution)
 -        || (dxx | dxy | dyx | dyy) & 15 ||
 -        (unsigned)ix >= width  - w ||
 -        (unsigned)iy >= height - h) {
 +        || (dxx | dxy | dyx | dyy) & 15
 +        || (need_emu && (h > MAX_H || stride > MAX_STRIDE))) {
          // FIXME could still use mmx for some of the rows
          ff_gmc_c(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy,
                   shift, r, width, height);
      }
  
      src += ix + iy * stride;
 +    if (need_emu) {
 +        emu_edge_fn(edge_buf, src, stride, w + 1, h + 1, ix, iy, width, height);
 +        src = edge_buf;
 +    }
  
      __asm__ volatile (
          "movd         %0, %%mm6         \n\t"
          src += 4 - h * stride;
      }
  }
 +
 +#if CONFIG_VIDEODSP
 +#if HAVE_YASM
 +#if ARCH_X86_32
 +static void gmc_mmx(uint8_t *dst, uint8_t *src,
 +                    int stride, int h, int ox, int oy,
 +                    int dxx, int dxy, int dyx, int dyy,
 +                    int shift, int r, int width, int height)
 +{
 +    gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
 +        width, height, &ff_emulated_edge_mc_8);
 +}
 +#endif
 +static void gmc_sse(uint8_t *dst, uint8_t *src,
 +                    int stride, int h, int ox, int oy,
 +                    int dxx, int dxy, int dyx, int dyy,
 +                    int shift, int r, int width, int height)
 +{
 +    gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
 +        width, height, &ff_emulated_edge_mc_8);
 +}
 +#else
 +static void gmc_mmx(uint8_t *dst, uint8_t *src,
 +                    int stride, int h, int ox, int oy,
 +                    int dxx, int dxy, int dyx, int dyy,
 +                    int shift, int r, int width, int height)
 +{
 +    gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
 +        width, height, &ff_emulated_edge_mc_8);
 +}
 +#endif
 +#endif
 +
  #endif /* HAVE_INLINE_ASM */
  
  void ff_put_pixels16_sse2(uint8_t *block, const uint8_t *pixels,
@@@ -1398,107 -1330,6 +1398,107 @@@ void ff_avg_vc1_mspel_mc00_mmxext(uint8
  }
  #endif /* HAVE_YASM */
  
 +#if CONFIG_DIRAC_DECODER
 +#define DIRAC_PIXOP(OPNAME2, OPNAME, EXT)\
 +void ff_ ## OPNAME2 ## _dirac_pixels8_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    if (h&3)\
 +        ff_ ## OPNAME2 ## _dirac_pixels8_c(dst, src, stride, h);\
 +    else\
 +        OPNAME ## _pixels8_ ## EXT(dst, src[0], stride, h);\
 +}\
 +void ff_ ## OPNAME2 ## _dirac_pixels16_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    if (h&3)\
 +        ff_ ## OPNAME2 ## _dirac_pixels16_c(dst, src, stride, h);\
 +    else\
 +        OPNAME ## _pixels16_ ## EXT(dst, src[0], stride, h);\
 +}\
 +void ff_ ## OPNAME2 ## _dirac_pixels32_ ## EXT(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
 +{\
 +    if (h&3) {\
 +        ff_ ## OPNAME2 ## _dirac_pixels32_c(dst, src, stride, h);\
 +    } else {\
 +        OPNAME ## _pixels16_ ## EXT(dst   , src[0]   , stride, h);\
 +        OPNAME ## _pixels16_ ## EXT(dst+16, src[0]+16, stride, h);\
 +    }\
 +}
 +
 +#if HAVE_MMX_INLINE
 +DIRAC_PIXOP(put, put, mmx)
 +DIRAC_PIXOP(avg, avg, mmx)
 +#endif
 +
 +#if HAVE_YASM
 +DIRAC_PIXOP(avg, ff_avg, mmxext)
 +
 +void ff_put_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
 +{
 +    if (h&3)
 +        ff_put_dirac_pixels16_c(dst, src, stride, h);
 +    else
 +    ff_put_pixels16_sse2(dst, src[0], stride, h);
 +}
 +void ff_avg_dirac_pixels16_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
 +{
 +    if (h&3)
 +        ff_avg_dirac_pixels16_c(dst, src, stride, h);
 +    else
 +    ff_avg_pixels16_sse2(dst, src[0], stride, h);
 +}
 +void ff_put_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
 +{
 +    if (h&3) {
 +        ff_put_dirac_pixels32_c(dst, src, stride, h);
 +    } else {
 +    ff_put_pixels16_sse2(dst   , src[0]   , stride, h);
 +    ff_put_pixels16_sse2(dst+16, src[0]+16, stride, h);
 +    }
 +}
 +void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride, int h)
 +{
 +    if (h&3) {
 +        ff_avg_dirac_pixels32_c(dst, src, stride, h);
 +    } else {
 +    ff_avg_pixels16_sse2(dst   , src[0]   , stride, h);
 +    ff_avg_pixels16_sse2(dst+16, src[0]+16, stride, h);
 +    }
 +}
 +#endif
 +#endif
 +
 +/* XXX: Those functions should be suppressed ASAP when all IDCTs are
 + * converted. */
 +#if CONFIG_GPL
 +static void ff_libmpeg2mmx_idct_put(uint8_t *dest, int line_size,
 +                                    int16_t *block)
 +{
 +    ff_mmx_idct(block);
 +    ff_put_pixels_clamped_mmx(block, dest, line_size);
 +}
 +
 +static void ff_libmpeg2mmx_idct_add(uint8_t *dest, int line_size,
 +                                    int16_t *block)
 +{
 +    ff_mmx_idct(block);
 +    ff_add_pixels_clamped_mmx(block, dest, line_size);
 +}
 +
 +static void ff_libmpeg2mmx2_idct_put(uint8_t *dest, int line_size,
 +                                     int16_t *block)
 +{
 +    ff_mmxext_idct(block);
 +    ff_put_pixels_clamped_mmx(block, dest, line_size);
 +}
 +
 +static void ff_libmpeg2mmx2_idct_add(uint8_t *dest, int line_size,
 +                                     int16_t *block)
 +{
 +    ff_mmxext_idct(block);
 +    ff_add_pixels_clamped_mmx(block, dest, line_size);
 +}
 +#endif
 +
  #if HAVE_INLINE_ASM
  static void vector_clipf_sse(float *dst, const float *src,
                               float min, float max, int len)
@@@ -1633,11 -1464,24 +1633,11 @@@ static av_cold void dsputil_init_mmx(DS
          SET_HPEL_FUNCS(put,        [1],  8, mmx);
          SET_HPEL_FUNCS(put_no_rnd, [1],  8, mmx);
          SET_HPEL_FUNCS(avg,        [1],  8, mmx);
 -
 -        switch (avctx->idct_algo) {
 -        case FF_IDCT_AUTO:
 -        case FF_IDCT_SIMPLEMMX:
 -            c->idct_put              = ff_simple_idct_put_mmx;
 -            c->idct_add              = ff_simple_idct_add_mmx;
 -            c->idct                  = ff_simple_idct_mmx;
 -            c->idct_permutation_type = FF_SIMPLE_IDCT_PERM;
 -            break;
 -        case FF_IDCT_XVIDMMX:
 -            c->idct_put              = ff_idct_xvid_mmx_put;
 -            c->idct_add              = ff_idct_xvid_mmx_add;
 -            c->idct                  = ff_idct_xvid_mmx;
 -            break;
 -        }
      }
  
 +#if CONFIG_VIDEODSP && (ARCH_X86_32 || !HAVE_YASM)
      c->gmc = gmc_mmx;
 +#endif
  
      c->add_bytes = add_bytes_mmx;
  #endif /* HAVE_INLINE_ASM */
@@@ -1697,6 -1541,14 +1697,6 @@@ static av_cold void dsputil_init_mmxext
      }
  #endif /* HAVE_YASM */
  
 -#if HAVE_INLINE_ASM
 -    if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX) {
 -        c->idct_put = ff_idct_xvid_mmxext_put;
 -        c->idct_add = ff_idct_xvid_mmxext_add;
 -        c->idct     = ff_idct_xvid_mmxext;
 -    }
 -#endif /* HAVE_INLINE_ASM */
 -
  #if HAVE_MMXEXT_EXTERNAL
      if (CONFIG_VP3_DECODER && (avctx->codec_id == AV_CODEC_ID_VP3 ||
                                 avctx->codec_id == AV_CODEC_ID_THEORA)) {
@@@ -1775,12 -1627,6 +1775,12 @@@ static av_cold void dsputil_init_sse(DS
  
      c->vector_clipf = vector_clipf_sse;
  #endif /* HAVE_INLINE_ASM */
 +
 +#if HAVE_YASM
 +#if HAVE_INLINE_ASM && CONFIG_VIDEODSP
 +    c->gmc = gmc_sse;
 +#endif
 +#endif /* HAVE_YASM */
  }
  
  static av_cold void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
@@@ -1859,50 -1705,8 +1859,50 @@@ av_cold void ff_dsputil_init_mmx(DSPCon
          c->add_hfyu_median_prediction = add_hfyu_median_prediction_cmov;
  #endif
  
 -    if (mm_flags & AV_CPU_FLAG_MMX)
 +    if (mm_flags & AV_CPU_FLAG_MMX) {
 +#if HAVE_INLINE_ASM
 +        const int idct_algo = avctx->idct_algo;
 +
 +        if (avctx->lowres == 0 && avctx->bits_per_raw_sample <= 8) {
 +            if (idct_algo == FF_IDCT_AUTO || idct_algo == FF_IDCT_SIMPLEMMX) {
 +                c->idct_put              = ff_simple_idct_put_mmx;
 +                c->idct_add              = ff_simple_idct_add_mmx;
 +                c->idct                  = ff_simple_idct_mmx;
 +                c->idct_permutation_type = FF_SIMPLE_IDCT_PERM;
 +#if CONFIG_GPL
 +            } else if (idct_algo == FF_IDCT_LIBMPEG2MMX) {
 +                if (mm_flags & AV_CPU_FLAG_MMX2) {
 +                    c->idct_put = ff_libmpeg2mmx2_idct_put;
 +                    c->idct_add = ff_libmpeg2mmx2_idct_add;
 +                    c->idct     = ff_mmxext_idct;
 +                } else {
 +                    c->idct_put = ff_libmpeg2mmx_idct_put;
 +                    c->idct_add = ff_libmpeg2mmx_idct_add;
 +                    c->idct     = ff_mmx_idct;
 +                }
 +                c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
 +#endif
 +            } else if (idct_algo == FF_IDCT_XVIDMMX) {
 +                if (mm_flags & AV_CPU_FLAG_SSE2) {
 +                    c->idct_put              = ff_idct_xvid_sse2_put;
 +                    c->idct_add              = ff_idct_xvid_sse2_add;
 +                    c->idct                  = ff_idct_xvid_sse2;
 +                    c->idct_permutation_type = FF_SSE2_IDCT_PERM;
 +                } else if (mm_flags & AV_CPU_FLAG_MMXEXT) {
 +                    c->idct_put              = ff_idct_xvid_mmxext_put;
 +                    c->idct_add              = ff_idct_xvid_mmxext_add;
 +                    c->idct                  = ff_idct_xvid_mmxext;
 +                } else {
 +                    c->idct_put              = ff_idct_xvid_mmx_put;
 +                    c->idct_add              = ff_idct_xvid_mmx_add;
 +                    c->idct                  = ff_idct_xvid_mmx;
 +                }
 +            }
 +        }
 +#endif /* HAVE_INLINE_ASM */
 +
          dsputil_init_mmx(c, avctx, mm_flags);
 +    }
  
      if (mm_flags & AV_CPU_FLAG_MMXEXT)
          dsputil_init_mmxext(c, avctx, mm_flags);