Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 8 Sep 2012 10:53:44 +0000 (12:53 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 8 Sep 2012 10:53:44 +0000 (12:53 +0200)
* qatar/master:
  mov_chan: Only set the channel_layout if setting it to a nonzero value
  mov_chan: Reindent an incorrectly indented line
  mp2 muxer: mark as AVFMT_NOTIMESTAMPS.
  x86: float_dsp: fix ff_vector_fmac_scalar_avx() on Win64
  x86: more specific checks for availability of required assembly capabilities
  x86: avcodec: Drop silly "_mmx" suffix from dsputil template names
  fate: Drop redundant setting of FUZZ to 1
  cavsdsp: set idct permutation independently of dsputil
  x86: allow using add_hfyu_median_prediction_cmov on any cpu with cmov

Conflicts:
libavcodec/x86/dsputil_mmx.c
libavformat/mp3enc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
16 files changed:
1  2 
libavcodec/cavsdec.c
libavcodec/cavsdsp.c
libavcodec/cavsdsp.h
libavcodec/x86/cavsdsp.c
libavcodec/x86/dnxhdenc.c
libavcodec/x86/dsputil_avg_template.c
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/dsputil_qns_template.c
libavcodec/x86/dsputil_rnd_template.c
libavcodec/x86/dsputilenc_mmx.c
libavcodec/x86/lpc.c
libavcodec/x86/mpegaudiodec.c
libavformat/mov_chan.c
libavutil/x86/float_dsp.asm
libswscale/swscale.c
tests/fate/mpc.mak

Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 0000000,8b116b7..6f76859
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,977 +1,977 @@@
 - * This file is part of Libav.
+ /*
+  * DSP utils : average functions are compiled twice for 3dnow/mmx2
+  * Copyright (c) 2000, 2001 Fabrice Bellard
+  * Copyright (c) 2002-2004 Michael Niedermayer
+  *
+  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
+  * mostly rewritten by Michael Niedermayer <michaelni@gmx.at>
+  * and improved by Zdenek Kabelac <kabi@users.sf.net>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ /* XXX: we use explicit registers to avoid a gcc 2.95.2 register asm
+    clobber bug - now it will work with 2.95.2 and also with -fPIC
+  */
+ static void DEF(put_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "1:                             \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+         PAVGB" 1(%1, %3), %%mm1         \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+         PAVGB" 1(%1, %3), %%mm1         \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ static void DEF(put_pixels4_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movd   (%1), %%mm0             \n\t"
+         "movd   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $4, %2                  \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         "movd   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movd   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movd   (%1), %%mm1             \n\t"
+         "movd   (%2), %%mm2             \n\t"
+         "movd   4(%2), %%mm3            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "movd   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movd   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movd   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movd   (%1), %%mm1             \n\t"
+         "movd   8(%2), %%mm2            \n\t"
+         "movd   12(%2), %%mm3           \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "movd   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movd   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $16, %2                 \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ }
+ static void DEF(put_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $8, %2                  \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 8(%2), %%mm1             \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" 16(%2), %%mm0            \n\t"
+         PAVGB" 24(%2), %%mm1            \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ //the following should be used, though better not with gcc ...
+ /*        :"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+         :"r"(src1Stride), "r"(dstStride)
+         :"memory");*/
+ }
+ static void DEF(put_no_rnd_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "pcmpeqb %%mm6, %%mm6           \n\t"
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $8, %2                  \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%2), %%mm2             \n\t"
+         "movq   8(%2), %%mm3            \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "pxor %%mm6, %%mm2              \n\t"
+         "pxor %%mm6, %%mm3              \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   16(%2), %%mm2           \n\t"
+         "movq   24(%2), %%mm3           \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "pxor %%mm6, %%mm2              \n\t"
+         "pxor %%mm6, %%mm3              \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ //the following should be used, though better not with gcc ...
+ /*        :"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+         :"r"(src1Stride), "r"(dstStride)
+         :"memory");*/
+ }
+ static void DEF(avg_pixels4_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movd   (%1), %%mm0             \n\t"
+         "movd   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $4, %2                  \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         "movd   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movd   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movd   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 4(%2), %%mm1             \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         "movd   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         PAVGB" (%3), %%mm1              \n\t"
+         "movd   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movd   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movd   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" 8(%2), %%mm0             \n\t"
+         PAVGB" 12(%2), %%mm1            \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         "movd   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         PAVGB" (%3), %%mm1              \n\t"
+         "movd   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $16, %2                 \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ }
+ static void DEF(avg_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $8, %2                  \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 8(%2), %%mm1             \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         PAVGB" (%3), %%mm1              \n\t"
+         "movq   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" 16(%2), %%mm0            \n\t"
+         PAVGB" 24(%2), %%mm1            \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         PAVGB" (%3), %%mm1              \n\t"
+         "movq   %%mm1, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE  //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ //the following should be used, though better not with gcc ...
+ /*        :"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+         :"r"(src1Stride), "r"(dstStride)
+         :"memory");*/
+ }
+ static void DEF(put_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "1:                             \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq 8(%1), %%mm2              \n\t"
+         "movq 8(%1, %3), %%mm3          \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+         PAVGB" 1(%1, %3), %%mm1         \n\t"
+         PAVGB" 9(%1), %%mm2             \n\t"
+         PAVGB" 9(%1, %3), %%mm3         \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "movq %%mm2, 8(%2)              \n\t"
+         "movq %%mm3, 8(%2, %3)          \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq 8(%1), %%mm2              \n\t"
+         "movq 8(%1, %3), %%mm3          \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+         PAVGB" 1(%1, %3), %%mm1         \n\t"
+         PAVGB" 9(%1), %%mm2             \n\t"
+         PAVGB" 9(%1, %3), %%mm3         \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "movq %%mm2, 8(%2)              \n\t"
+         "movq %%mm3, 8(%2, %3)          \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ static void DEF(put_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 8(%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $16, %2                 \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 8(%2), %%mm1             \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" 16(%2), %%mm0            \n\t"
+         PAVGB" 24(%2), %%mm1            \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $2, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE  //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ //the following should be used, though better not with gcc ...
+ /*        :"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+         :"r"(src1Stride), "r"(dstStride)
+         :"memory");*/
+ }
+ static void DEF(avg_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 8(%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $16, %2                 \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         PAVGB" 8(%3), %%mm1             \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" 8(%2), %%mm1             \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         PAVGB" 8(%3), %%mm1             \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGB" 16(%2), %%mm0            \n\t"
+         PAVGB" 24(%2), %%mm1            \n\t"
+         PAVGB" (%3), %%mm0              \n\t"
+         PAVGB" 8(%3), %%mm1             \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $2, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE  //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ //the following should be used, though better not with gcc ...
+ /*        :"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+         :"r"(src1Stride), "r"(dstStride)
+         :"memory");*/
+ }
+ static void DEF(put_no_rnd_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     __asm__ volatile(
+         "pcmpeqb %%mm6, %%mm6           \n\t"
+         "testl $1, %0                   \n\t"
+             " jz 1f                     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "movq   (%2), %%mm2             \n\t"
+         "movq   8(%2), %%mm3            \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "pxor %%mm6, %%mm2              \n\t"
+         "pxor %%mm6, %%mm3              \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $16, %2                 \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%2), %%mm2             \n\t"
+         "movq   8(%2), %%mm3            \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "pxor %%mm6, %%mm2              \n\t"
+         "pxor %%mm6, %%mm3              \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   8(%1), %%mm1            \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   16(%2), %%mm2           \n\t"
+         "movq   24(%2), %%mm3           \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "pxor %%mm6, %%mm2              \n\t"
+         "pxor %%mm6, %%mm3              \n\t"
+         PAVGB" %%mm2, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm1             \n\t"
+         "pxor %%mm6, %%mm0              \n\t"
+         "pxor %%mm6, %%mm1              \n\t"
+         "movq   %%mm0, (%3)             \n\t"
+         "movq   %%mm1, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $2, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ //the following should be used, though better not with gcc ...
+ /*        :"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+         :"r"(src1Stride), "r"(dstStride)
+         :"memory");*/
+ }
+ /* GL: this function does incorrect rounding if overflow */
+ static void DEF(put_no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BONE(mm6);
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "1:                             \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm2           \n\t"
+         "movq 1(%1), %%mm1              \n\t"
+         "movq 1(%1, %3), %%mm3          \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "psubusb %%mm6, %%mm0           \n\t"
+         "psubusb %%mm6, %%mm2           \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm2             \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq 1(%1), %%mm1              \n\t"
+         "movq (%1, %3), %%mm2           \n\t"
+         "movq 1(%1, %3), %%mm3          \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "psubusb %%mm6, %%mm0           \n\t"
+         "psubusb %%mm6, %%mm2           \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm2             \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ static void DEF(put_no_rnd_pixels8_x2_exact)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile (
+         "pcmpeqb %%mm6, %%mm6           \n\t"
+         "1:                             \n\t"
+         "movq  (%1),     %%mm0          \n\t"
+         "movq  (%1, %3), %%mm2          \n\t"
+         "movq 1(%1),     %%mm1          \n\t"
+         "movq 1(%1, %3), %%mm3          \n\t"
+         "pxor  %%mm6, %%mm0             \n\t"
+         "pxor  %%mm6, %%mm2             \n\t"
+         "pxor  %%mm6, %%mm1             \n\t"
+         "pxor  %%mm6, %%mm3             \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm2             \n\t"
+         "pxor  %%mm6, %%mm0             \n\t"
+         "pxor  %%mm6, %%mm2             \n\t"
+         "movq  %%mm0, (%2)              \n\t"
+         "movq  %%mm2, (%2, %3)          \n\t"
+         "movq  (%1, %3,2), %%mm0        \n\t"
+         "movq 1(%1, %3,2), %%mm1        \n\t"
+         "movq  (%1, %4),   %%mm2        \n\t"
+         "movq 1(%1, %4),   %%mm3        \n\t"
+         "pxor  %%mm6, %%mm0             \n\t"
+         "pxor  %%mm6, %%mm1             \n\t"
+         "pxor  %%mm6, %%mm2             \n\t"
+         "pxor  %%mm6, %%mm3             \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm3, %%mm2             \n\t"
+         "pxor  %%mm6, %%mm0             \n\t"
+         "pxor  %%mm6, %%mm2             \n\t"
+         "movq  %%mm0, (%2, %3,2)        \n\t"
+         "movq  %%mm2, (%2, %4)          \n\t"
+         "lea   (%1, %3,4), %1           \n\t"
+         "lea   (%2, %3,4), %2           \n\t"
+         "subl  $4, %0                   \n\t"
+         "jg 1b                          \n\t"
+         : "+g"(h), "+r"(pixels), "+r"(block)
+         : "r" ((x86_reg)line_size), "r"((x86_reg)3*line_size)
+         : "memory"
+     );
+ }
+ static void DEF(put_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "sub %3, %2                     \n\t"
+         "1:                             \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm2    \n\t"
+         "add %%"REG_a", %1              \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm2, %%mm1             \n\t"
+         "movq %%mm0, (%2, %3)           \n\t"
+         "movq %%mm1, (%2, %%"REG_a")    \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm0    \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "add %%"REG_a", %1              \n\t"
+         PAVGB" %%mm1, %%mm2             \n\t"
+         PAVGB" %%mm0, %%mm1             \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "movq %%mm1, (%2, %%"REG_a")    \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D" (block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ /* GL: this function does incorrect rounding if overflow */
+ static void DEF(put_no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BONE(mm6);
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "sub %3, %2                     \n\t"
+         "1:                             \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm2    \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "psubusb %%mm6, %%mm1           \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm2, %%mm1             \n\t"
+         "movq %%mm0, (%2, %3)           \n\t"
+         "movq %%mm1, (%2, %%"REG_a")    \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm0    \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "psubusb %%mm6, %%mm1           \n\t"
+         PAVGB" %%mm1, %%mm2             \n\t"
+         PAVGB" %%mm0, %%mm1             \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "movq %%mm1, (%2, %%"REG_a")    \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D" (block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ static void DEF(put_no_rnd_pixels8_y2_exact)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile (
+         "movq     (%1), %%mm0           \n\t"
+         "pcmpeqb %%mm6, %%mm6           \n\t"
+         "add        %3, %1              \n\t"
+         "pxor    %%mm6, %%mm0           \n\t"
+         "1:                             \n\t"
+         "movq  (%1),     %%mm1          \n\t"
+         "movq  (%1, %3), %%mm2          \n\t"
+         "pxor  %%mm6, %%mm1             \n\t"
+         "pxor  %%mm6, %%mm2             \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm2, %%mm1             \n\t"
+         "pxor  %%mm6, %%mm0             \n\t"
+         "pxor  %%mm6, %%mm1             \n\t"
+         "movq  %%mm0, (%2)              \n\t"
+         "movq  %%mm1, (%2, %3)          \n\t"
+         "movq  (%1, %3,2), %%mm1        \n\t"
+         "movq  (%1, %4),   %%mm0        \n\t"
+         "pxor  %%mm6, %%mm1             \n\t"
+         "pxor  %%mm6, %%mm0             \n\t"
+         PAVGB" %%mm1, %%mm2             \n\t"
+         PAVGB" %%mm0, %%mm1             \n\t"
+         "pxor  %%mm6, %%mm2             \n\t"
+         "pxor  %%mm6, %%mm1             \n\t"
+         "movq %%mm2, (%2, %3,2)         \n\t"
+         "movq %%mm1, (%2, %4)           \n\t"
+         "lea   (%1, %3,4), %1           \n\t"
+         "lea   (%2, %3,4), %2           \n\t"
+         "subl $4, %0                    \n\t"
+         "jg 1b                          \n\t"
+         :"+g"(h), "+r"(pixels), "+r" (block)
+         :"r" ((x86_reg)line_size), "r"((x86_reg)3*line_size)
+         :"memory"
+     );
+ }
+ static void DEF(avg_pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "1:                             \n\t"
+         "movq (%2), %%mm0               \n\t"
+         "movq (%2, %3), %%mm1           \n\t"
+         PAVGB" (%1), %%mm0              \n\t"
+         PAVGB" (%1, %3), %%mm1          \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "movq (%2), %%mm0               \n\t"
+         "movq (%2, %3), %%mm1           \n\t"
+         PAVGB" (%1), %%mm0              \n\t"
+         PAVGB" (%1, %3), %%mm1          \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ static void DEF(avg_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "1:                             \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm2           \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+         PAVGB" 1(%1, %3), %%mm2         \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" (%2, %3), %%mm2          \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "movq (%1, %3), %%mm2           \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+         PAVGB" 1(%1, %3), %%mm2         \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "add %%"REG_a", %1              \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" (%2, %3), %%mm2          \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ static void DEF(avg_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "movq (%1), %%mm0               \n\t"
+         "sub %3, %2                     \n\t"
+         "1:                             \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm2    \n\t"
+         "add %%"REG_a", %1              \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm2, %%mm1             \n\t"
+         "movq (%2, %3), %%mm3           \n\t"
+         "movq (%2, %%"REG_a"), %%mm4    \n\t"
+         PAVGB" %%mm3, %%mm0             \n\t"
+         PAVGB" %%mm4, %%mm1             \n\t"
+         "movq %%mm0, (%2, %3)           \n\t"
+         "movq %%mm1, (%2, %%"REG_a")    \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm0    \n\t"
+         PAVGB" %%mm1, %%mm2             \n\t"
+         PAVGB" %%mm0, %%mm1             \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "add %%"REG_a", %1              \n\t"
+         "movq (%2, %3), %%mm3           \n\t"
+         "movq (%2, %%"REG_a"), %%mm4    \n\t"
+         PAVGB" %%mm3, %%mm2             \n\t"
+         PAVGB" %%mm4, %%mm1             \n\t"
+         "movq %%mm2, (%2, %3)           \n\t"
+         "movq %%mm1, (%2, %%"REG_a")    \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a, "memory");
+ }
+ /* Note this is not correctly rounded, but this function is only
+  * used for B-frames so it does not matter. */
+ static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BONE(mm6);
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "movq (%1), %%mm0               \n\t"
+         PAVGB" 1(%1), %%mm0             \n\t"
+          ".p2align 3                    \n\t"
+         "1:                             \n\t"
+         "movq (%1, %%"REG_a"), %%mm2    \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "psubusb %%mm6, %%mm2           \n\t"
+         PAVGB" 1(%1, %3), %%mm1         \n\t"
+         PAVGB" 1(%1, %%"REG_a"), %%mm2  \n\t"
+         "add %%"REG_a", %1              \n\t"
+         PAVGB" %%mm1, %%mm0             \n\t"
+         PAVGB" %%mm2, %%mm1             \n\t"
+         PAVGB" (%2), %%mm0              \n\t"
+         PAVGB" (%2, %3), %%mm1          \n\t"
+         "movq %%mm0, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "movq (%1, %3), %%mm1           \n\t"
+         "movq (%1, %%"REG_a"), %%mm0    \n\t"
+         PAVGB" 1(%1, %3), %%mm1         \n\t"
+         PAVGB" 1(%1, %%"REG_a"), %%mm0  \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "add %%"REG_a", %1              \n\t"
+         PAVGB" %%mm1, %%mm2             \n\t"
+         PAVGB" %%mm0, %%mm1             \n\t"
+         PAVGB" (%2), %%mm2              \n\t"
+         PAVGB" (%2, %3), %%mm1          \n\t"
+         "movq %%mm2, (%2)               \n\t"
+         "movq %%mm1, (%2, %3)           \n\t"
+         "add %%"REG_a", %2              \n\t"
+         "subl $4, %0                    \n\t"
+         "jnz 1b                         \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r" ((x86_reg)line_size)
+         :"%"REG_a,  "memory");
+ }
+ static void DEF(avg_pixels4)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     do {
+         __asm__ volatile(
+             "movd (%1), %%mm0               \n\t"
+             "movd (%1, %2), %%mm1           \n\t"
+             "movd (%1, %2, 2), %%mm2        \n\t"
+             "movd (%1, %3), %%mm3           \n\t"
+             PAVGB" (%0), %%mm0              \n\t"
+             PAVGB" (%0, %2), %%mm1          \n\t"
+             PAVGB" (%0, %2, 2), %%mm2       \n\t"
+             PAVGB" (%0, %3), %%mm3          \n\t"
+             "movd %%mm0, (%1)               \n\t"
+             "movd %%mm1, (%1, %2)           \n\t"
+             "movd %%mm2, (%1, %2, 2)        \n\t"
+             "movd %%mm3, (%1, %3)           \n\t"
+             ::"S"(pixels), "D"(block),
+              "r" ((x86_reg)line_size), "r"((x86_reg)3L*line_size)
+             :"memory");
+         block += 4*line_size;
+         pixels += 4*line_size;
+         h -= 4;
+     } while(h > 0);
+ }
+ //FIXME the following could be optimized too ...
+ static void DEF(put_no_rnd_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(put_no_rnd_pixels8_x2)(block  , pixels  , line_size, h);
+     DEF(put_no_rnd_pixels8_x2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(put_pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(put_pixels8_y2)(block  , pixels  , line_size, h);
+     DEF(put_pixels8_y2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(put_no_rnd_pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(put_no_rnd_pixels8_y2)(block  , pixels  , line_size, h);
+     DEF(put_no_rnd_pixels8_y2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(avg_pixels16)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(avg_pixels8)(block  , pixels  , line_size, h);
+     DEF(avg_pixels8)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(avg_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(avg_pixels8_x2)(block  , pixels  , line_size, h);
+     DEF(avg_pixels8_x2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(avg_pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(avg_pixels8_y2)(block  , pixels  , line_size, h);
+     DEF(avg_pixels8_y2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(avg_pixels16_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(avg_pixels8_xy2)(block  , pixels  , line_size, h);
+     DEF(avg_pixels8_xy2)(block+8, pixels+8, line_size, h);
+ }
+ #define QPEL_2TAP_L3(OPNAME) \
+ static void DEF(OPNAME ## 2tap_qpel16_l3)(uint8_t *dst, uint8_t *src, int stride, int h, int off1, int off2){\
+     __asm__ volatile(\
+         "1:                    \n\t"\
+         "movq   (%1,%2), %%mm0 \n\t"\
+         "movq  8(%1,%2), %%mm1 \n\t"\
+         PAVGB"  (%1,%3), %%mm0 \n\t"\
+         PAVGB" 8(%1,%3), %%mm1 \n\t"\
+         PAVGB"  (%1),    %%mm0 \n\t"\
+         PAVGB" 8(%1),    %%mm1 \n\t"\
+         STORE_OP( (%1,%4),%%mm0)\
+         STORE_OP(8(%1,%4),%%mm1)\
+         "movq  %%mm0,  (%1,%4) \n\t"\
+         "movq  %%mm1, 8(%1,%4) \n\t"\
+         "add   %5, %1          \n\t"\
+         "decl  %0              \n\t"\
+         "jnz   1b              \n\t"\
+         :"+g"(h), "+r"(src)\
+         :"r"((x86_reg)off1), "r"((x86_reg)off2),\
+          "r"((x86_reg)(dst-src)), "r"((x86_reg)stride)\
+         :"memory"\
+     );\
+ }\
+ static void DEF(OPNAME ## 2tap_qpel8_l3)(uint8_t *dst, uint8_t *src, int stride, int h, int off1, int off2){\
+     __asm__ volatile(\
+         "1:                    \n\t"\
+         "movq   (%1,%2), %%mm0 \n\t"\
+         PAVGB"  (%1,%3), %%mm0 \n\t"\
+         PAVGB"  (%1),    %%mm0 \n\t"\
+         STORE_OP((%1,%4),%%mm0)\
+         "movq  %%mm0,  (%1,%4) \n\t"\
+         "add   %5, %1          \n\t"\
+         "decl  %0              \n\t"\
+         "jnz   1b              \n\t"\
+         :"+g"(h), "+r"(src)\
+         :"r"((x86_reg)off1), "r"((x86_reg)off2),\
+          "r"((x86_reg)(dst-src)), "r"((x86_reg)stride)\
+         :"memory"\
+     );\
+ }
+ #define STORE_OP(a,b) PAVGB" "#a","#b" \n\t"
+ QPEL_2TAP_L3(avg_)
+ #undef STORE_OP
+ #define STORE_OP(a,b)
+ QPEL_2TAP_L3(put_)
+ #undef STORE_OP
+ #undef QPEL_2TAP_L3
@@@ -3149,21 -3021,6 +3151,19 @@@ void ff_dsputil_init_mmx(DSPContext *c
                  c->idct_add              = ff_simple_idct_add_mmx;
                  c->idct                  = ff_simple_idct_mmx;
                  c->idct_permutation_type = FF_SIMPLE_IDCT_PERM;
-             } else if (idct_algo == FF_IDCT_CAVS) {
-                     c->idct_permutation_type = FF_TRANSPOSE_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;
index 0000000,20a40a1..77a41b9
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,101 +1,101 @@@
 - * This file is part of Libav.
+ /*
+  * DSP utils : QNS functions are compiled 3 times for mmx/3dnow/ssse3
+  * Copyright (c) 2004 Michael Niedermayer
+  *
+  * MMX optimization by Michael Niedermayer <michaelni@gmx.at>
+  * 3DNow! and SSSE3 optimization by Zuxy Meng <zuxy.meng@gmail.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #define MAX_ABS (512 >> (SCALE_OFFSET>0 ? SCALE_OFFSET : 0))
+ static int DEF(try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale)
+ {
+     x86_reg i=0;
+     assert(FFABS(scale) < MAX_ABS);
+     scale<<= 16 + SCALE_OFFSET - BASIS_SHIFT + RECON_SHIFT;
+     SET_RND(mm6);
+     __asm__ volatile(
+         "pxor %%mm7, %%mm7              \n\t"
+         "movd  %4, %%mm5                \n\t"
+         "punpcklwd %%mm5, %%mm5         \n\t"
+         "punpcklwd %%mm5, %%mm5         \n\t"
+         ".p2align 4                     \n\t"
+         "1:                             \n\t"
+         "movq  (%1, %0), %%mm0          \n\t"
+         "movq  8(%1, %0), %%mm1         \n\t"
+         PMULHRW(%%mm0, %%mm1, %%mm5, %%mm6)
+         "paddw (%2, %0), %%mm0          \n\t"
+         "paddw 8(%2, %0), %%mm1         \n\t"
+         "psraw $6, %%mm0                \n\t"
+         "psraw $6, %%mm1                \n\t"
+         "pmullw (%3, %0), %%mm0         \n\t"
+         "pmullw 8(%3, %0), %%mm1        \n\t"
+         "pmaddwd %%mm0, %%mm0           \n\t"
+         "pmaddwd %%mm1, %%mm1           \n\t"
+         "paddd %%mm1, %%mm0             \n\t"
+         "psrld $4, %%mm0                \n\t"
+         "paddd %%mm0, %%mm7             \n\t"
+         "add $16, %0                    \n\t"
+         "cmp $128, %0                   \n\t" //FIXME optimize & bench
+         " jb 1b                         \n\t"
+         PHADDD(%%mm7, %%mm6)
+         "psrld $2, %%mm7                \n\t"
+         "movd %%mm7, %0                 \n\t"
+         : "+r" (i)
+         : "r"(basis), "r"(rem), "r"(weight), "g"(scale)
+     );
+     return i;
+ }
+ static void DEF(add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale)
+ {
+     x86_reg i=0;
+     if(FFABS(scale) < MAX_ABS){
+         scale<<= 16 + SCALE_OFFSET - BASIS_SHIFT + RECON_SHIFT;
+         SET_RND(mm6);
+         __asm__ volatile(
+                 "movd  %3, %%mm5        \n\t"
+                 "punpcklwd %%mm5, %%mm5 \n\t"
+                 "punpcklwd %%mm5, %%mm5 \n\t"
+                 ".p2align 4             \n\t"
+                 "1:                     \n\t"
+                 "movq  (%1, %0), %%mm0  \n\t"
+                 "movq  8(%1, %0), %%mm1 \n\t"
+                 PMULHRW(%%mm0, %%mm1, %%mm5, %%mm6)
+                 "paddw (%2, %0), %%mm0  \n\t"
+                 "paddw 8(%2, %0), %%mm1 \n\t"
+                 "movq %%mm0, (%2, %0)   \n\t"
+                 "movq %%mm1, 8(%2, %0)  \n\t"
+                 "add $16, %0            \n\t"
+                 "cmp $128, %0           \n\t" // FIXME optimize & bench
+                 " jb 1b                 \n\t"
+                 : "+r" (i)
+                 : "r"(basis), "r"(rem), "g"(scale)
+         );
+     }else{
+         for(i=0; i<8*8; i++){
+             rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
+         }
+     }
+ }
index 0000000,34a2c0b..e4c9138
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,590 +1,590 @@@
 - * This file is part of Libav.
+ /*
+  * DSP utils mmx functions are compiled twice for rnd/no_rnd
+  * Copyright (c) 2000, 2001 Fabrice Bellard
+  * Copyright (c) 2003-2004 Michael Niedermayer <michaelni@gmx.at>
+  *
+  * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
+  * mostly rewritten by Michael Niedermayer <michaelni@gmx.at>
+  * and improved by Zdenek Kabelac <kabi@users.sf.net>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ // put_pixels
+ static void DEF(put, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     __asm__ volatile(
+         "lea    (%3, %3), %%"REG_a"     \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   1(%1), %%mm1            \n\t"
+         "movq   (%1, %3), %%mm2         \n\t"
+         "movq   1(%1, %3), %%mm3        \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%2)             \n\t"
+         "movq   %%mm5, (%2, %3)         \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   1(%1), %%mm1            \n\t"
+         "movq   (%1, %3), %%mm2         \n\t"
+         "movq   1(%1, %3), %%mm3        \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%2)             \n\t"
+         "movq   %%mm5, (%2, %3)         \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r"((x86_reg)line_size)
+         :REG_a, "memory");
+ }
+ static void av_unused DEF(put, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     MOVQ_BFE(mm6);
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+         " jz 1f                         \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $8, %2                  \n\t"
+         PAVGB(%%mm0, %%mm1, %%mm4, %%mm6)
+         "movq   %%mm4, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm2             \n\t"
+         "movq   8(%2), %%mm3            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   %%mm5, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   16(%2), %%mm1           \n\t"
+         "add    %4, %1                  \n\t"
+         "movq   (%1), %%mm2             \n\t"
+         "movq   24(%2), %%mm3           \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $32, %2                 \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   %%mm5, (%3)             \n\t"
+         "add    %5, %3                  \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ }
+ static void DEF(put, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     __asm__ volatile(
+         "lea        (%3, %3), %%"REG_a" \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   1(%1), %%mm1            \n\t"
+         "movq   (%1, %3), %%mm2         \n\t"
+         "movq   1(%1, %3), %%mm3        \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%2)             \n\t"
+         "movq   %%mm5, (%2, %3)         \n\t"
+         "movq   8(%1), %%mm0            \n\t"
+         "movq   9(%1), %%mm1            \n\t"
+         "movq   8(%1, %3), %%mm2        \n\t"
+         "movq   9(%1, %3), %%mm3        \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, 8(%2)            \n\t"
+         "movq   %%mm5, 8(%2, %3)        \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   1(%1), %%mm1            \n\t"
+         "movq   (%1, %3), %%mm2         \n\t"
+         "movq   1(%1, %3), %%mm3        \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%2)             \n\t"
+         "movq   %%mm5, (%2, %3)         \n\t"
+         "movq   8(%1), %%mm0            \n\t"
+         "movq   9(%1), %%mm1            \n\t"
+         "movq   8(%1, %3), %%mm2        \n\t"
+         "movq   9(%1, %3), %%mm3        \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, 8(%2)            \n\t"
+         "movq   %%mm5, 8(%2, %3)        \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r"((x86_reg)line_size)
+         :REG_a, "memory");
+ }
+ static void av_unused DEF(put, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     MOVQ_BFE(mm6);
+     __asm__ volatile(
+         "testl $1, %0                   \n\t"
+         " jz 1f                         \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "movq   8(%1), %%mm2            \n\t"
+         "movq   8(%2), %%mm3            \n\t"
+         "add    %4, %1                  \n\t"
+         "add    $16, %2                 \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%3)             \n\t"
+         "movq   %%mm5, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "decl   %0                      \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   (%2), %%mm1             \n\t"
+         "movq   8(%1), %%mm2            \n\t"
+         "movq   8(%2), %%mm3            \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%3)             \n\t"
+         "movq   %%mm5, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         "movq   16(%2), %%mm1           \n\t"
+         "movq   8(%1), %%mm2            \n\t"
+         "movq   24(%2), %%mm3           \n\t"
+         "add    %4, %1                  \n\t"
+         PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
+         "movq   %%mm4, (%3)             \n\t"
+         "movq   %%mm5, 8(%3)            \n\t"
+         "add    %5, %3                  \n\t"
+         "add    $32, %2                 \n\t"
+         "subl   $2, %0                  \n\t"
+         "jnz    1b                      \n\t"
+ #if !HAVE_EBX_AVAILABLE  //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cannot be used
+         :"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #else
+         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+ #endif
+         :"S"((x86_reg)src1Stride), "D"((x86_reg)dstStride)
+         :"memory");
+ }
+ static void DEF(put, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     __asm__ volatile(
+         "lea (%3, %3), %%"REG_a"        \n\t"
+         "movq (%1), %%mm0               \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1, %3), %%mm1         \n\t"
+         "movq   (%1, %%"REG_a"),%%mm2   \n\t"
+         PAVGBP(%%mm1, %%mm0, %%mm4,   %%mm2, %%mm1, %%mm5)
+         "movq   %%mm4, (%2)             \n\t"
+         "movq   %%mm5, (%2, %3)         \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "movq   (%1, %3), %%mm1         \n\t"
+         "movq   (%1, %%"REG_a"),%%mm0   \n\t"
+         PAVGBP(%%mm1, %%mm2, %%mm4,   %%mm0, %%mm1, %%mm5)
+         "movq   %%mm4, (%2)             \n\t"
+         "movq   %%mm5, (%2, %3)         \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r"((x86_reg)line_size)
+         :REG_a, "memory");
+ }
+ static void DEF(put, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_ZERO(mm7);
+     SET_RND(mm6); // =2 for rnd  and  =1 for no_rnd version
+     __asm__ volatile(
+         "movq   (%1), %%mm0             \n\t"
+         "movq   1(%1), %%mm4            \n\t"
+         "movq   %%mm0, %%mm1            \n\t"
+         "movq   %%mm4, %%mm5            \n\t"
+         "punpcklbw %%mm7, %%mm0         \n\t"
+         "punpcklbw %%mm7, %%mm4         \n\t"
+         "punpckhbw %%mm7, %%mm1         \n\t"
+         "punpckhbw %%mm7, %%mm5         \n\t"
+         "paddusw %%mm0, %%mm4           \n\t"
+         "paddusw %%mm1, %%mm5           \n\t"
+         "xor    %%"REG_a", %%"REG_a"    \n\t"
+         "add    %3, %1                  \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1, %%"REG_a"), %%mm0  \n\t"
+         "movq   1(%1, %%"REG_a"), %%mm2 \n\t"
+         "movq   %%mm0, %%mm1            \n\t"
+         "movq   %%mm2, %%mm3            \n\t"
+         "punpcklbw %%mm7, %%mm0         \n\t"
+         "punpcklbw %%mm7, %%mm2         \n\t"
+         "punpckhbw %%mm7, %%mm1         \n\t"
+         "punpckhbw %%mm7, %%mm3         \n\t"
+         "paddusw %%mm2, %%mm0           \n\t"
+         "paddusw %%mm3, %%mm1           \n\t"
+         "paddusw %%mm6, %%mm4           \n\t"
+         "paddusw %%mm6, %%mm5           \n\t"
+         "paddusw %%mm0, %%mm4           \n\t"
+         "paddusw %%mm1, %%mm5           \n\t"
+         "psrlw  $2, %%mm4               \n\t"
+         "psrlw  $2, %%mm5               \n\t"
+         "packuswb  %%mm5, %%mm4         \n\t"
+         "movq   %%mm4, (%2, %%"REG_a")  \n\t"
+         "add    %3, %%"REG_a"           \n\t"
+         "movq   (%1, %%"REG_a"), %%mm2  \n\t" // 0 <-> 2   1 <-> 3
+         "movq   1(%1, %%"REG_a"), %%mm4 \n\t"
+         "movq   %%mm2, %%mm3            \n\t"
+         "movq   %%mm4, %%mm5            \n\t"
+         "punpcklbw %%mm7, %%mm2         \n\t"
+         "punpcklbw %%mm7, %%mm4         \n\t"
+         "punpckhbw %%mm7, %%mm3         \n\t"
+         "punpckhbw %%mm7, %%mm5         \n\t"
+         "paddusw %%mm2, %%mm4           \n\t"
+         "paddusw %%mm3, %%mm5           \n\t"
+         "paddusw %%mm6, %%mm0           \n\t"
+         "paddusw %%mm6, %%mm1           \n\t"
+         "paddusw %%mm4, %%mm0           \n\t"
+         "paddusw %%mm5, %%mm1           \n\t"
+         "psrlw  $2, %%mm0               \n\t"
+         "psrlw  $2, %%mm1               \n\t"
+         "packuswb  %%mm1, %%mm0         \n\t"
+         "movq   %%mm0, (%2, %%"REG_a")  \n\t"
+         "add    %3, %%"REG_a"           \n\t"
+         "subl   $2, %0                  \n\t"
+         "jnz    1b                      \n\t"
+         :"+g"(h), "+S"(pixels)
+         :"D"(block), "r"((x86_reg)line_size)
+         :REG_a, "memory");
+ }
+ // avg_pixels
+ static void av_unused DEF(avg, pixels4)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+              "movd  %0, %%mm0           \n\t"
+              "movd  %1, %%mm1           \n\t"
+              OP_AVG(%%mm0, %%mm1, %%mm2, %%mm6)
+              "movd  %%mm2, %0           \n\t"
+              :"+m"(*block)
+              :"m"(*pixels)
+              :"memory");
+         pixels += line_size;
+         block += line_size;
+     }
+     while (--h);
+ }
+ // in case more speed is needed - unroling would certainly help
+ static void DEF(avg, pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+              "movq  %0, %%mm0           \n\t"
+              "movq  %1, %%mm1           \n\t"
+              OP_AVG(%%mm0, %%mm1, %%mm2, %%mm6)
+              "movq  %%mm2, %0           \n\t"
+              :"+m"(*block)
+              :"m"(*pixels)
+              :"memory");
+         pixels += line_size;
+         block += line_size;
+     }
+     while (--h);
+ }
+ static void DEF(avg, pixels16)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+              "movq  %0, %%mm0           \n\t"
+              "movq  %1, %%mm1           \n\t"
+              OP_AVG(%%mm0, %%mm1, %%mm2, %%mm6)
+              "movq  %%mm2, %0           \n\t"
+              "movq  8%0, %%mm0          \n\t"
+              "movq  8%1, %%mm1          \n\t"
+              OP_AVG(%%mm0, %%mm1, %%mm2, %%mm6)
+              "movq  %%mm2, 8%0          \n\t"
+              :"+m"(*block)
+              :"m"(*pixels)
+              :"memory");
+         pixels += line_size;
+         block += line_size;
+     }
+     while (--h);
+ }
+ static void DEF(avg, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+             "movq  %1, %%mm0            \n\t"
+             "movq  1%1, %%mm1           \n\t"
+             "movq  %0, %%mm3            \n\t"
+             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
+             OP_AVG(%%mm3, %%mm2, %%mm0, %%mm6)
+             "movq  %%mm0, %0            \n\t"
+             :"+m"(*block)
+             :"m"(*pixels)
+             :"memory");
+         pixels += line_size;
+         block += line_size;
+     } while (--h);
+ }
+ static av_unused void DEF(avg, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+             "movq  %1, %%mm0            \n\t"
+             "movq  %2, %%mm1            \n\t"
+             "movq  %0, %%mm3            \n\t"
+             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
+             OP_AVG(%%mm3, %%mm2, %%mm0, %%mm6)
+             "movq  %%mm0, %0            \n\t"
+             :"+m"(*dst)
+             :"m"(*src1), "m"(*src2)
+             :"memory");
+         dst += dstStride;
+         src1 += src1Stride;
+         src2 += 8;
+     } while (--h);
+ }
+ static void DEF(avg, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+             "movq  %1, %%mm0            \n\t"
+             "movq  1%1, %%mm1           \n\t"
+             "movq  %0, %%mm3            \n\t"
+             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
+             OP_AVG(%%mm3, %%mm2, %%mm0, %%mm6)
+             "movq  %%mm0, %0            \n\t"
+             "movq  8%1, %%mm0           \n\t"
+             "movq  9%1, %%mm1           \n\t"
+             "movq  8%0, %%mm3           \n\t"
+             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
+             OP_AVG(%%mm3, %%mm2, %%mm0, %%mm6)
+             "movq  %%mm0, 8%0           \n\t"
+             :"+m"(*block)
+             :"m"(*pixels)
+             :"memory");
+         pixels += line_size;
+         block += line_size;
+     } while (--h);
+ }
+ static av_unused void DEF(avg, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+ {
+     MOVQ_BFE(mm6);
+     JUMPALIGN();
+     do {
+         __asm__ volatile(
+             "movq  %1, %%mm0            \n\t"
+             "movq  %2, %%mm1            \n\t"
+             "movq  %0, %%mm3            \n\t"
+             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
+             OP_AVG(%%mm3, %%mm2, %%mm0, %%mm6)
+             "movq  %%mm0, %0            \n\t"
+             "movq  8%1, %%mm0           \n\t"
+             "movq  8%2, %%mm1           \n\t"
+             "movq  8%0, %%mm3           \n\t"
+             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
+             OP_AVG(%%mm3, %%mm2, %%mm0, %%mm6)
+             "movq  %%mm0, 8%0           \n\t"
+             :"+m"(*dst)
+             :"m"(*src1), "m"(*src2)
+             :"memory");
+         dst += dstStride;
+         src1 += src1Stride;
+         src2 += 16;
+     } while (--h);
+ }
+ static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_BFE(mm6);
+     __asm__ volatile(
+         "lea    (%3, %3), %%"REG_a"     \n\t"
+         "movq   (%1), %%mm0             \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1, %3), %%mm1         \n\t"
+         "movq   (%1, %%"REG_a"), %%mm2  \n\t"
+         PAVGBP(%%mm1, %%mm0, %%mm4,   %%mm2, %%mm1, %%mm5)
+         "movq   (%2), %%mm3             \n\t"
+         OP_AVG(%%mm3, %%mm4, %%mm0, %%mm6)
+         "movq   (%2, %3), %%mm3         \n\t"
+         OP_AVG(%%mm3, %%mm5, %%mm1, %%mm6)
+         "movq   %%mm0, (%2)             \n\t"
+         "movq   %%mm1, (%2, %3)         \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "movq   (%1, %3), %%mm1         \n\t"
+         "movq   (%1, %%"REG_a"), %%mm0  \n\t"
+         PAVGBP(%%mm1, %%mm2, %%mm4,   %%mm0, %%mm1, %%mm5)
+         "movq   (%2), %%mm3             \n\t"
+         OP_AVG(%%mm3, %%mm4, %%mm2, %%mm6)
+         "movq   (%2, %3), %%mm3         \n\t"
+         OP_AVG(%%mm3, %%mm5, %%mm1, %%mm6)
+         "movq   %%mm2, (%2)             \n\t"
+         "movq   %%mm1, (%2, %3)         \n\t"
+         "add    %%"REG_a", %1           \n\t"
+         "add    %%"REG_a", %2           \n\t"
+         "subl   $4, %0                  \n\t"
+         "jnz    1b                      \n\t"
+         :"+g"(h), "+S"(pixels), "+D"(block)
+         :"r"((x86_reg)line_size)
+         :REG_a, "memory");
+ }
+ // this routine is 'slightly' suboptimal but mostly unused
+ static void DEF(avg, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+ {
+     MOVQ_ZERO(mm7);
+     SET_RND(mm6); // =2 for rnd  and  =1 for no_rnd version
+     __asm__ volatile(
+         "movq   (%1), %%mm0             \n\t"
+         "movq   1(%1), %%mm4            \n\t"
+         "movq   %%mm0, %%mm1            \n\t"
+         "movq   %%mm4, %%mm5            \n\t"
+         "punpcklbw %%mm7, %%mm0         \n\t"
+         "punpcklbw %%mm7, %%mm4         \n\t"
+         "punpckhbw %%mm7, %%mm1         \n\t"
+         "punpckhbw %%mm7, %%mm5         \n\t"
+         "paddusw %%mm0, %%mm4           \n\t"
+         "paddusw %%mm1, %%mm5           \n\t"
+         "xor    %%"REG_a", %%"REG_a"    \n\t"
+         "add    %3, %1                  \n\t"
+         ".p2align 3                     \n\t"
+         "1:                             \n\t"
+         "movq   (%1, %%"REG_a"), %%mm0  \n\t"
+         "movq   1(%1, %%"REG_a"), %%mm2 \n\t"
+         "movq   %%mm0, %%mm1            \n\t"
+         "movq   %%mm2, %%mm3            \n\t"
+         "punpcklbw %%mm7, %%mm0         \n\t"
+         "punpcklbw %%mm7, %%mm2         \n\t"
+         "punpckhbw %%mm7, %%mm1         \n\t"
+         "punpckhbw %%mm7, %%mm3         \n\t"
+         "paddusw %%mm2, %%mm0           \n\t"
+         "paddusw %%mm3, %%mm1           \n\t"
+         "paddusw %%mm6, %%mm4           \n\t"
+         "paddusw %%mm6, %%mm5           \n\t"
+         "paddusw %%mm0, %%mm4           \n\t"
+         "paddusw %%mm1, %%mm5           \n\t"
+         "psrlw  $2, %%mm4               \n\t"
+         "psrlw  $2, %%mm5               \n\t"
+                 "movq   (%2, %%"REG_a"), %%mm3  \n\t"
+         "packuswb  %%mm5, %%mm4         \n\t"
+                 "pcmpeqd %%mm2, %%mm2   \n\t"
+                 "paddb %%mm2, %%mm2     \n\t"
+                 OP_AVG(%%mm3, %%mm4, %%mm5, %%mm2)
+                 "movq   %%mm5, (%2, %%"REG_a")  \n\t"
+         "add    %3, %%"REG_a"                \n\t"
+         "movq   (%1, %%"REG_a"), %%mm2  \n\t" // 0 <-> 2   1 <-> 3
+         "movq   1(%1, %%"REG_a"), %%mm4 \n\t"
+         "movq   %%mm2, %%mm3            \n\t"
+         "movq   %%mm4, %%mm5            \n\t"
+         "punpcklbw %%mm7, %%mm2         \n\t"
+         "punpcklbw %%mm7, %%mm4         \n\t"
+         "punpckhbw %%mm7, %%mm3         \n\t"
+         "punpckhbw %%mm7, %%mm5         \n\t"
+         "paddusw %%mm2, %%mm4           \n\t"
+         "paddusw %%mm3, %%mm5           \n\t"
+         "paddusw %%mm6, %%mm0           \n\t"
+         "paddusw %%mm6, %%mm1           \n\t"
+         "paddusw %%mm4, %%mm0           \n\t"
+         "paddusw %%mm5, %%mm1           \n\t"
+         "psrlw  $2, %%mm0               \n\t"
+         "psrlw  $2, %%mm1               \n\t"
+                 "movq   (%2, %%"REG_a"), %%mm3  \n\t"
+         "packuswb  %%mm1, %%mm0         \n\t"
+                 "pcmpeqd %%mm2, %%mm2   \n\t"
+                 "paddb %%mm2, %%mm2     \n\t"
+                 OP_AVG(%%mm3, %%mm0, %%mm1, %%mm2)
+                 "movq   %%mm1, (%2, %%"REG_a")  \n\t"
+         "add    %3, %%"REG_a"           \n\t"
+         "subl   $2, %0                  \n\t"
+         "jnz    1b                      \n\t"
+         :"+g"(h), "+S"(pixels)
+         :"D"(block), "r"((x86_reg)line_size)
+         :REG_a, "memory");
+ }
+ //FIXME optimize
+ static void DEF(put, pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(put, pixels8_y2)(block  , pixels  , line_size, h);
+     DEF(put, pixels8_y2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(put, pixels16_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(put, pixels8_xy2)(block  , pixels  , line_size, h);
+     DEF(put, pixels8_xy2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(avg, pixels16_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(avg, pixels8_y2)(block  , pixels  , line_size, h);
+     DEF(avg, pixels8_y2)(block+8, pixels+8, line_size, h);
+ }
+ static void DEF(avg, pixels16_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){
+     DEF(avg, pixels8_xy2)(block  , pixels  , line_size, h);
+     DEF(avg, pixels8_xy2)(block+8, pixels+8, line_size, h);
+ }
Simple merge
  
  #include "libavutil/x86/asm.h"
  #include "libavutil/cpu.h"
 -#include "libavutil/internal.h"
  #include "libavcodec/lpc.h"
  
- #if HAVE_INLINE_ASM
+ #if HAVE_SSE2_INLINE
  
  static void lpc_apply_welch_window_sse2(const int32_t *data, int len,
                                          double *w_data)
@@@ -248,13 -244,11 +248,14 @@@ void ff_mpadsp_init_mmx(MPADSPContext *
      if (mm_flags & AV_CPU_FLAG_SSE2) {
          s->apply_window_float = apply_window_mp3;
      }
- #endif /* HAVE_INLINE_ASM */
+ #endif /* HAVE_SSE2_INLINE */
  #if HAVE_YASM
 -    if (mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
 +    if (0) {
 +#if HAVE_AVX_EXTERNAL
 +    } else if (mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
          s->imdct36_blocks_float = imdct36_blocks_avx;
 +#endif
  #if HAVE_SSE
      } else if (mm_flags & AV_CPU_FLAG_SSSE3) {
          s->imdct36_blocks_float = imdct36_blocks_ssse3;
@@@ -580,11 -579,11 +580,12 @@@ int ff_mov_read_chan(AVFormatContext *s
              label_mask |= mask_incr;
          }
      }
-     if (layout_tag == 0)
+     if (layout_tag == 0) {
+         if (label_mask)
              st->codec->channel_layout = label_mask;
-     else
+     else
          st->codec->channel_layout = ff_mov_get_channel_layout(layout_tag, bitmap);
 +    avio_skip(pb, size - 12);
  
      return 0;
  }
Simple merge
Simple merge
@@@ -8,7 -8,6 +8,6 @@@ FATE_MPC += fate-musepack
  fate-musepack7: CMD = pcm -i $(SAMPLES)/musepack/inside-mp7.mpc
  fate-musepack7: CMP = oneoff
  fate-musepack7: REF = $(SAMPLES)/musepack/inside-mp7.pcm
- fate-musepack7: FUZZ = 1
  
 -FATE_SAMPLES_AVCONV += $(FATE_MPC)
 +FATE_SAMPLES_FFMPEG += $(FATE_MPC)
  fate-mpc: $(FATE_MPC)