From 97c50cb77949856573d7f5f5a3c28cb73e61e011 Mon Sep 17 00:00:00 2001
From: Mike Melanson <mike@multimedia.cx>
Date: Tue, 19 Apr 2005 05:16:45 +0000
Subject: sync to FFmpeg build 4752

CVS patchset: 7463
CVS date: 2005/04/19 05:16:45
---
 src/libffmpeg/libavcodec/i386/cputest.c            |  117 +-
 src/libffmpeg/libavcodec/i386/dsputil_mmx.c        | 1244 +++++++++++++++++---
 src/libffmpeg/libavcodec/i386/dsputil_mmx_avg.h    |  601 ++++++++--
 src/libffmpeg/libavcodec/i386/dsputil_mmx_rnd.h    |  179 +--
 src/libffmpeg/libavcodec/i386/fdct_mmx.c           |    6 +-
 src/libffmpeg/libavcodec/i386/mmx.h                |    6 +
 src/libffmpeg/libavcodec/i386/motion_est_mmx.c     |  121 +-
 src/libffmpeg/libavcodec/i386/mpegvideo_mmx.c      |  145 +--
 .../libavcodec/i386/mpegvideo_mmx_template.c       |   47 +-
 9 files changed, 1889 insertions(+), 577 deletions(-)

(limited to 'src/libffmpeg/libavcodec/i386')

diff --git a/src/libffmpeg/libavcodec/i386/cputest.c b/src/libffmpeg/libavcodec/i386/cputest.c
index b50d653c4..593e0550d 100644
--- a/src/libffmpeg/libavcodec/i386/cputest.c
+++ b/src/libffmpeg/libavcodec/i386/cputest.c
@@ -4,12 +4,20 @@
 #include <stdlib.h>
 #include "../dsputil.h"
 
+#ifdef ARCH_X86_64
+#  define REG_b "rbx"
+#  define REG_S "rsi"
+#else
+#  define REG_b "ebx"
+#  define REG_S "esi"
+#endif
+
 /* ebx saving is necessary for PIC. gcc seems unable to see it alone */
 #define cpuid(index,eax,ebx,ecx,edx)\
     __asm __volatile\
-	("movl %%ebx, %%esi\n\t"\
+	("mov %%"REG_b", %%"REG_S"\n\t"\
          "cpuid\n\t"\
-         "xchgl %%ebx, %%esi"\
+         "xchg %%"REG_b", %%"REG_S\
          : "=a" (eax), "=S" (ebx),\
            "=c" (ecx), "=d" (edx)\
          : "0" (index));
@@ -17,82 +25,72 @@
 /* Function to test if multimedia instructions are supported...  */
 int mm_support(void)
 {
-    int rval;
+    int rval = 0;
     int eax, ebx, ecx, edx;
+    int max_std_level, max_ext_level, std_caps=0, ext_caps=0;
+    long a, c;
     
     __asm__ __volatile__ (
                           /* See if CPUID instruction is supported ... */
                           /* ... Get copies of EFLAGS into eax and ecx */
                           "pushf\n\t"
-                          "popl %0\n\t"
-                          "movl %0, %1\n\t"
+                          "pop %0\n\t"
+                          "mov %0, %1\n\t"
                           
                           /* ... Toggle the ID bit in one copy and store */
                           /*     to the EFLAGS reg */
-                          "xorl $0x200000, %0\n\t"
+                          "xor $0x200000, %0\n\t"
                           "push %0\n\t"
                           "popf\n\t"
                           
                           /* ... Get the (hopefully modified) EFLAGS */
                           "pushf\n\t"
-                          "popl %0\n\t"
-                          : "=a" (eax), "=c" (ecx)
+                          "pop %0\n\t"
+                          : "=a" (a), "=c" (c)
                           :
                           : "cc" 
                           );
     
-    if (eax == ecx)
+    if (a == c)
         return 0; /* CPUID not supported */
-    
-    cpuid(0, eax, ebx, ecx, edx);
 
-    if (ebx == 0x756e6547 &&
-        edx == 0x49656e69 &&
-        ecx == 0x6c65746e) {
-        
-        /* intel */
-    inteltest:
-        cpuid(1, eax, ebx, ecx, edx);
-        if ((edx & 0x00800000) == 0)
-            return 0;
-        rval = MM_MMX;
-        if (edx & 0x02000000) 
+    cpuid(0, max_std_level, ebx, ecx, edx);
+
+    if(max_std_level >= 1){
+        cpuid(1, eax, ebx, ecx, std_caps);
+        if (std_caps & (1<<23))
+            rval |= MM_MMX;
+        if (std_caps & (1<<25)) 
             rval |= MM_MMXEXT | MM_SSE;
-        if (edx & 0x04000000) 
+        if (std_caps & (1<<26)) 
             rval |= MM_SSE2;
-        return rval;
-    } else if (ebx == 0x68747541 &&
+    }
+
+    cpuid(0x80000000, max_ext_level, ebx, ecx, edx);
+
+    if(max_ext_level >= 0x80000001){
+        cpuid(0x80000001, eax, ebx, ecx, ext_caps);
+        if (ext_caps & (1<<31))
+            rval |= MM_3DNOW;
+        if (ext_caps & (1<<30))
+            rval |= MM_3DNOWEXT;
+        if (ext_caps & (1<<23))
+            rval |= MM_MMX;
+    }
+
+    cpuid(0, eax, ebx, ecx, edx);
+    if (       ebx == 0x68747541 &&
                edx == 0x69746e65 &&
                ecx == 0x444d4163) {
         /* AMD */
-        cpuid(0x80000000, eax, ebx, ecx, edx);
-        if ((unsigned)eax < 0x80000001)
-            goto inteltest;
-        cpuid(0x80000001, eax, ebx, ecx, edx);
-        if ((edx & 0x00800000) == 0)
-            return 0;
-        rval = MM_MMX;
-        if (edx & 0x80000000)
-            rval |= MM_3DNOW;
-        if (edx & 0x00400000)
+        if(ext_caps & (1<<22))
             rval |= MM_MMXEXT;
-        return rval;
     } else if (ebx == 0x746e6543 &&
                edx == 0x48727561 &&
                ecx == 0x736c7561) {  /*  "CentaurHauls" */
         /* VIA C3 */
-        cpuid(0x80000000, eax, ebx, ecx, edx);
-        if ((unsigned)eax < 0x80000001)
-            goto inteltest;	
-	cpuid(0x80000001, eax, ebx, ecx, edx);
-	rval = 0;      
-	if( edx & ( 1 << 31) )
-	  rval |= MM_3DNOW;
-	if( edx & ( 1 << 23) )
-	  rval |= MM_MMX;
-	if( edx & ( 1 << 24) )
+	if(ext_caps & (1<<24))
 	  rval |= MM_MMXEXT;
-	return rval;
     } else if (ebx == 0x69727943 &&
                edx == 0x736e4978 &&
                ecx == 0x64616574) {
@@ -105,18 +103,21 @@ int mm_support(void)
            According to the table, the only CPU which supports level
            2 is also the only one which supports extended CPUID levels.
         */
-        if (eax != 2) 
-            goto inteltest;
-        cpuid(0x80000001, eax, ebx, ecx, edx);
-        if ((eax & 0x00800000) == 0)
-            return 0;
-        rval = MM_MMX;
-        if (eax & 0x01000000)
+        if (eax < 2) 
+            return rval;
+        if (ext_caps & (1<<24))
             rval |= MM_MMXEXT;
-        return rval;
-    } else {
-        return 0;
     }
+#if 0
+    av_log(NULL, AV_LOG_DEBUG, "%s%s%s%s%s%s\n", 
+        (rval&MM_MMX) ? "MMX ":"", 
+        (rval&MM_MMXEXT) ? "MMX2 ":"", 
+        (rval&MM_SSE) ? "SSE ":"", 
+        (rval&MM_SSE2) ? "SSE2 ":"", 
+        (rval&MM_3DNOW) ? "3DNow ":"", 
+        (rval&MM_3DNOWEXT) ? "3DNowExt ":"");
+#endif
+    return rval;
 }
 
 #ifdef __TEST__
@@ -124,7 +125,7 @@ int main ( void )
 {
   int mm_flags;
   mm_flags = mm_support();
-  printf("mm_support = 0x%08u\n",mm_flags);
+  printf("mm_support = 0x%08X\n",mm_flags);
   return 0;
 }
 #endif
diff --git a/src/libffmpeg/libavcodec/i386/dsputil_mmx.c b/src/libffmpeg/libavcodec/i386/dsputil_mmx.c
index 11504e225..550122673 100644
--- a/src/libffmpeg/libavcodec/i386/dsputil_mmx.c
+++ b/src/libffmpeg/libavcodec/i386/dsputil_mmx.c
@@ -22,6 +22,7 @@
 
 #include "../dsputil.h"
 #include "../simple_idct.h"
+#include "../mpegvideo.h"
 #include "mmx.h"
 
 //#undef NDEBUG
@@ -38,7 +39,9 @@ static const uint64_t mm_wtwo attribute_used __attribute__ ((aligned(8))) = 0x00
 
 static const uint64_t ff_pw_20 attribute_used __attribute__ ((aligned(8))) = 0x0014001400140014ULL;
 static const uint64_t ff_pw_3  attribute_used __attribute__ ((aligned(8))) = 0x0003000300030003ULL;
+static const uint64_t ff_pw_5  attribute_used __attribute__ ((aligned(8))) = 0x0005000500050005ULL;
 static const uint64_t ff_pw_16 attribute_used __attribute__ ((aligned(8))) = 0x0010001000100010ULL;
+static const uint64_t ff_pw_32 attribute_used __attribute__ ((aligned(8))) = 0x0020002000200020ULL;
 static const uint64_t ff_pw_15 attribute_used __attribute__ ((aligned(8))) = 0x000F000F000F000FULL;
 
 static const uint64_t ff_pb_FC attribute_used __attribute__ ((aligned(8))) = 0xFCFCFCFCFCFCFCFCULL;
@@ -184,7 +187,7 @@ static const uint64_t ff_pb_FC attribute_used __attribute__ ((aligned(8))) = 0xF
 static void get_pixels_mmx(DCTELEM *block, const uint8_t *pixels, int line_size)
 {
     asm volatile(
-        "movl $-128, %%eax	\n\t"
+        "mov $-128, %%"REG_a"	\n\t"
         "pxor %%mm7, %%mm7	\n\t"
         ".balign 16		\n\t"
         "1:			\n\t"
@@ -196,16 +199,16 @@ static void get_pixels_mmx(DCTELEM *block, const uint8_t *pixels, int line_size)
         "punpckhbw %%mm7, %%mm1	\n\t"
         "punpcklbw %%mm7, %%mm2	\n\t"
         "punpckhbw %%mm7, %%mm3	\n\t"
-        "movq %%mm0, (%1, %%eax)\n\t"
-        "movq %%mm1, 8(%1, %%eax)\n\t"
-        "movq %%mm2, 16(%1, %%eax)\n\t"
-        "movq %%mm3, 24(%1, %%eax)\n\t"
-        "addl %3, %0		\n\t"
-        "addl $32, %%eax	\n\t"
+        "movq %%mm0, (%1, %%"REG_a")\n\t"
+        "movq %%mm1, 8(%1, %%"REG_a")\n\t"
+        "movq %%mm2, 16(%1, %%"REG_a")\n\t"
+        "movq %%mm3, 24(%1, %%"REG_a")\n\t"
+        "add %3, %0		\n\t"
+        "add $32, %%"REG_a"	\n\t"
         "js 1b			\n\t"
         : "+r" (pixels)
-        : "r" (block+64), "r" (line_size), "r" (line_size*2)
-        : "%eax"
+        : "r" (block+64), "r" ((long)line_size), "r" ((long)line_size*2)
+        : "%"REG_a
     );
 }
 
@@ -213,7 +216,7 @@ static inline void diff_pixels_mmx(DCTELEM *block, const uint8_t *s1, const uint
 {
     asm volatile(
         "pxor %%mm7, %%mm7	\n\t"
-        "movl $-128, %%eax	\n\t"
+        "mov $-128, %%"REG_a"	\n\t"
         ".balign 16		\n\t"
         "1:			\n\t"
         "movq (%0), %%mm0	\n\t"
@@ -226,15 +229,15 @@ static inline void diff_pixels_mmx(DCTELEM *block, const uint8_t *s1, const uint
         "punpckhbw %%mm7, %%mm3	\n\t"
         "psubw %%mm2, %%mm0	\n\t"
         "psubw %%mm3, %%mm1	\n\t"
-        "movq %%mm0, (%2, %%eax)\n\t"
-        "movq %%mm1, 8(%2, %%eax)\n\t"
-        "addl %3, %0		\n\t"
-        "addl %3, %1		\n\t"
-        "addl $16, %%eax	\n\t"
+        "movq %%mm0, (%2, %%"REG_a")\n\t"
+        "movq %%mm1, 8(%2, %%"REG_a")\n\t"
+        "add %3, %0		\n\t"
+        "add %3, %1		\n\t"
+        "add $16, %%"REG_a"	\n\t"
         "jnz 1b			\n\t"
         : "+r" (s1), "+r" (s2)
-        : "r" (block+64), "r" (stride)
-        : "%eax"
+        : "r" (block+64), "r" ((long)stride)
+        : "%"REG_a
     );
 }
 #endif //CONFIG_ENCODERS
@@ -265,7 +268,7 @@ void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size
 		"movq	%%mm2, (%0, %1)\n\t"
 		"movq	%%mm4, (%0, %1, 2)\n\t"
 		"movq	%%mm6, (%0, %2)\n\t"
-		::"r" (pix), "r" (line_size), "r" (line_size*3), "m"(*p)
+		::"r" (pix), "r" ((long)line_size), "r" ((long)line_size*3), "m"(*p)
 		:"memory");
         pix += line_size*4;
         p += 32;
@@ -290,7 +293,7 @@ void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size
 	    "movq	%%mm2, (%0, %1)\n\t"
 	    "movq	%%mm4, (%0, %1, 2)\n\t"
 	    "movq	%%mm6, (%0, %2)\n\t"
-	    ::"r" (pix), "r" (line_size), "r" (line_size*3), "r"(p)
+	    ::"r" (pix), "r" ((long)line_size), "r" ((long)line_size*3), "r"(p)
 	    :"memory");
 }
 
@@ -353,36 +356,62 @@ void add_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size
     } while (--i);
 }
 
+static void put_pixels4_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+{
+    __asm __volatile(
+	 "lea (%3, %3), %%"REG_a"	\n\t"
+	 ".balign 8			\n\t"
+	 "1:				\n\t"
+	 "movd (%1), %%mm0		\n\t"
+	 "movd (%1, %3), %%mm1		\n\t"
+	 "movd %%mm0, (%2)		\n\t"
+	 "movd %%mm1, (%2, %3)		\n\t"
+	 "add %%"REG_a", %1		\n\t"
+	 "add %%"REG_a", %2		\n\t"
+	 "movd (%1), %%mm0		\n\t"
+	 "movd (%1, %3), %%mm1		\n\t"
+	 "movd %%mm0, (%2)		\n\t"
+	 "movd %%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), "+r" (pixels),  "+r" (block)
+	 : "r"((long)line_size)
+	 : "%"REG_a, "memory"
+	);
+}
+
 static void put_pixels8_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
-	 "lea (%3, %3), %%eax		\n\t"
+	 "lea (%3, %3), %%"REG_a"	\n\t"
 	 ".balign 8			\n\t"
 	 "1:				\n\t"
 	 "movq (%1), %%mm0		\n\t"
 	 "movq (%1, %3), %%mm1		\n\t"
      	 "movq %%mm0, (%2)		\n\t"
 	 "movq %%mm1, (%2, %3)		\n\t"
-	 "addl %%eax, %1		\n\t"
-         "addl %%eax, %2       		\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 %%mm0, (%2)		\n\t"
 	 "movq %%mm1, (%2, %3)		\n\t"
-	 "addl %%eax, %1		\n\t"
-	 "addl %%eax, %2       		\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), "+r" (pixels),  "+r" (block)
-	 : "r"(line_size)
-	 : "%eax", "memory"
+	 : "r"((long)line_size)
+	 : "%"REG_a, "memory"
 	);
 }
 
 static void put_pixels16_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
-	 "lea (%3, %3), %%eax		\n\t"
+	 "lea (%3, %3), %%"REG_a"	\n\t"
 	 ".balign 8			\n\t"
 	 "1:				\n\t"
 	 "movq (%1), %%mm0		\n\t"
@@ -393,8 +422,8 @@ static void put_pixels16_mmx(uint8_t *block, const uint8_t *pixels, int line_siz
      	 "movq %%mm4, 8(%2)		\n\t"
 	 "movq %%mm1, (%2, %3)		\n\t"
 	 "movq %%mm5, 8(%2, %3)		\n\t"
-	 "addl %%eax, %1		\n\t"
-         "addl %%eax, %2       		\n\t"
+	 "add %%"REG_a", %1		\n\t"
+	 "add %%"REG_a", %2       	\n\t"
 	 "movq (%1), %%mm0		\n\t"
 	 "movq 8(%1), %%mm4		\n\t"
 	 "movq (%1, %3), %%mm1		\n\t"
@@ -403,13 +432,13 @@ static void put_pixels16_mmx(uint8_t *block, const uint8_t *pixels, int line_siz
 	 "movq %%mm4, 8(%2)		\n\t"
 	 "movq %%mm1, (%2, %3)		\n\t"
 	 "movq %%mm5, 8(%2, %3)		\n\t"
-	 "addl %%eax, %1		\n\t"
-	 "addl %%eax, %2       		\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), "+r" (pixels),  "+r" (block)
-	 : "r"(line_size)
-	 : "%eax", "memory"
+	 : "r"((long)line_size)
+	 : "%"REG_a, "memory"
 	);
 }
 
@@ -417,16 +446,16 @@ static void clear_blocks_mmx(DCTELEM *blocks)
 {
     __asm __volatile(
                 "pxor %%mm7, %%mm7		\n\t"
-                "movl $-128*6, %%eax		\n\t"
+                "mov $-128*6, %%"REG_a"	\n\t"
                 "1:				\n\t"
-                "movq %%mm7, (%0, %%eax)	\n\t"
-                "movq %%mm7, 8(%0, %%eax)	\n\t"
-                "movq %%mm7, 16(%0, %%eax)	\n\t"
-                "movq %%mm7, 24(%0, %%eax)	\n\t"
-                "addl $32, %%eax		\n\t"
+                "movq %%mm7, (%0, %%"REG_a")	\n\t"
+                "movq %%mm7, 8(%0, %%"REG_a")	\n\t"
+                "movq %%mm7, 16(%0, %%"REG_a")	\n\t"
+                "movq %%mm7, 24(%0, %%"REG_a")	\n\t"
+                "add $32, %%"REG_a"		\n\t"
                 " js 1b				\n\t"
-                : : "r" (((int)blocks)+128*6)
-                : "%eax"
+                : : "r" (((uint8_t *)blocks)+128*6)
+                : "%"REG_a
         );
 }
 
@@ -434,7 +463,7 @@ static void clear_blocks_mmx(DCTELEM *blocks)
 static int pix_sum16_mmx(uint8_t * pix, int line_size){
     const int h=16;
     int sum;
-    int index= -line_size*h;
+    long index= -line_size*h;
 
     __asm __volatile(
                 "pxor %%mm7, %%mm7		\n\t"
@@ -452,7 +481,7 @@ static int pix_sum16_mmx(uint8_t * pix, int line_size){
                 "paddw %%mm2, %%mm3		\n\t"
                 "paddw %%mm1, %%mm3		\n\t"
                 "paddw %%mm3, %%mm6		\n\t"
-                "addl %3, %1			\n\t"
+                "add %3, %1			\n\t"
                 " js 1b				\n\t"
                 "movq %%mm6, %%mm5		\n\t"
                 "psrlq $32, %%mm6		\n\t"
@@ -463,7 +492,7 @@ static int pix_sum16_mmx(uint8_t * pix, int line_size){
                 "movd %%mm6, %0			\n\t"
                 "andl $0xFFFF, %0		\n\t"
                 : "=&r" (sum), "+r" (index)
-                : "r" (pix - index), "r" (line_size)
+                : "r" (pix - index), "r" ((long)line_size)
         );
 
         return sum;
@@ -471,7 +500,7 @@ static int pix_sum16_mmx(uint8_t * pix, int line_size){
 #endif //CONFIG_ENCODERS
 
 static void add_bytes_mmx(uint8_t *dst, uint8_t *src, int w){
-    int i=0;
+    long i=0;
     asm volatile(
         "1:				\n\t"
         "movq  (%1, %0), %%mm0		\n\t"
@@ -482,11 +511,11 @@ static void add_bytes_mmx(uint8_t *dst, uint8_t *src, int w){
         "movq 8(%2, %0), %%mm1		\n\t"
         "paddb %%mm0, %%mm1		\n\t"
         "movq %%mm1, 8(%2, %0)		\n\t"
-        "addl $16, %0			\n\t"
-        "cmpl %3, %0			\n\t"
+        "add $16, %0			\n\t"
+        "cmp %3, %0			\n\t"
         " jb 1b				\n\t"
         : "+r" (i)
-        : "r"(src), "r"(dst), "r"(w-15)
+        : "r"(src), "r"(dst), "r"((long)w-15)
     );
     for(; i<w; i++)
         dst[i+0] += src[i+0];
@@ -643,26 +672,22 @@ static void h263_h_loop_filter_mmx(uint8_t *src, int stride, int qscale){
         "punpcklwd %%mm0, %%mm1		\n\t"
         "punpckhwd %%mm4, %%mm3		\n\t"
         "punpckhwd %%mm0, %%mm6		\n\t"
-        "movd %%mm5, %0			\n\t"
+        "movd %%mm5, (%0)		\n\t"
         "punpckhdq %%mm5, %%mm5		\n\t"
-        "movd %%mm5, %1			\n\t"
-        "movd %%mm3, %2			\n\t"
+        "movd %%mm5, (%0,%2)		\n\t"
+        "movd %%mm3, (%0,%2,2)		\n\t"
         "punpckhdq %%mm3, %%mm3		\n\t"
-        "movd %%mm3, %3			\n\t"
-        "movd %%mm1, %4			\n\t"
+        "movd %%mm3, (%0,%3)		\n\t"
+        "movd %%mm1, (%1)		\n\t"
         "punpckhdq %%mm1, %%mm1		\n\t"
-        "movd %%mm1, %5			\n\t"
-        "movd %%mm6, %6			\n\t"
+        "movd %%mm1, (%1,%2)		\n\t"
+        "movd %%mm6, (%1,%2,2)		\n\t"
         "punpckhdq %%mm6, %%mm6		\n\t"
-        "movd %%mm6, %7			\n\t"
-        : "=m" (*(uint32_t*)(src + 0*stride)),
-          "=m" (*(uint32_t*)(src + 1*stride)),
-          "=m" (*(uint32_t*)(src + 2*stride)),
-          "=m" (*(uint32_t*)(src + 3*stride)),
-          "=m" (*(uint32_t*)(src + 4*stride)),
-          "=m" (*(uint32_t*)(src + 5*stride)),
-          "=m" (*(uint32_t*)(src + 6*stride)),
-          "=m" (*(uint32_t*)(src + 7*stride))
+        "movd %%mm6, (%1,%3)		\n\t"
+        :: "r" (src),
+           "r" (src + 4*stride),
+           "r" ((long)   stride ),
+           "r" ((long)(3*stride))
     );
 }
 
@@ -697,7 +722,7 @@ static int pix_norm1_mmx(uint8_t *pix, int line_size) {
       "paddd %%mm3,%%mm4\n"
       "paddd %%mm2,%%mm7\n"
 
-      "addl %2, %0\n"
+      "add %2, %0\n"
       "paddd %%mm4,%%mm7\n"
       "dec %%ecx\n"
       "jnz 1b\n"
@@ -706,7 +731,50 @@ static int pix_norm1_mmx(uint8_t *pix, int line_size) {
       "psrlq $32, %%mm7\n"	/* shift hi dword to lo */
       "paddd %%mm7,%%mm1\n"
       "movd %%mm1,%1\n"
-      : "+r" (pix), "=r"(tmp) : "r" (line_size) : "%ecx" );
+      : "+r" (pix), "=r"(tmp) : "r" ((long)line_size) : "%ecx" );
+    return tmp;
+}
+
+static int sse8_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
+    int tmp;
+  asm volatile (
+      "movl %4,%%ecx\n"
+      "pxor %%mm0,%%mm0\n"	/* mm0 = 0 */
+      "pxor %%mm7,%%mm7\n"	/* mm7 holds the sum */
+      "1:\n"
+      "movq (%0),%%mm1\n"	/* mm1 = pix1[0-7] */
+      "movq (%1),%%mm2\n"	/* mm2 = pix2[0-7] */
+
+      "movq %%mm1,%%mm5\n"
+      "psubusb %%mm2,%%mm1\n"
+      "psubusb %%mm5,%%mm2\n"
+
+      "por %%mm1,%%mm2\n"
+
+      "movq %%mm2,%%mm1\n"
+
+      "punpckhbw %%mm0,%%mm2\n"
+      "punpcklbw %%mm0,%%mm1\n"	/* mm1 now spread over (mm1,mm2) */
+
+      "pmaddwd %%mm2,%%mm2\n"
+      "pmaddwd %%mm1,%%mm1\n"
+
+      "add %3,%0\n"
+      "add %3,%1\n"
+
+      "paddd %%mm2,%%mm1\n"
+      "paddd %%mm1,%%mm7\n"
+
+      "decl %%ecx\n"
+      "jnz 1b\n"
+
+      "movq %%mm7,%%mm1\n"
+      "psrlq $32, %%mm7\n"	/* shift hi dword to lo */
+      "paddd %%mm7,%%mm1\n"
+      "movd %%mm1,%2\n"
+      : "+r" (pix1), "+r" (pix2), "=r"(tmp) 
+      : "r" ((long)line_size) , "m" (h)
+      : "%ecx");
     return tmp;
 }
 
@@ -749,8 +817,8 @@ static int sse16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int
       "pmaddwd %%mm1,%%mm1\n"
       "pmaddwd %%mm3,%%mm3\n"
 
-      "addl %3,%0\n"
-      "addl %3,%1\n"
+      "add %3,%0\n"
+      "add %3,%1\n"
 
       "paddd %%mm2,%%mm1\n"
       "paddd %%mm4,%%mm3\n"
@@ -765,11 +833,266 @@ static int sse16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int
       "paddd %%mm7,%%mm1\n"
       "movd %%mm1,%2\n"
       : "+r" (pix1), "+r" (pix2), "=r"(tmp) 
-      : "r" (line_size) , "m" (h)
+      : "r" ((long)line_size) , "m" (h)
       : "%ecx");
     return tmp;
 }
 
+static int hf_noise8_mmx(uint8_t * pix1, int line_size, int h) {
+    int tmp;
+  asm volatile (
+      "movl %3,%%ecx\n"
+      "pxor %%mm7,%%mm7\n"
+      "pxor %%mm6,%%mm6\n"
+      
+      "movq (%0),%%mm0\n"
+      "movq %%mm0, %%mm1\n"
+      "psllq $8, %%mm0\n"
+      "psrlq $8, %%mm1\n"
+      "psrlq $8, %%mm0\n"
+      "movq %%mm0, %%mm2\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm0\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm2\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm0\n"
+      "psubw %%mm3, %%mm2\n"
+      
+      "add %2,%0\n"
+      
+      "movq (%0),%%mm4\n"
+      "movq %%mm4, %%mm1\n"
+      "psllq $8, %%mm4\n"
+      "psrlq $8, %%mm1\n"
+      "psrlq $8, %%mm4\n"
+      "movq %%mm4, %%mm5\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm4\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm5\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm4\n"
+      "psubw %%mm3, %%mm5\n"
+      "psubw %%mm4, %%mm0\n"
+      "psubw %%mm5, %%mm2\n"
+      "pxor %%mm3, %%mm3\n"
+      "pxor %%mm1, %%mm1\n"
+      "pcmpgtw %%mm0, %%mm3\n\t"
+      "pcmpgtw %%mm2, %%mm1\n\t"
+      "pxor %%mm3, %%mm0\n"
+      "pxor %%mm1, %%mm2\n"
+      "psubw %%mm3, %%mm0\n" 
+      "psubw %%mm1, %%mm2\n"
+      "paddw %%mm0, %%mm2\n"
+      "paddw %%mm2, %%mm6\n"
+
+      "add %2,%0\n"
+      "1:\n"
+  
+      "movq (%0),%%mm0\n"
+      "movq %%mm0, %%mm1\n"
+      "psllq $8, %%mm0\n"
+      "psrlq $8, %%mm1\n"
+      "psrlq $8, %%mm0\n"
+      "movq %%mm0, %%mm2\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm0\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm2\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm0\n"
+      "psubw %%mm3, %%mm2\n"
+      "psubw %%mm0, %%mm4\n"
+      "psubw %%mm2, %%mm5\n"
+      "pxor %%mm3, %%mm3\n"
+      "pxor %%mm1, %%mm1\n"
+      "pcmpgtw %%mm4, %%mm3\n\t"
+      "pcmpgtw %%mm5, %%mm1\n\t"
+      "pxor %%mm3, %%mm4\n"
+      "pxor %%mm1, %%mm5\n"
+      "psubw %%mm3, %%mm4\n" 
+      "psubw %%mm1, %%mm5\n"
+      "paddw %%mm4, %%mm5\n"
+      "paddw %%mm5, %%mm6\n"
+      
+      "add %2,%0\n"
+      
+      "movq (%0),%%mm4\n"
+      "movq %%mm4, %%mm1\n"
+      "psllq $8, %%mm4\n"
+      "psrlq $8, %%mm1\n"
+      "psrlq $8, %%mm4\n"
+      "movq %%mm4, %%mm5\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm4\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm5\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm4\n"
+      "psubw %%mm3, %%mm5\n"
+      "psubw %%mm4, %%mm0\n"
+      "psubw %%mm5, %%mm2\n"
+      "pxor %%mm3, %%mm3\n"
+      "pxor %%mm1, %%mm1\n"
+      "pcmpgtw %%mm0, %%mm3\n\t"
+      "pcmpgtw %%mm2, %%mm1\n\t"
+      "pxor %%mm3, %%mm0\n"
+      "pxor %%mm1, %%mm2\n"
+      "psubw %%mm3, %%mm0\n" 
+      "psubw %%mm1, %%mm2\n"
+      "paddw %%mm0, %%mm2\n"
+      "paddw %%mm2, %%mm6\n"
+
+      "add %2,%0\n"
+      "subl $2, %%ecx\n"
+      " jnz 1b\n"
+
+      "movq %%mm6, %%mm0\n"
+      "punpcklwd %%mm7,%%mm0\n"
+      "punpckhwd %%mm7,%%mm6\n"
+      "paddd %%mm0, %%mm6\n"
+      
+      "movq %%mm6,%%mm0\n"
+      "psrlq $32, %%mm6\n"
+      "paddd %%mm6,%%mm0\n"
+      "movd %%mm0,%1\n"
+      : "+r" (pix1), "=r"(tmp) 
+      : "r" ((long)line_size) , "g" (h-2)
+      : "%ecx");
+      return tmp;
+}
+
+static int hf_noise16_mmx(uint8_t * pix1, int line_size, int h) {
+    int tmp;
+    uint8_t * pix= pix1;
+  asm volatile (
+      "movl %3,%%ecx\n"
+      "pxor %%mm7,%%mm7\n"
+      "pxor %%mm6,%%mm6\n"
+      
+      "movq (%0),%%mm0\n"
+      "movq 1(%0),%%mm1\n"
+      "movq %%mm0, %%mm2\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm0\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm2\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm0\n"
+      "psubw %%mm3, %%mm2\n"
+      
+      "add %2,%0\n"
+      
+      "movq (%0),%%mm4\n"
+      "movq 1(%0),%%mm1\n"
+      "movq %%mm4, %%mm5\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm4\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm5\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm4\n"
+      "psubw %%mm3, %%mm5\n"
+      "psubw %%mm4, %%mm0\n"
+      "psubw %%mm5, %%mm2\n"
+      "pxor %%mm3, %%mm3\n"
+      "pxor %%mm1, %%mm1\n"
+      "pcmpgtw %%mm0, %%mm3\n\t"
+      "pcmpgtw %%mm2, %%mm1\n\t"
+      "pxor %%mm3, %%mm0\n"
+      "pxor %%mm1, %%mm2\n"
+      "psubw %%mm3, %%mm0\n" 
+      "psubw %%mm1, %%mm2\n"
+      "paddw %%mm0, %%mm2\n"
+      "paddw %%mm2, %%mm6\n"
+
+      "add %2,%0\n"
+      "1:\n"
+  
+      "movq (%0),%%mm0\n"
+      "movq 1(%0),%%mm1\n"
+      "movq %%mm0, %%mm2\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm0\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm2\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm0\n"
+      "psubw %%mm3, %%mm2\n"
+      "psubw %%mm0, %%mm4\n"
+      "psubw %%mm2, %%mm5\n"
+      "pxor %%mm3, %%mm3\n"
+      "pxor %%mm1, %%mm1\n"
+      "pcmpgtw %%mm4, %%mm3\n\t"
+      "pcmpgtw %%mm5, %%mm1\n\t"
+      "pxor %%mm3, %%mm4\n"
+      "pxor %%mm1, %%mm5\n"
+      "psubw %%mm3, %%mm4\n"
+      "psubw %%mm1, %%mm5\n"
+      "paddw %%mm4, %%mm5\n"
+      "paddw %%mm5, %%mm6\n"
+      
+      "add %2,%0\n"
+      
+      "movq (%0),%%mm4\n"
+      "movq 1(%0),%%mm1\n"
+      "movq %%mm4, %%mm5\n"
+      "movq %%mm1, %%mm3\n"
+      "punpcklbw %%mm7,%%mm4\n"
+      "punpcklbw %%mm7,%%mm1\n"
+      "punpckhbw %%mm7,%%mm5\n"
+      "punpckhbw %%mm7,%%mm3\n"
+      "psubw %%mm1, %%mm4\n"
+      "psubw %%mm3, %%mm5\n"
+      "psubw %%mm4, %%mm0\n"
+      "psubw %%mm5, %%mm2\n"
+      "pxor %%mm3, %%mm3\n"
+      "pxor %%mm1, %%mm1\n"
+      "pcmpgtw %%mm0, %%mm3\n\t"
+      "pcmpgtw %%mm2, %%mm1\n\t"
+      "pxor %%mm3, %%mm0\n"
+      "pxor %%mm1, %%mm2\n"
+      "psubw %%mm3, %%mm0\n" 
+      "psubw %%mm1, %%mm2\n"
+      "paddw %%mm0, %%mm2\n"
+      "paddw %%mm2, %%mm6\n"
+
+      "add %2,%0\n"
+      "subl $2, %%ecx\n"
+      " jnz 1b\n"
+
+      "movq %%mm6, %%mm0\n"
+      "punpcklwd %%mm7,%%mm0\n"
+      "punpckhwd %%mm7,%%mm6\n"
+      "paddd %%mm0, %%mm6\n"
+      
+      "movq %%mm6,%%mm0\n"
+      "psrlq $32, %%mm6\n"
+      "paddd %%mm6,%%mm0\n"
+      "movd %%mm0,%1\n"
+      : "+r" (pix1), "=r"(tmp) 
+      : "r" ((long)line_size) , "g" (h-2)
+      : "%ecx");
+      return tmp + hf_noise8_mmx(pix+8, line_size, h);
+}
+
+static int nsse16_mmx(MpegEncContext *c, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
+    int score1= sse16_mmx(c, pix1, pix2, line_size, h);
+    int score2= hf_noise16_mmx(pix1, line_size, h) - hf_noise16_mmx(pix2, line_size, h);
+
+    if(c) return score1 + ABS(score2)*c->avctx->nsse_weight;
+    else  return score1 + ABS(score2)*8;
+}
+
+static int nsse8_mmx(MpegEncContext *c, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
+    int score1= sse8_mmx(c, pix1, pix2, line_size, h);
+    int score2= hf_noise8_mmx(pix1, line_size, h) - hf_noise8_mmx(pix2, line_size, h);
+
+    if(c) return score1 + ABS(score2)*c->avctx->nsse_weight;
+    else  return score1 + ABS(score2)*8;
+}
+
 static int vsad_intra16_mmx(void *v, uint8_t * pix, uint8_t * dummy, int line_size, int h) {
     int tmp;
     
@@ -779,7 +1102,7 @@ static int vsad_intra16_mmx(void *v, uint8_t * pix, uint8_t * dummy, int line_si
 #define SUM(in0, in1, out0, out1) \
       "movq (%0), %%mm2\n"\
       "movq 8(%0), %%mm3\n"\
-      "addl %2,%0\n"\
+      "add %2,%0\n"\
       "movq %%mm2, " #out0 "\n"\
       "movq %%mm3, " #out1 "\n"\
       "psubusb " #in0 ", %%mm2\n"\
@@ -806,7 +1129,7 @@ static int vsad_intra16_mmx(void *v, uint8_t * pix, uint8_t * dummy, int line_si
       "pxor %%mm7,%%mm7\n"
       "movq (%0),%%mm0\n"
       "movq 8(%0),%%mm1\n"
-      "addl %2,%0\n"
+      "add %2,%0\n"
       "subl $2, %%ecx\n"
       SUM(%%mm0, %%mm1, %%mm4, %%mm5)
       "1:\n"
@@ -826,7 +1149,7 @@ static int vsad_intra16_mmx(void *v, uint8_t * pix, uint8_t * dummy, int line_si
       "paddw %%mm6,%%mm0\n"
       "movd %%mm0,%1\n"
       : "+r" (pix), "=r"(tmp) 
-      : "r" (line_size) , "m" (h)
+      : "r" ((long)line_size) , "m" (h)
       : "%ecx");
     return tmp & 0xFFFF;
 }
@@ -841,7 +1164,7 @@ static int vsad_intra16_mmx2(void *v, uint8_t * pix, uint8_t * dummy, int line_s
 #define SUM(in0, in1, out0, out1) \
       "movq (%0), " #out0 "\n"\
       "movq 8(%0), " #out1 "\n"\
-      "addl %2,%0\n"\
+      "add %2,%0\n"\
       "psadbw " #out0 ", " #in0 "\n"\
       "psadbw " #out1 ", " #in1 "\n"\
       "paddw " #in1 ", " #in0 "\n"\
@@ -853,7 +1176,7 @@ static int vsad_intra16_mmx2(void *v, uint8_t * pix, uint8_t * dummy, int line_s
       "pxor %%mm7,%%mm7\n"
       "movq (%0),%%mm0\n"
       "movq 8(%0),%%mm1\n"
-      "addl %2,%0\n"
+      "add %2,%0\n"
       "subl $2, %%ecx\n"
       SUM(%%mm0, %%mm1, %%mm4, %%mm5)
       "1:\n"
@@ -867,7 +1190,7 @@ static int vsad_intra16_mmx2(void *v, uint8_t * pix, uint8_t * dummy, int line_s
 
       "movd %%mm6,%1\n"
       : "+r" (pix), "=r"(tmp) 
-      : "r" (line_size) , "m" (h)
+      : "r" ((long)line_size) , "m" (h)
       : "%ecx");
     return tmp;
 }
@@ -885,8 +1208,8 @@ static int vsad16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, in
       "movq (%1)," #out0 "\n"\
       "movq 8(%0),%%mm3\n"\
       "movq 8(%1)," #out1 "\n"\
-      "addl %3,%0\n"\
-      "addl %3,%1\n"\
+      "add %3,%0\n"\
+      "add %3,%1\n"\
       "psubb " #out0 ", %%mm2\n"\
       "psubb " #out1 ", %%mm3\n"\
       "pxor %%mm7, %%mm2\n"\
@@ -921,8 +1244,8 @@ static int vsad16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, in
       "movq (%1),%%mm2\n"
       "movq 8(%0),%%mm1\n"
       "movq 8(%1),%%mm3\n"
-      "addl %3,%0\n"
-      "addl %3,%1\n"
+      "add %3,%0\n"
+      "add %3,%1\n"
       "subl $2, %%ecx\n"
       "psubb %%mm2, %%mm0\n"
       "psubb %%mm3, %%mm1\n"
@@ -946,7 +1269,7 @@ static int vsad16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, in
       "paddw %%mm6,%%mm0\n"
       "movd %%mm0,%2\n"
       : "+r" (pix1), "+r" (pix2), "=r"(tmp) 
-      : "r" (line_size) , "m" (h)
+      : "r" ((long)line_size) , "m" (h)
       : "%ecx");
     return tmp & 0x7FFF;
 }
@@ -964,8 +1287,8 @@ static int vsad16_mmx2(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, i
       "movq (%1),%%mm2\n"\
       "movq 8(%0)," #out1 "\n"\
       "movq 8(%1),%%mm3\n"\
-      "addl %3,%0\n"\
-      "addl %3,%1\n"\
+      "add %3,%0\n"\
+      "add %3,%1\n"\
       "psubb %%mm2, " #out0 "\n"\
       "psubb %%mm3, " #out1 "\n"\
       "pxor %%mm7, " #out0 "\n"\
@@ -985,8 +1308,8 @@ static int vsad16_mmx2(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, i
       "movq (%1),%%mm2\n"
       "movq 8(%0),%%mm1\n"
       "movq 8(%1),%%mm3\n"
-      "addl %3,%0\n"
-      "addl %3,%1\n"
+      "add %3,%0\n"
+      "add %3,%1\n"
       "subl $2, %%ecx\n"
       "psubb %%mm2, %%mm0\n"
       "psubb %%mm3, %%mm1\n"
@@ -1004,14 +1327,14 @@ static int vsad16_mmx2(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, i
 
       "movd %%mm6,%2\n"
       : "+r" (pix1), "+r" (pix2), "=r"(tmp) 
-      : "r" (line_size) , "m" (h)
+      : "r" ((long)line_size) , "m" (h)
       : "%ecx");
     return tmp;
 }
 #undef SUM
 
 static void diff_bytes_mmx(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
-    int i=0;
+    long i=0;
     asm volatile(
         "1:				\n\t"
         "movq  (%2, %0), %%mm0		\n\t"
@@ -1022,20 +1345,20 @@ static void diff_bytes_mmx(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
         "movq 8(%1, %0), %%mm1		\n\t"
         "psubb %%mm0, %%mm1		\n\t"
         "movq %%mm1, 8(%3, %0)		\n\t"
-        "addl $16, %0			\n\t"
-        "cmpl %4, %0			\n\t"
+        "add $16, %0			\n\t"
+        "cmp %4, %0			\n\t"
         " jb 1b				\n\t"
         : "+r" (i)
-        : "r"(src1), "r"(src2), "r"(dst), "r"(w-15)
+        : "r"(src1), "r"(src2), "r"(dst), "r"((long)w-15)
     );
     for(; i<w; i++)
         dst[i+0] = src1[i+0]-src2[i+0];
 }
 
 static void sub_hfyu_median_prediction_mmx2(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
-    int i=0;
+    long i=0;
     uint8_t l, lt;
-
+    
     asm volatile(
         "1:				\n\t"
         "movq  -1(%1, %0), %%mm0	\n\t" // LT
@@ -1052,11 +1375,11 @@ static void sub_hfyu_median_prediction_mmx2(uint8_t *dst, uint8_t *src1, uint8_t
         "pmaxub %%mm1, %%mm4		\n\t"
         "psubb %%mm4, %%mm3		\n\t" // dst - pred
         "movq %%mm3, (%3, %0)		\n\t"
-        "addl $8, %0			\n\t"
-        "cmpl %4, %0			\n\t"
+        "add $8, %0			\n\t"
+        "cmp %4, %0			\n\t"
         " jb 1b				\n\t"
         : "+r" (i)
-        : "r"(src1), "r"(src2), "r"(dst), "r"(w)
+        : "r"(src1), "r"(src2), "r"(dst), "r"((long)w)
     );
 
     l= *left;
@@ -1445,12 +1768,12 @@ static void OPNAME ## mpeg4_qpel16_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, in
         "packuswb %%mm4, %%mm0		\n\t"\
         OP_MMX2(%%mm0, 8(%1), %%mm4, q)\
         \
-        "addl %3, %0			\n\t"\
-        "addl %4, %1			\n\t"\
+        "add %3, %0			\n\t"\
+        "add %4, %1			\n\t"\
         "decl %2			\n\t"\
         " jnz 1b				\n\t"\
         : "+a"(src), "+c"(dst), "+m"(h)\
-        : "d"(srcStride), "S"(dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
+        : "d"((long)srcStride), "S"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
         : "memory"\
     );\
 }\
@@ -1558,12 +1881,12 @@ static void OPNAME ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int
         "packuswb %%mm3, %%mm0		\n\t"\
         OP_MMX2(%%mm0, (%1), %%mm4, q)\
         \
-        "addl %3, %0			\n\t"\
-        "addl %4, %1			\n\t"\
+        "add %3, %0			\n\t"\
+        "add %4, %1			\n\t"\
         "decl %2			\n\t"\
         " jnz 1b			\n\t"\
         : "+a"(src), "+c"(dst), "+m"(h)\
-        : "S"(srcStride), "D"(dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
+        : "S"((long)srcStride), "D"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
         : "memory"\
     );\
 }\
@@ -1622,12 +1945,12 @@ static void OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src,
         "movq %%mm1, 17*8(%1)		\n\t"\
         "movq %%mm2, 2*17*8(%1)		\n\t"\
         "movq %%mm3, 3*17*8(%1)		\n\t"\
-        "addl $8, %1			\n\t"\
-        "addl %3, %0			\n\t"\
+        "add $8, %1			\n\t"\
+        "add %3, %0			\n\t"\
         "decl %2			\n\t"\
         " jnz 1b			\n\t"\
         : "+r" (src), "+r" (temp_ptr), "+r"(count)\
-        : "r" (srcStride)\
+        : "r" ((long)srcStride)\
         : "memory"\
     );\
     \
@@ -1644,43 +1967,43 @@ static void OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src,
         "movq 24(%0), %%mm3		\n\t"\
         QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0),  8(%0),   (%0), 32(%0), (%1), OP)\
         QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5,  8(%0),   (%0),   (%0), 40(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5,   (%0),   (%0),  8(%0), 48(%0), (%1), OP)\
         \
         QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5,   (%0),  8(%0), 16(%0), 56(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5,  8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
         QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 72(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 80(%0), (%1), OP)\
         QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 88(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 40(%0), 48(%0), 56(%0), 96(%0), (%1), OP)\
         QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 48(%0), 56(%0), 64(%0),104(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 56(%0), 64(%0), 72(%0),112(%0), (%1), OP)\
         QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 64(%0), 72(%0), 80(%0),120(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 72(%0), 80(%0), 88(%0),128(%0), (%1), OP)\
         \
         QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 80(%0), 88(%0), 96(%0),128(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"  \
+        "add %4, %1			\n\t"  \
         QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 88(%0), 96(%0),104(%0),120(%0), (%1), OP)\
         QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 96(%0),104(%0),112(%0),112(%0), (%1, %3), OP)\
         \
-        "addl $136, %0			\n\t"\
-        "addl %6, %1			\n\t"\
+        "add $136, %0			\n\t"\
+        "add %6, %1			\n\t"\
         "decl %2			\n\t"\
         " jnz 1b			\n\t"\
         \
         : "+r"(temp_ptr), "+r"(dst), "+g"(count)\
-        : "r"(dstStride), "r"(2*dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER), "g"(4-14*dstStride)\
+        : "r"((long)dstStride), "r"(2*(long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER), "g"(4-14*(long)dstStride)\
         :"memory"\
     );\
 }\
 \
 static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
-    uint64_t temp[9*4];\
+    uint64_t temp[9*2];\
     uint64_t *temp_ptr= temp;\
     int count= 9;\
 \
@@ -1694,12 +2017,12 @@ static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src,
         "punpckhbw %%mm7, %%mm1		\n\t"\
         "movq %%mm0, (%1)		\n\t"\
         "movq %%mm1, 9*8(%1)		\n\t"\
-        "addl $8, %1			\n\t"\
-        "addl %3, %0			\n\t"\
+        "add $8, %1			\n\t"\
+        "add %3, %0			\n\t"\
         "decl %2			\n\t"\
         " jnz 1b			\n\t"\
         : "+r" (src), "+r" (temp_ptr), "+r"(count)\
-        : "r" (srcStride)\
+        : "r" ((long)srcStride)\
         : "memory"\
     );\
     \
@@ -1716,25 +2039,25 @@ static void OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src,
         "movq 24(%0), %%mm3		\n\t"\
         QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5, 16(%0),  8(%0),   (%0), 32(%0), (%1), OP)\
         QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5,  8(%0),   (%0),   (%0), 40(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5,   (%0),   (%0),  8(%0), 48(%0), (%1), OP)\
         \
         QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5,   (%0),  8(%0), 16(%0), 56(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm0, %%mm1, %%mm2, %%mm3, %5, %6, %5,  8(%0), 16(%0), 24(%0), 64(%0), (%1), OP)\
         \
         QPEL_V_LOW(%%mm1, %%mm2, %%mm3, %%mm0, %5, %6, %5, 16(%0), 24(%0), 32(%0), 64(%0), (%1, %3), OP)\
-        "addl %4, %1			\n\t"\
+        "add %4, %1			\n\t"\
         QPEL_V_LOW(%%mm2, %%mm3, %%mm0, %%mm1, %5, %6, %5, 24(%0), 32(%0), 40(%0), 56(%0), (%1), OP)\
         QPEL_V_LOW(%%mm3, %%mm0, %%mm1, %%mm2, %5, %6, %5, 32(%0), 40(%0), 48(%0), 48(%0), (%1, %3), OP)\
                 \
-        "addl $72, %0			\n\t"\
-        "addl %6, %1			\n\t"\
+        "add $72, %0			\n\t"\
+        "add %6, %1			\n\t"\
         "decl %2			\n\t"\
         " jnz 1b			\n\t"\
          \
         : "+r"(temp_ptr), "+r"(dst), "+g"(count)\
-        : "r"(dstStride), "r"(2*dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER), "g"(4-6*dstStride)\
+        : "r"((long)dstStride), "r"(2*(long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER), "g"(4-6*(long)dstStride)\
         : "memory"\
    );\
 }\
@@ -1747,7 +2070,7 @@ static void OPNAME ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride)
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, src, half, stride, stride, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
 }\
 \
 static void OPNAME ## qpel8_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
@@ -1758,14 +2081,14 @@ static void OPNAME ## qpel8_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride)
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(half, src, 8, stride, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, src+1, half, stride, stride, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, src+1, half, stride, stride, 8);\
 }\
 \
 static void OPNAME ## qpel8_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
-    OPNAME ## pixels8_l2_mmx(dst, src, half, stride, stride, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, src, half, stride, stride, 8);\
 }\
 \
 static void OPNAME ## qpel8_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
@@ -1776,43 +2099,43 @@ static void OPNAME ## qpel8_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride)
     uint64_t temp[8];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(half, src, 8, stride);\
-    OPNAME ## pixels8_l2_mmx(dst, src+stride, half, stride, stride, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, src+stride, half, stride, stride, 8);\
 }\
 static void OPNAME ## qpel8_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
-    put ## RND ## pixels8_l2_mmx(halfH, src, halfH, 8, stride, 9);\
+    put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, halfH, halfHV, stride, 8, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
 }\
 static void OPNAME ## qpel8_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
-    put ## RND ## pixels8_l2_mmx(halfH, src+1, halfH, 8, stride, 9);\
+    put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, halfH, halfHV, stride, 8, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
 }\
 static void OPNAME ## qpel8_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
-    put ## RND ## pixels8_l2_mmx(halfH, src, halfH, 8, stride, 9);\
+    put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, halfH+8, halfHV, stride, 8, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
 }\
 static void OPNAME ## qpel8_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half) + 64;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
-    put ## RND ## pixels8_l2_mmx(halfH, src+1, halfH, 8, stride, 9);\
+    put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, halfH+8, halfHV, stride, 8, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
 }\
 static void OPNAME ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
@@ -1820,7 +2143,7 @@ static void OPNAME ## qpel8_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride)
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, halfH, halfHV, stride, 8, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, halfH, halfHV, stride, 8, 8);\
 }\
 static void OPNAME ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
@@ -1828,20 +2151,20 @@ static void OPNAME ## qpel8_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride)
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
     put ## RND ## mpeg4_qpel8_v_lowpass_ ## MMX(halfHV, halfH, 8, 8);\
-    OPNAME ## pixels8_l2_mmx(dst, halfH+8, halfHV, stride, 8, 8);\
+    OPNAME ## pixels8_l2_ ## MMX(dst, halfH+8, halfHV, stride, 8, 8);\
 }\
 static void OPNAME ## qpel8_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
-    put ## RND ## pixels8_l2_mmx(halfH, src, halfH, 8, stride, 9);\
+    put ## RND ## pixels8_l2_ ## MMX(halfH, src, halfH, 8, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
 }\
 static void OPNAME ## qpel8_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[8 + 9];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel8_h_lowpass_ ## MMX(halfH, src, 8, stride, 9);\
-    put ## RND ## pixels8_l2_mmx(halfH, src+1, halfH, 8, stride, 9);\
+    put ## RND ## pixels8_l2_ ## MMX(halfH, src+1, halfH, 8, stride, 9);\
     OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
 }\
 static void OPNAME ## qpel8_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
@@ -1858,7 +2181,7 @@ static void OPNAME ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, src, half, stride, stride, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
 }\
 \
 static void OPNAME ## qpel16_mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
@@ -1869,14 +2192,14 @@ static void OPNAME ## qpel16_mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(half, src, 16, stride, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, src+1, half, stride, stride, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, src+1, half, stride, stride, 16);\
 }\
 \
 static void OPNAME ## qpel16_mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
-    OPNAME ## pixels16_l2_mmx(dst, src, half, stride, stride, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, src, half, stride, stride, 16);\
 }\
 \
 static void OPNAME ## qpel16_mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
@@ -1887,43 +2210,43 @@ static void OPNAME ## qpel16_mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride
     uint64_t temp[32];\
     uint8_t * const half= (uint8_t*)temp;\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(half, src, 16, stride);\
-    OPNAME ## pixels16_l2_mmx(dst, src+stride, half, stride, stride, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, src+stride, half, stride, stride, 16);\
 }\
 static void OPNAME ## qpel16_mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
-    put ## RND ## pixels16_l2_mmx(halfH, src, halfH, 16, stride, 17);\
+    put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, halfH, halfHV, stride, 16, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
 }\
 static void OPNAME ## qpel16_mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
-    put ## RND ## pixels16_l2_mmx(halfH, src+1, halfH, 16, stride, 17);\
+    put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, halfH, halfHV, stride, 16, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
 }\
 static void OPNAME ## qpel16_mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
-    put ## RND ## pixels16_l2_mmx(halfH, src, halfH, 16, stride, 17);\
+    put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, halfH+16, halfHV, stride, 16, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
 }\
 static void OPNAME ## qpel16_mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
     uint8_t * const halfH= ((uint8_t*)half) + 256;\
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
-    put ## RND ## pixels16_l2_mmx(halfH, src+1, halfH, 16, stride, 17);\
+    put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, halfH+16, halfHV, stride, 16, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
 }\
 static void OPNAME ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
@@ -1931,7 +2254,7 @@ static void OPNAME ## qpel16_mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, halfH, halfHV, stride, 16, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, halfH, halfHV, stride, 16, 16);\
 }\
 static void OPNAME ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[16*2 + 17*2];\
@@ -1939,20 +2262,20 @@ static void OPNAME ## qpel16_mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride
     uint8_t * const halfHV= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
     put ## RND ## mpeg4_qpel16_v_lowpass_ ## MMX(halfHV, halfH, 16, 16);\
-    OPNAME ## pixels16_l2_mmx(dst, halfH+16, halfHV, stride, 16, 16);\
+    OPNAME ## pixels16_l2_ ## MMX(dst, halfH+16, halfHV, stride, 16, 16);\
 }\
 static void OPNAME ## qpel16_mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[17*2];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
-    put ## RND ## pixels16_l2_mmx(halfH, src, halfH, 16, stride, 17);\
+    put ## RND ## pixels16_l2_ ## MMX(halfH, src, halfH, 16, stride, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
 }\
 static void OPNAME ## qpel16_mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
     uint64_t half[17*2];\
     uint8_t * const halfH= ((uint8_t*)half);\
     put ## RND ## mpeg4_qpel16_h_lowpass_ ## MMX(halfH, src, 16, stride, 17);\
-    put ## RND ## pixels16_l2_mmx(halfH, src+1, halfH, 16, stride, 17);\
+    put ## RND ## pixels16_l2_ ## MMX(halfH, src+1, halfH, 16, stride, 17);\
     OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
 }\
 static void OPNAME ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
@@ -1962,6 +2285,499 @@ static void OPNAME ## qpel16_mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride
     OPNAME ## mpeg4_qpel16_v_lowpass_ ## MMX(dst, halfH, stride, 16);\
 }
 
+#define QPEL_H264V(A,B,C,D,E,F,OP)\
+        "movd (%0), "#F"		\n\t"\
+        "movq "#C", %%mm6		\n\t"\
+        "paddw "#D", %%mm6		\n\t"\
+        "psllw $2, %%mm6		\n\t"\
+        "psubw "#B", %%mm6		\n\t"\
+        "psubw "#E", %%mm6		\n\t"\
+        "pmullw %4, %%mm6		\n\t"\
+        "add %2, %0			\n\t"\
+        "punpcklbw %%mm7, "#F"		\n\t"\
+        "paddw %5, "#A"			\n\t"\
+        "paddw "#F", "#A"		\n\t"\
+        "paddw "#A", %%mm6		\n\t"\
+        "psraw $5, %%mm6		\n\t"\
+        "packuswb %%mm6, %%mm6		\n\t"\
+        OP(%%mm6, (%1), A, d)\
+        "add %3, %1			\n\t"     
+
+#define QPEL_H264HV(A,B,C,D,E,F,OF)\
+        "movd (%0), "#F"		\n\t"\
+        "movq "#C", %%mm6		\n\t"\
+        "paddw "#D", %%mm6		\n\t"\
+        "psllw $2, %%mm6		\n\t"\
+        "psubw "#B", %%mm6		\n\t"\
+        "psubw "#E", %%mm6		\n\t"\
+        "pmullw %3, %%mm6		\n\t"\
+        "add %2, %0			\n\t"\
+        "punpcklbw %%mm7, "#F"		\n\t"\
+        "paddw "#F", "#A"		\n\t"\
+        "paddw "#A", %%mm6		\n\t"\
+        "movq %%mm6, "#OF"(%1)		\n\t"
+        
+#define QPEL_H264(OPNAME, OP, MMX)\
+static void OPNAME ## h264_qpel4_h_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    int h=4;\
+\
+    asm volatile(\
+        "pxor %%mm7, %%mm7		\n\t"\
+        "movq %5, %%mm4			\n\t"\
+        "movq %6, %%mm5			\n\t"\
+        "1:				\n\t"\
+        "movd  -1(%0), %%mm1		\n\t"\
+        "movd    (%0), %%mm2		\n\t"\
+        "movd   1(%0), %%mm3		\n\t"\
+        "movd   2(%0), %%mm0		\n\t"\
+        "punpcklbw %%mm7, %%mm1		\n\t"\
+        "punpcklbw %%mm7, %%mm2		\n\t"\
+        "punpcklbw %%mm7, %%mm3		\n\t"\
+        "punpcklbw %%mm7, %%mm0		\n\t"\
+        "paddw %%mm0, %%mm1		\n\t"\
+        "paddw %%mm3, %%mm2		\n\t"\
+        "movd  -2(%0), %%mm0		\n\t"\
+        "movd   3(%0), %%mm3		\n\t"\
+        "punpcklbw %%mm7, %%mm0		\n\t"\
+        "punpcklbw %%mm7, %%mm3		\n\t"\
+        "paddw %%mm3, %%mm0		\n\t"\
+        "psllw $2, %%mm2		\n\t"\
+        "psubw %%mm1, %%mm2		\n\t"\
+        "pmullw %%mm4, %%mm2		\n\t"\
+        "paddw %%mm5, %%mm0		\n\t"\
+        "paddw %%mm2, %%mm0		\n\t"\
+        "psraw $5, %%mm0		\n\t"\
+        "packuswb %%mm0, %%mm0		\n\t"\
+        OP(%%mm0, (%1),%%mm6, d)\
+        "add %3, %0			\n\t"\
+        "add %4, %1			\n\t"\
+        "decl %2			\n\t"\
+        " jnz 1b			\n\t"\
+        : "+a"(src), "+c"(dst), "+m"(h)\
+        : "d"((long)srcStride), "S"((long)dstStride), "m"(ff_pw_5), "m"(ff_pw_16)\
+        : "memory"\
+    );\
+}\
+static void OPNAME ## h264_qpel4_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    src -= 2*srcStride;\
+    asm volatile(\
+        "pxor %%mm7, %%mm7		\n\t"\
+        "movd (%0), %%mm0		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm1		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm2		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm3		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm4		\n\t"\
+        "add %2, %0			\n\t"\
+        "punpcklbw %%mm7, %%mm0		\n\t"\
+        "punpcklbw %%mm7, %%mm1		\n\t"\
+        "punpcklbw %%mm7, %%mm2		\n\t"\
+        "punpcklbw %%mm7, %%mm3		\n\t"\
+        "punpcklbw %%mm7, %%mm4		\n\t"\
+        QPEL_H264V(%%mm0, %%mm1, %%mm2, %%mm3, %%mm4, %%mm5, OP)\
+        QPEL_H264V(%%mm1, %%mm2, %%mm3, %%mm4, %%mm5, %%mm0, OP)\
+        QPEL_H264V(%%mm2, %%mm3, %%mm4, %%mm5, %%mm0, %%mm1, OP)\
+        QPEL_H264V(%%mm3, %%mm4, %%mm5, %%mm0, %%mm1, %%mm2, OP)\
+         \
+        : "+a"(src), "+c"(dst)\
+        : "S"((long)srcStride), "D"((long)dstStride), "m"(ff_pw_5), "m"(ff_pw_16)\
+        : "memory"\
+    );\
+}\
+static void OPNAME ## h264_qpel4_hv_lowpass_ ## MMX(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
+    int h=4;\
+    int w=3;\
+    src -= 2*srcStride+2;\
+    while(w--){\
+        asm volatile(\
+            "pxor %%mm7, %%mm7			\n\t"\
+            "movd (%0), %%mm0			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm1			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm2			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm3			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm4			\n\t"\
+            "add %2, %0				\n\t"\
+            "punpcklbw %%mm7, %%mm0		\n\t"\
+            "punpcklbw %%mm7, %%mm1		\n\t"\
+            "punpcklbw %%mm7, %%mm2		\n\t"\
+            "punpcklbw %%mm7, %%mm3		\n\t"\
+            "punpcklbw %%mm7, %%mm4		\n\t"\
+            QPEL_H264HV(%%mm0, %%mm1, %%mm2, %%mm3, %%mm4, %%mm5, 0*8*3)\
+            QPEL_H264HV(%%mm1, %%mm2, %%mm3, %%mm4, %%mm5, %%mm0, 1*8*3)\
+            QPEL_H264HV(%%mm2, %%mm3, %%mm4, %%mm5, %%mm0, %%mm1, 2*8*3)\
+            QPEL_H264HV(%%mm3, %%mm4, %%mm5, %%mm0, %%mm1, %%mm2, 3*8*3)\
+             \
+            : "+a"(src)\
+            : "c"(tmp), "S"((long)srcStride), "m"(ff_pw_5)\
+            : "memory"\
+        );\
+        tmp += 4;\
+        src += 4 - 9*srcStride;\
+    }\
+    tmp -= 3*4;\
+    asm volatile(\
+        "movq %4, %%mm6			\n\t"\
+        "1:				\n\t"\
+        "movq     (%0), %%mm0		\n\t"\
+        "paddw  10(%0), %%mm0		\n\t"\
+        "movq    2(%0), %%mm1		\n\t"\
+        "paddw   8(%0), %%mm1		\n\t"\
+        "movq    4(%0), %%mm2		\n\t"\
+        "paddw   6(%0), %%mm2		\n\t"\
+        "psubw %%mm1, %%mm0		\n\t"/*a-b   (abccba)*/\
+        "psraw $2, %%mm0		\n\t"/*(a-b)/4 */\
+        "psubw %%mm1, %%mm0		\n\t"/*(a-b)/4-b */\
+        "paddsw %%mm2, %%mm0		\n\t"\
+        "psraw $2, %%mm0		\n\t"/*((a-b)/4-b)/4 */\
+        "paddw %%mm6, %%mm2		\n\t"\
+        "paddw %%mm2, %%mm0		\n\t"\
+        "psraw $6, %%mm0		\n\t"\
+        "packuswb %%mm0, %%mm0		\n\t"\
+        OP(%%mm0, (%1),%%mm7, d)\
+        "add $24, %0			\n\t"\
+        "add %3, %1			\n\t"\
+        "decl %2			\n\t"\
+        " jnz 1b			\n\t"\
+        : "+a"(tmp), "+c"(dst), "+m"(h)\
+        : "S"((long)dstStride), "m"(ff_pw_32)\
+        : "memory"\
+    );\
+}\
+\
+static void OPNAME ## h264_qpel8_h_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    int h=8;\
+    asm volatile(\
+        "pxor %%mm7, %%mm7		\n\t"\
+        "movq %5, %%mm6			\n\t"\
+        "1:				\n\t"\
+        "movq    (%0), %%mm0		\n\t"\
+        "movq   1(%0), %%mm2		\n\t"\
+        "movq %%mm0, %%mm1		\n\t"\
+        "movq %%mm2, %%mm3		\n\t"\
+        "punpcklbw %%mm7, %%mm0		\n\t"\
+        "punpckhbw %%mm7, %%mm1		\n\t"\
+        "punpcklbw %%mm7, %%mm2		\n\t"\
+        "punpckhbw %%mm7, %%mm3		\n\t"\
+        "paddw %%mm2, %%mm0		\n\t"\
+        "paddw %%mm3, %%mm1		\n\t"\
+        "psllw $2, %%mm0		\n\t"\
+        "psllw $2, %%mm1		\n\t"\
+        "movq   -1(%0), %%mm2		\n\t"\
+        "movq    2(%0), %%mm4		\n\t"\
+        "movq %%mm2, %%mm3		\n\t"\
+        "movq %%mm4, %%mm5		\n\t"\
+        "punpcklbw %%mm7, %%mm2		\n\t"\
+        "punpckhbw %%mm7, %%mm3		\n\t"\
+        "punpcklbw %%mm7, %%mm4		\n\t"\
+        "punpckhbw %%mm7, %%mm5		\n\t"\
+        "paddw %%mm4, %%mm2		\n\t"\
+        "paddw %%mm3, %%mm5		\n\t"\
+        "psubw %%mm2, %%mm0		\n\t"\
+        "psubw %%mm5, %%mm1		\n\t"\
+        "pmullw %%mm6, %%mm0		\n\t"\
+        "pmullw %%mm6, %%mm1		\n\t"\
+        "movd   -2(%0), %%mm2		\n\t"\
+        "movd    7(%0), %%mm5		\n\t"\
+        "punpcklbw %%mm7, %%mm2		\n\t"\
+        "punpcklbw %%mm7, %%mm5		\n\t"\
+        "paddw %%mm3, %%mm2		\n\t"\
+        "paddw %%mm5, %%mm4		\n\t"\
+        "movq %6, %%mm5			\n\t"\
+        "paddw %%mm5, %%mm2		\n\t"\
+        "paddw %%mm5, %%mm4		\n\t"\
+        "paddw %%mm2, %%mm0		\n\t"\
+        "paddw %%mm4, %%mm1		\n\t"\
+        "psraw $5, %%mm0		\n\t"\
+        "psraw $5, %%mm1		\n\t"\
+        "packuswb %%mm1, %%mm0		\n\t"\
+        OP(%%mm0, (%1),%%mm5, q)\
+        "add %3, %0			\n\t"\
+        "add %4, %1			\n\t"\
+        "decl %2			\n\t"\
+        " jnz 1b			\n\t"\
+        : "+a"(src), "+c"(dst), "+m"(h)\
+        : "d"((long)srcStride), "S"((long)dstStride), "m"(ff_pw_5), "m"(ff_pw_16)\
+        : "memory"\
+    );\
+}\
+\
+static void OPNAME ## h264_qpel8_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    int h= 2;\
+    src -= 2*srcStride;\
+    \
+    while(h--){\
+      asm volatile(\
+        "pxor %%mm7, %%mm7		\n\t"\
+        "movd (%0), %%mm0		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm1		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm2		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm3		\n\t"\
+        "add %2, %0			\n\t"\
+        "movd (%0), %%mm4		\n\t"\
+        "add %2, %0			\n\t"\
+        "punpcklbw %%mm7, %%mm0		\n\t"\
+        "punpcklbw %%mm7, %%mm1		\n\t"\
+        "punpcklbw %%mm7, %%mm2		\n\t"\
+        "punpcklbw %%mm7, %%mm3		\n\t"\
+        "punpcklbw %%mm7, %%mm4		\n\t"\
+        QPEL_H264V(%%mm0, %%mm1, %%mm2, %%mm3, %%mm4, %%mm5, OP)\
+        QPEL_H264V(%%mm1, %%mm2, %%mm3, %%mm4, %%mm5, %%mm0, OP)\
+        QPEL_H264V(%%mm2, %%mm3, %%mm4, %%mm5, %%mm0, %%mm1, OP)\
+        QPEL_H264V(%%mm3, %%mm4, %%mm5, %%mm0, %%mm1, %%mm2, OP)\
+        QPEL_H264V(%%mm4, %%mm5, %%mm0, %%mm1, %%mm2, %%mm3, OP)\
+        QPEL_H264V(%%mm5, %%mm0, %%mm1, %%mm2, %%mm3, %%mm4, OP)\
+        QPEL_H264V(%%mm0, %%mm1, %%mm2, %%mm3, %%mm4, %%mm5, OP)\
+        QPEL_H264V(%%mm1, %%mm2, %%mm3, %%mm4, %%mm5, %%mm0, OP)\
+         \
+        : "+a"(src), "+c"(dst)\
+        : "S"((long)srcStride), "D"((long)dstStride), "m"(ff_pw_5), "m"(ff_pw_16)\
+        : "memory"\
+     );\
+     src += 4-13*srcStride;\
+     dst +=  4-8*dstStride;\
+   }\
+}\
+static void OPNAME ## h264_qpel8_hv_lowpass_ ## MMX(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
+    int h=8;\
+    int w=4;\
+    src -= 2*srcStride+2;\
+    while(w--){\
+        asm volatile(\
+            "pxor %%mm7, %%mm7			\n\t"\
+            "movd (%0), %%mm0			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm1			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm2			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm3			\n\t"\
+            "add %2, %0				\n\t"\
+            "movd (%0), %%mm4			\n\t"\
+            "add %2, %0				\n\t"\
+            "punpcklbw %%mm7, %%mm0		\n\t"\
+            "punpcklbw %%mm7, %%mm1		\n\t"\
+            "punpcklbw %%mm7, %%mm2		\n\t"\
+            "punpcklbw %%mm7, %%mm3		\n\t"\
+            "punpcklbw %%mm7, %%mm4		\n\t"\
+            QPEL_H264HV(%%mm0, %%mm1, %%mm2, %%mm3, %%mm4, %%mm5, 0*8*4)\
+            QPEL_H264HV(%%mm1, %%mm2, %%mm3, %%mm4, %%mm5, %%mm0, 1*8*4)\
+            QPEL_H264HV(%%mm2, %%mm3, %%mm4, %%mm5, %%mm0, %%mm1, 2*8*4)\
+            QPEL_H264HV(%%mm3, %%mm4, %%mm5, %%mm0, %%mm1, %%mm2, 3*8*4)\
+            QPEL_H264HV(%%mm4, %%mm5, %%mm0, %%mm1, %%mm2, %%mm3, 4*8*4)\
+            QPEL_H264HV(%%mm5, %%mm0, %%mm1, %%mm2, %%mm3, %%mm4, 5*8*4)\
+            QPEL_H264HV(%%mm0, %%mm1, %%mm2, %%mm3, %%mm4, %%mm5, 6*8*4)\
+            QPEL_H264HV(%%mm1, %%mm2, %%mm3, %%mm4, %%mm5, %%mm0, 7*8*4)\
+             \
+            : "+a"(src)\
+            : "c"(tmp), "S"((long)srcStride), "m"(ff_pw_5)\
+            : "memory"\
+        );\
+        tmp += 4;\
+        src += 4 - 13*srcStride;\
+    }\
+    tmp -= 4*4;\
+    asm volatile(\
+        "movq %4, %%mm6			\n\t"\
+        "1:				\n\t"\
+        "movq     (%0), %%mm0		\n\t"\
+        "movq    8(%0), %%mm3		\n\t"\
+        "movq    2(%0), %%mm1		\n\t"\
+        "movq   10(%0), %%mm4		\n\t"\
+        "paddw   %%mm4, %%mm0		\n\t"\
+        "paddw   %%mm3, %%mm1		\n\t"\
+        "paddw  18(%0), %%mm3		\n\t"\
+        "paddw  16(%0), %%mm4		\n\t"\
+        "movq    4(%0), %%mm2		\n\t"\
+        "movq   12(%0), %%mm5		\n\t"\
+        "paddw   6(%0), %%mm2		\n\t"\
+        "paddw  14(%0), %%mm5		\n\t"\
+        "psubw %%mm1, %%mm0		\n\t"\
+        "psubw %%mm4, %%mm3		\n\t"\
+        "psraw $2, %%mm0		\n\t"\
+        "psraw $2, %%mm3		\n\t"\
+        "psubw %%mm1, %%mm0		\n\t"\
+        "psubw %%mm4, %%mm3		\n\t"\
+        "paddsw %%mm2, %%mm0		\n\t"\
+        "paddsw %%mm5, %%mm3		\n\t"\
+        "psraw $2, %%mm0		\n\t"\
+        "psraw $2, %%mm3		\n\t"\
+        "paddw %%mm6, %%mm2		\n\t"\
+        "paddw %%mm6, %%mm5		\n\t"\
+        "paddw %%mm2, %%mm0		\n\t"\
+        "paddw %%mm5, %%mm3		\n\t"\
+        "psraw $6, %%mm0		\n\t"\
+        "psraw $6, %%mm3		\n\t"\
+        "packuswb %%mm3, %%mm0		\n\t"\
+        OP(%%mm0, (%1),%%mm7, q)\
+        "add $32, %0			\n\t"\
+        "add %3, %1			\n\t"\
+        "decl %2			\n\t"\
+        " jnz 1b			\n\t"\
+        : "+a"(tmp), "+c"(dst), "+m"(h)\
+        : "S"((long)dstStride), "m"(ff_pw_32)\
+        : "memory"\
+    );\
+}\
+static void OPNAME ## h264_qpel16_v_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    OPNAME ## h264_qpel8_v_lowpass_ ## MMX(dst  , src  , dstStride, srcStride);\
+    OPNAME ## h264_qpel8_v_lowpass_ ## MMX(dst+8, src+8, dstStride, srcStride);\
+    src += 8*srcStride;\
+    dst += 8*dstStride;\
+    OPNAME ## h264_qpel8_v_lowpass_ ## MMX(dst  , src  , dstStride, srcStride);\
+    OPNAME ## h264_qpel8_v_lowpass_ ## MMX(dst+8, src+8, dstStride, srcStride);\
+}\
+\
+static void OPNAME ## h264_qpel16_h_lowpass_ ## MMX(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
+    OPNAME ## h264_qpel8_h_lowpass_ ## MMX(dst  , src  , dstStride, srcStride);\
+    OPNAME ## h264_qpel8_h_lowpass_ ## MMX(dst+8, src+8, dstStride, srcStride);\
+    src += 8*srcStride;\
+    dst += 8*dstStride;\
+    OPNAME ## h264_qpel8_h_lowpass_ ## MMX(dst  , src  , dstStride, srcStride);\
+    OPNAME ## h264_qpel8_h_lowpass_ ## MMX(dst+8, src+8, dstStride, srcStride);\
+}\
+\
+static void OPNAME ## h264_qpel16_hv_lowpass_ ## MMX(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
+    OPNAME ## h264_qpel8_hv_lowpass_ ## MMX(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
+    OPNAME ## h264_qpel8_hv_lowpass_ ## MMX(dst+8, tmp  , src+8, dstStride, tmpStride, srcStride);\
+    src += 8*srcStride;\
+    dst += 8*dstStride;\
+    OPNAME ## h264_qpel8_hv_lowpass_ ## MMX(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
+    OPNAME ## h264_qpel8_hv_lowpass_ ## MMX(dst+8, tmp  , src+8, dstStride, tmpStride, srcStride);\
+}\
+
+#define H264_MC(OPNAME, SIZE, MMX) \
+static void OPNAME ## h264_qpel ## SIZE ## _mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
+    OPNAME ## pixels ## SIZE ## _mmx(dst, src, stride, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/8];\
+    uint8_t * const half= (uint8_t*)temp;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(half, src, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, src, half, stride, stride, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc20_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    OPNAME ## h264_qpel ## SIZE ## _h_lowpass_ ## MMX(dst, src, stride, stride);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc30_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/8];\
+    uint8_t * const half= (uint8_t*)temp;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(half, src, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, src+1, half, stride, stride, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc01_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/8];\
+    uint8_t * const half= (uint8_t*)temp;\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(half, src, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, src, half, stride, stride, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc02_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    OPNAME ## h264_qpel ## SIZE ## _v_lowpass_ ## MMX(dst, src, stride, stride);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc03_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/8];\
+    uint8_t * const half= (uint8_t*)temp;\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(half, src, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, src+stride, half, stride, stride, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc11_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/4];\
+    uint8_t * const halfH= (uint8_t*)temp;\
+    uint8_t * const halfV= ((uint8_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(halfH, src, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(halfV, src, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfH, halfV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc31_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/4];\
+    uint8_t * const halfH= (uint8_t*)temp;\
+    uint8_t * const halfV= ((uint8_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(halfH, src, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(halfV, src+1, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfH, halfV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc13_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/4];\
+    uint8_t * const halfH= (uint8_t*)temp;\
+    uint8_t * const halfV= ((uint8_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(halfH, src + stride, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(halfV, src, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfH, halfV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc33_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*SIZE/4];\
+    uint8_t * const halfH= (uint8_t*)temp;\
+    uint8_t * const halfV= ((uint8_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(halfH, src + stride, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(halfV, src+1, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfH, halfV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc22_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*(SIZE+8)/4];\
+    int16_t * const tmp= (int16_t*)temp;\
+    OPNAME ## h264_qpel ## SIZE ## _hv_lowpass_ ## MMX(dst, tmp, src, stride, SIZE, stride);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc21_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*(SIZE+8)/4 + SIZE*SIZE/4];\
+    uint8_t * const halfH= (uint8_t*)temp;\
+    uint8_t * const halfHV= ((uint8_t*)temp) + SIZE*SIZE;\
+    int16_t * const tmp= ((int16_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(halfH, src, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _hv_lowpass_ ## MMX(halfHV, tmp, src, SIZE, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfH, halfHV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc23_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*(SIZE+8)/4 + SIZE*SIZE/4];\
+    uint8_t * const halfH= (uint8_t*)temp;\
+    uint8_t * const halfHV= ((uint8_t*)temp) + SIZE*SIZE;\
+    int16_t * const tmp= ((int16_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _h_lowpass_ ## MMX(halfH, src + stride, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _hv_lowpass_ ## MMX(halfHV, tmp, src, SIZE, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfH, halfHV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc12_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*(SIZE+8)/4 + SIZE*SIZE/4];\
+    uint8_t * const halfV= (uint8_t*)temp;\
+    uint8_t * const halfHV= ((uint8_t*)temp) + SIZE*SIZE;\
+    int16_t * const tmp= ((int16_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(halfV, src, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _hv_lowpass_ ## MMX(halfHV, tmp, src, SIZE, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfV, halfHV, stride, SIZE, SIZE);\
+}\
+\
+static void OPNAME ## h264_qpel ## SIZE ## _mc32_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
+    uint64_t temp[SIZE*(SIZE+8)/4 + SIZE*SIZE/4];\
+    uint8_t * const halfV= (uint8_t*)temp;\
+    uint8_t * const halfHV= ((uint8_t*)temp) + SIZE*SIZE;\
+    int16_t * const tmp= ((int16_t*)temp) + SIZE*SIZE;\
+    put_h264_qpel ## SIZE ## _v_lowpass_ ## MMX(halfV, src+1, SIZE, stride);\
+    put_h264_qpel ## SIZE ## _hv_lowpass_ ## MMX(halfHV, tmp, src, SIZE, SIZE, stride);\
+    OPNAME ## pixels ## SIZE ## _l2_ ## MMX(dst, halfV, halfHV, stride, SIZE, SIZE);\
+}\
+
 
 #define PUT_OP(a,b,temp, size) "mov" #size " " #a ", " #b "	\n\t"
 #define AVG_3DNOW_OP(a,b,temp, size) \
@@ -1983,6 +2799,24 @@ QPEL_OP(put_       , ff_pw_16, _       , PUT_OP, mmx2)
 QPEL_OP(avg_       , ff_pw_16, _       , AVG_MMX2_OP, mmx2)
 QPEL_OP(put_no_rnd_, ff_pw_15, _no_rnd_, PUT_OP, mmx2)
 
+QPEL_H264(put_       ,       PUT_OP, 3dnow)
+QPEL_H264(avg_       , AVG_3DNOW_OP, 3dnow)
+QPEL_H264(put_       ,       PUT_OP, mmx2)
+QPEL_H264(avg_       ,  AVG_MMX2_OP, mmx2)
+
+H264_MC(put_, 4, 3dnow)
+H264_MC(put_, 8, 3dnow)
+H264_MC(put_, 16,3dnow)
+H264_MC(avg_, 4, 3dnow)
+H264_MC(avg_, 8, 3dnow)
+H264_MC(avg_, 16,3dnow)
+H264_MC(put_, 4, mmx2)
+H264_MC(put_, 8, mmx2)
+H264_MC(put_, 16,mmx2)
+H264_MC(avg_, 4, mmx2)
+H264_MC(avg_, 8, mmx2)
+H264_MC(avg_, 16,mmx2)
+
 #if 0
 static void just_return() { return; }
 #endif
@@ -1993,7 +2827,7 @@ static void just_return() { return; }
     c->avg_ ## postfix1 = avg_ ## postfix2;
 
 static int try_8x8basis_mmx(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
-    int i=0;
+    long i=0;
     
     assert(ABS(scale) < 256);
     scale<<= 16 + 1 - BASIS_SHIFT + RECON_SHIFT;
@@ -2025,8 +2859,8 @@ static int try_8x8basis_mmx(int16_t rem[64], int16_t weight[64], int16_t basis[6
         "paddd %%mm1, %%mm0		\n\t"
         "psrld $4, %%mm0		\n\t"
         "paddd %%mm0, %%mm7		\n\t"
-        "addl $16, %0			\n\t"
-        "cmpl $128, %0			\n\t" //FIXME optimize & bench
+        "add $16, %0			\n\t"
+        "cmp $128, %0			\n\t" //FIXME optimize & bench
         " jb 1b				\n\t"
         "movq %%mm7, %%mm6		\n\t"
         "psrlq $32, %%mm7		\n\t"
@@ -2041,7 +2875,7 @@ static int try_8x8basis_mmx(int16_t rem[64], int16_t weight[64], int16_t basis[6
 }
 
 static void add_8x8basis_mmx(int16_t rem[64], int16_t basis[64], int scale){
-    int i=0;
+    long i=0;
     
     if(ABS(scale) < 256){
         scale<<= 16 + 1 - BASIS_SHIFT + RECON_SHIFT;
@@ -2064,8 +2898,8 @@ static void add_8x8basis_mmx(int16_t rem[64], int16_t basis[64], int scale){
                 "paddw 8(%2, %0), %%mm1		\n\t"
                 "movq %%mm0, (%2, %0)		\n\t"
                 "movq %%mm1, 8(%2, %0)		\n\t"
-                "addl $16, %0			\n\t"
-                "cmpl $128, %0			\n\t" //FIXME optimize & bench
+                "add $16, %0			\n\t"
+                "cmp $128, %0			\n\t" //FIXME optimize & bench
                 " jb 1b				\n\t"
                 
                 : "+r" (i)
@@ -2146,23 +2980,24 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
             }
         }
 #endif //CONFIG_ENCODERS
-
-        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;
-        }else if(idct_algo==FF_IDCT_LIBMPEG2MMX){
-            if(mm_flags & MM_MMXEXT){
-                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;
+        if(avctx->lowres==0){
+            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;
+            }else if(idct_algo==FF_IDCT_LIBMPEG2MMX){
+                if(mm_flags & MM_MMXEXT){
+                    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;
             }
-            c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
         }
 
         /* VP3 optimized DSP functions */
@@ -2235,8 +3070,11 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
         
 	c->pix_norm1 = pix_norm1_mmx;
 	c->sse[0] = sse16_mmx;
+  	c->sse[1] = sse8_mmx;
         c->vsad[4]= vsad_intra16_mmx;
 
+	c->nsse[0] = nsse16_mmx;
+	c->nsse[1] = nsse8_mmx;
         if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
             c->vsad[0] = vsad16_mmx;
         }
@@ -2319,6 +3157,33 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
             SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_mmx2)
 #endif
 
+//FIXME 3dnow too
+#define dspfunc(PFX, IDX, NUM) \
+    c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_mmx2; \
+    c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_mmx2; \
+    c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_mmx2; \
+    c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_mmx2; \
+    c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_mmx2; \
+    c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_mmx2; \
+    c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_mmx2; \
+    c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_mmx2
+
+            dspfunc(put_h264_qpel, 0, 16);
+            dspfunc(put_h264_qpel, 1, 8);
+            dspfunc(put_h264_qpel, 2, 4);
+            dspfunc(avg_h264_qpel, 0, 16);
+            dspfunc(avg_h264_qpel, 1, 8);
+            dspfunc(avg_h264_qpel, 2, 4);
+#undef dspfunc
+
 #ifdef CONFIG_ENCODERS
             c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_mmx2;
 #endif //CONFIG_ENCODERS
@@ -2378,6 +3243,31 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
             SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_3dnow)
             SET_QPEL_FUNC(qpel_pixels_tab[1][14], qpel8_mc23_3dnow)
             SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_3dnow)
+
+#define dspfunc(PFX, IDX, NUM) \
+    c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_3dnow; \
+    c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_3dnow; \
+    c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_3dnow; \
+    c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_3dnow; \
+    c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_3dnow; \
+    c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_3dnow; \
+    c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_3dnow; \
+    c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_3dnow
+
+            dspfunc(put_h264_qpel, 0, 16);
+            dspfunc(put_h264_qpel, 1, 8);
+            dspfunc(put_h264_qpel, 2, 4);
+            dspfunc(avg_h264_qpel, 0, 16);
+            dspfunc(avg_h264_qpel, 1, 8);
+            dspfunc(avg_h264_qpel, 2, 4);
         }
     }
         
diff --git a/src/libffmpeg/libavcodec/i386/dsputil_mmx_avg.h b/src/libffmpeg/libavcodec/i386/dsputil_mmx_avg.h
index 052aad75c..c70891304 100644
--- a/src/libffmpeg/libavcodec/i386/dsputil_mmx_avg.h
+++ b/src/libffmpeg/libavcodec/i386/dsputil_mmx_avg.h
@@ -28,7 +28,7 @@
 static void DEF(put_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"1:				\n\t"
 	"movq (%1), %%mm0		\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
@@ -36,59 +36,305 @@ static void DEF(put_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_
 	PAVGB" 1(%1, %3), %%mm1		\n\t"
 	"movq %%mm0, (%2)		\n\t"
 	"movq %%mm1, (%2, %3)		\n\t"
-	"addl %%eax, %1			\n\t"
-	"addl %%eax, %2			\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"
-	"addl %%eax, %1			\n\t"
+	"add %%"REG_a", %1		\n\t"
 	"movq %%mm0, (%2)		\n\t"
 	"movq %%mm1, (%2, %3)		\n\t"
-	"addl %%eax, %2			\n\t"
+	"add %%"REG_a", %2		\n\t"
 	"subl $4, %0			\n\t"
 	"jnz 1b				\n\t"
 	:"+g"(h), "+S"(pixels), "+D"(block)
-	:"r" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)line_size)
+	:"%"REG_a, "memory");
 }
 
-static __attribute__((unused)) void DEF(put_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+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"
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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"
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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"
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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"
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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"
-	"addl	%4, %1			\n\t"
+	"add	%4, %1			\n\t"
 	"movq	(%1), %%mm1		\n\t"
-	"addl	%4, %1			\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"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
+	PAVGB" (%3), %%mm1	 	\n\t"
 	"movq	%%mm1, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"movq	(%1), %%mm0		\n\t"
-	"addl	%4, %1			\n\t"
+	"add	%4, %1			\n\t"
 	"movq	(%1), %%mm1		\n\t"
-	"addl	%4, %1			\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"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
+	PAVGB" (%3), %%mm1	 	\n\t"
 	"movq	%%mm1, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
-        "addl	$32, %2			\n\t"
+	"add	%5, %3			\n\t"
+	"add	$32, %2			\n\t"
 	"subl	$4, %0			\n\t"
 	"jnz	1b			\n\t"
-	:"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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");
+	:"memory");*/
 }
 
 static void DEF(put_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"1:				\n\t"
 	"movq (%1), %%mm0		\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
@@ -102,8 +348,8 @@ static void DEF(put_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line
 	"movq %%mm1, (%2, %3)		\n\t"
 	"movq %%mm2, 8(%2)		\n\t"
 	"movq %%mm3, 8(%2, %3)		\n\t"
-	"addl %%eax, %1			\n\t"
-	"addl %%eax, %2			\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"
@@ -112,45 +358,192 @@ static void DEF(put_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line
 	PAVGB" 1(%1, %3), %%mm1		\n\t"
 	PAVGB" 9(%1), %%mm2		\n\t"
 	PAVGB" 9(%1, %3), %%mm3		\n\t"
-	"addl %%eax, %1			\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"
-	"addl %%eax, %2			\n\t"
+	"add %%"REG_a", %2		\n\t"
 	"subl $4, %0			\n\t"
 	"jnz 1b				\n\t"
 	:"+g"(h), "+S"(pixels), "+D"(block)
-	:"r" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)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"
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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 __attribute__((unused)) void DEF(put_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
+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"
-	"addl	%4, %1			\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"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"movq	(%1), %%mm0		\n\t"
 	"movq	8(%1), %%mm1		\n\t"
-	"addl	%4, %1			\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"
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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"
-	"addl	%5, %3			\n\t"
-        "addl	$32, %2			\n\t"
+	"add	%5, %3			\n\t"
+	"add	$32, %2			\n\t"
 	"subl	$2, %0			\n\t"
 	"jnz	1b			\n\t"
-	:"+g"(h), "+r"(src1), "+r"(src2), "+r"(dst)
+#ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
+	:"+m"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#else
+	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
+#endif
+	:"S"((long)src1Stride), "D"((long)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");
+	:"memory");*/
 }
  
 /* GL: this function does incorrect rounding if overflow */
@@ -158,13 +551,13 @@ static void DEF(put_no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, in
 {
     MOVQ_BONE(mm6);
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"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"
-	"addl %%eax, %1			\n\t"
+	"add %%"REG_a", %1		\n\t"
 	"psubusb %%mm6, %%mm0		\n\t"
 	"psubusb %%mm6, %%mm2		\n\t"
 	PAVGB" %%mm1, %%mm0		\n\t"
@@ -175,50 +568,50 @@ static void DEF(put_no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, in
 	"movq 1(%1), %%mm1		\n\t"
 	"movq (%1, %3), %%mm2		\n\t"
 	"movq 1(%1, %3), %%mm3		\n\t"
-	"addl %%eax, %2			\n\t"
-	"addl %%eax, %1			\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"
-	"addl %%eax, %2			\n\t"
+	"add %%"REG_a", %2		\n\t"
 	"subl $4, %0			\n\t"
 	"jnz 1b				\n\t"
 	:"+g"(h), "+S"(pixels), "+D"(block)
-	:"r" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)line_size)
+	:"%"REG_a, "memory");
 }
 
 static void DEF(put_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"movq (%1), %%mm0		\n\t"
-	"subl %3, %2			\n\t"
+	"sub %3, %2			\n\t"
 	"1:				\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm2	\n\t"
-	"addl %%eax, %1			\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, %%eax)	\n\t"
+	"movq %%mm1, (%2, %%"REG_a")	\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm0	\n\t"
-	"addl %%eax, %2			\n\t"
-	"addl %%eax, %1			\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, %%eax)	\n\t"
-	"addl %%eax, %2			\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" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)line_size)
+	:"%"REG_a, "memory");
 }
 
 /* GL: this function does incorrect rounding if overflow */
@@ -226,39 +619,39 @@ static void DEF(put_no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, in
 {
     MOVQ_BONE(mm6);
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"movq (%1), %%mm0		\n\t"
-	"subl %3, %2			\n\t"
+	"sub %3, %2			\n\t"
 	"1:				\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm2	\n\t"
-	"addl %%eax, %1			\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, %%eax)	\n\t"
+	"movq %%mm1, (%2, %%"REG_a")	\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm0	\n\t"
-	"addl %%eax, %2			\n\t"
-	"addl %%eax, %1			\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, %%eax)	\n\t"
-	"addl %%eax, %2			\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" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)line_size)
+	:"%"REG_a, "memory");
 }
 
 static void DEF(avg_pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 {
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"1:				\n\t"
 	"movq (%2), %%mm0		\n\t"
 	"movq (%2, %3), %%mm1		\n\t"
@@ -266,27 +659,27 @@ static void DEF(avg_pixels8)(uint8_t *block, const uint8_t *pixels, int line_siz
 	PAVGB" (%1, %3), %%mm1		\n\t"
 	"movq %%mm0, (%2)		\n\t"
 	"movq %%mm1, (%2, %3)		\n\t"
-	"addl %%eax, %1			\n\t"
-	"addl %%eax, %2			\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"
-	"addl %%eax, %1			\n\t"
+	"add %%"REG_a", %1		\n\t"
 	"movq %%mm0, (%2)		\n\t"
 	"movq %%mm1, (%2, %3)		\n\t"
-	"addl %%eax, %2			\n\t"
+	"add %%"REG_a", %2		\n\t"
 	"subl $4, %0			\n\t"
 	"jnz 1b				\n\t"
 	:"+g"(h), "+S"(pixels), "+D"(block)
-	:"r" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)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), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"1:				\n\t"
 	"movq (%1), %%mm0		\n\t"
 	"movq (%1, %3), %%mm2		\n\t"
@@ -294,63 +687,63 @@ static void DEF(avg_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_
 	PAVGB" 1(%1, %3), %%mm2		\n\t"
 	PAVGB" (%2), %%mm0		\n\t"
 	PAVGB" (%2, %3), %%mm2		\n\t"
-	"addl %%eax, %1			\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"
-	"addl %%eax, %2			\n\t"
-	"addl %%eax, %1			\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"
-	"addl %%eax, %2			\n\t"
+	"add %%"REG_a", %2		\n\t"
 	"subl $4, %0			\n\t"
 	"jnz 1b				\n\t"
 	:"+g"(h), "+S"(pixels), "+D"(block)
-	:"r" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)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), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"movq (%1), %%mm0		\n\t"
-	"subl %3, %2			\n\t"
+	"sub %3, %2			\n\t"
 	"1:				\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm2	\n\t"
-	"addl %%eax, %1			\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, %%eax), %%mm4	\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, %%eax)	\n\t"
+	"movq %%mm1, (%2, %%"REG_a")	\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm0	\n\t"
+	"movq (%1, %%"REG_a"), %%mm0	\n\t"
 	PAVGB" %%mm1, %%mm2		\n\t"
 	PAVGB" %%mm0, %%mm1		\n\t"
-	"addl %%eax, %2			\n\t"
-	"addl %%eax, %1			\n\t"
+	"add %%"REG_a", %2		\n\t"
+	"add %%"REG_a", %1		\n\t"
 	"movq (%2, %3), %%mm3		\n\t"
-	"movq (%2, %%eax), %%mm4	\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, %%eax)	\n\t"
-	"addl %%eax, %2			\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" (line_size)
-	:"%eax", "memory");
+	:"r" ((long)line_size)
+	:"%"REG_a, "memory");
 }
 
 // Note this is not correctly rounded, but this function is only used for b frames so it doesnt matter 
@@ -358,17 +751,17 @@ static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line
 {
     MOVQ_BONE(mm6);
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"movq (%1), %%mm0		\n\t"
 	PAVGB" 1(%1), %%mm0		\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
-	"movq (%1, %%eax), %%mm2	\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, %%eax), %%mm2	\n\t"
-	"addl %%eax, %1			\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"
@@ -376,23 +769,23 @@ static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line
 	"movq %%mm0, (%2)		\n\t"
 	"movq %%mm1, (%2, %3)		\n\t"
 	"movq (%1, %3), %%mm1		\n\t"
-	"movq (%1, %%eax), %%mm0	\n\t"
+	"movq (%1, %%"REG_a"), %%mm0	\n\t"
 	PAVGB" 1(%1, %3), %%mm1		\n\t"
-	PAVGB" 1(%1, %%eax), %%mm0	\n\t"
-	"addl %%eax, %2			\n\t"
-	"addl %%eax, %1			\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"
-	"addl %%eax, %2			\n\t"
+	"add %%"REG_a", %2		\n\t"
 	"subl $4, %0			\n\t"
 	"jnz 1b				\n\t"
 	:"+g"(h), "+S"(pixels), "+D"(block)
-	:"r" (line_size)
-	:"%eax",  "memory");
+	:"r" ((long)line_size)
+	:"%"REG_a,  "memory");
 }
 
 //FIXME the following could be optimized too ...
diff --git a/src/libffmpeg/libavcodec/i386/dsputil_mmx_rnd.h b/src/libffmpeg/libavcodec/i386/dsputil_mmx_rnd.h
index 1b79aa56a..20ea1b59e 100644
--- a/src/libffmpeg/libavcodec/i386/dsputil_mmx_rnd.h
+++ b/src/libffmpeg/libavcodec/i386/dsputil_mmx_rnd.h
@@ -27,7 +27,7 @@ static void DEF(put, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
-	"lea	(%3, %3), %%eax		\n\t"
+	"lea	(%3, %3), %%"REG_a"	\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
 	"movq	(%1), %%mm0		\n\t"
@@ -37,8 +37,8 @@ static void DEF(put, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line
 	PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
 	"movq	%%mm4, (%2)		\n\t"
 	"movq	%%mm5, (%2, %3)		\n\t"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\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"
@@ -46,13 +46,13 @@ static void DEF(put, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line
 	PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
 	"movq	%%mm4, (%2)		\n\t"
 	"movq	%%mm5, (%2, %3)		\n\t"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\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"(line_size)
-	:"eax", "memory");
+	:"r"((long)line_size)
+	:REG_a, "memory");
 }
 
 static void DEF(put, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
@@ -63,37 +63,37 @@ static void DEF(put, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int
         " jz 1f				\n\t"
 	"movq	(%1), %%mm0		\n\t"
 	"movq	(%2), %%mm1		\n\t"
-	"addl	%4, %1			\n\t"
-        "addl	$8, %2			\n\t"
+	"add	%4, %1			\n\t"
+	"add	$8, %2			\n\t"
 	PAVGB(%%mm0, %%mm1, %%mm4, %%mm6)
 	"movq	%%mm4, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
         "decl	%0			\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
 	"movq	(%1), %%mm0		\n\t"
 	"movq	(%2), %%mm1		\n\t"
-	"addl	%4, %1			\n\t"
+	"add	%4, %1			\n\t"
 	"movq	(%1), %%mm2		\n\t"
 	"movq	8(%2), %%mm3		\n\t"
-	"addl	%4, %1			\n\t"
+	"add	%4, %1			\n\t"
 	PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
 	"movq	%%mm4, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"movq	%%mm5, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"movq	(%1), %%mm0		\n\t"
 	"movq	16(%2), %%mm1		\n\t"
-	"addl	%4, %1			\n\t"
+	"add	%4, %1			\n\t"
 	"movq	(%1), %%mm2		\n\t"
 	"movq	24(%2), %%mm3		\n\t"
-	"addl	%4, %1			\n\t"
-	"addl	$32, %2			\n\t"
+	"add	%4, %1			\n\t"
+	"add	$32, %2			\n\t"
 	PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
 	"movq	%%mm4, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"movq	%%mm5, (%3)		\n\t"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"subl	$4, %0			\n\t"
 	"jnz	1b			\n\t"
 #ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
@@ -101,7 +101,7 @@ static void DEF(put, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int
 #else
         :"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
 #endif
-	:"S"(src1Stride), "D"(dstStride)
+	:"S"((long)src1Stride), "D"((long)dstStride)
 	:"memory");
 }
 
@@ -109,7 +109,7 @@ static void DEF(put, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int lin
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
-	"lea	(%3, %3), %%eax		\n\t"
+	"lea	(%3, %3), %%"REG_a"	\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
 	"movq	(%1), %%mm0		\n\t"
@@ -126,8 +126,8 @@ static void DEF(put, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int lin
 	PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
 	"movq	%%mm4, 8(%2)		\n\t"
 	"movq	%%mm5, 8(%2, %3)	\n\t"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\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"
@@ -142,13 +142,13 @@ static void DEF(put, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int lin
 	PAVGBP(%%mm0, %%mm1, %%mm4,   %%mm2, %%mm3, %%mm5)
 	"movq	%%mm4, 8(%2)		\n\t"
 	"movq	%%mm5, 8(%2, %3)	\n\t"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\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"(line_size)
-	:"eax", "memory");
+	:"r"((long)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)
@@ -161,12 +161,12 @@ static void DEF(put, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, in
 	"movq	(%2), %%mm1		\n\t"
 	"movq	8(%1), %%mm2		\n\t"
 	"movq	8(%2), %%mm3		\n\t"
-	"addl	%4, %1			\n\t"
-	"addl	$16, %2			\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"
-	"addl	%5, %3			\n\t"
+	"add	%5, %3			\n\t"
 	"decl	%0			\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
@@ -174,21 +174,21 @@ static void DEF(put, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, in
 	"movq	(%2), %%mm1		\n\t"
 	"movq	8(%1), %%mm2		\n\t"
 	"movq	8(%2), %%mm3		\n\t"
-	"addl	%4, %1			\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"
-	"addl	%5, %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"
-	"addl	%4, %1			\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"
-	"addl	%5, %3			\n\t"
-	"addl	$32, %2			\n\t"
+	"add	%5, %3			\n\t"
+	"add	$32, %2			\n\t"
 	"subl	$2, %0			\n\t"
 	"jnz	1b			\n\t"
 #ifdef PIC //Note "+bm" and "+mb" are buggy too (with gcc 3.2.2 at least) and cant be used
@@ -196,7 +196,7 @@ static void DEF(put, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, in
 #else
 	:"+b"(h), "+a"(src1), "+c"(src2), "+d"(dst)
 #endif
-	:"S"(src1Stride), "D"(dstStride)
+	:"S"((long)src1Stride), "D"((long)dstStride)
 	:"memory"); 
 }
 
@@ -204,29 +204,29 @@ static void DEF(put, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
-	"lea (%3, %3), %%eax		\n\t"
+	"lea (%3, %3), %%"REG_a"	\n\t"
 	"movq (%1), %%mm0		\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
 	"movq	(%1, %3), %%mm1		\n\t"
-	"movq	(%1, %%eax),%%mm2	\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"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\n\t"
+	"add	%%"REG_a", %1		\n\t"
+	"add	%%"REG_a", %2		\n\t"
 	"movq	(%1, %3), %%mm1		\n\t"
-	"movq	(%1, %%eax),%%mm0	\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"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\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"(line_size)
-	:"eax", "memory");
+	:"r"((long)line_size)
+	:REG_a, "memory");
 }
 
 static void DEF(put, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
@@ -244,12 +244,12 @@ static void DEF(put, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int lin
 	"punpckhbw %%mm7, %%mm5		\n\t"
 	"paddusw %%mm0, %%mm4		\n\t"
 	"paddusw %%mm1, %%mm5		\n\t"
-	"xorl	%%eax, %%eax		\n\t"
-	"addl	%3, %1			\n\t"
+	"xor	%%"REG_a", %%"REG_a"	\n\t"
+	"add	%3, %1			\n\t"
 	".balign 8      		\n\t"
 	"1:				\n\t"
-	"movq	(%1, %%eax), %%mm0	\n\t"
-	"movq	1(%1, %%eax), %%mm2	\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"
@@ -265,11 +265,11 @@ static void DEF(put, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int lin
 	"psrlw	$2, %%mm4		\n\t"
 	"psrlw	$2, %%mm5		\n\t"
 	"packuswb  %%mm5, %%mm4		\n\t"
-	"movq	%%mm4, (%2, %%eax)	\n\t"
-	"addl	%3, %%eax		\n\t"
+	"movq	%%mm4, (%2, %%"REG_a")	\n\t"
+	"add	%3, %%"REG_a"		\n\t"
 
-	"movq	(%1, %%eax), %%mm2	\n\t" // 0 <-> 2   1 <-> 3
-	"movq	1(%1, %%eax), %%mm4	\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"
@@ -285,17 +285,36 @@ static void DEF(put, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int lin
 	"psrlw	$2, %%mm0		\n\t"
 	"psrlw	$2, %%mm1		\n\t"
 	"packuswb  %%mm1, %%mm0		\n\t"
-	"movq	%%mm0, (%2, %%eax)	\n\t"
-	"addl	%3, %%eax		\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"(line_size)
-	:"eax", "memory");
+	:"D"(block), "r"((long)line_size)
+	:REG_a, "memory");
 }
 
 // avg_pixels
+static void 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"
+	     PAVGB(%%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)
 {
@@ -437,12 +456,12 @@ static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line
 {
     MOVQ_BFE(mm6);
     __asm __volatile(
-	"lea	(%3, %3), %%eax		\n\t"
+	"lea	(%3, %3), %%"REG_a"	\n\t"
 	"movq	(%1), %%mm0		\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
 	"movq	(%1, %3), %%mm1		\n\t"
-	"movq	(%1, %%eax), %%mm2	\n\t"
+	"movq	(%1, %%"REG_a"), %%mm2	\n\t"
 	PAVGBP(%%mm1, %%mm0, %%mm4,   %%mm2, %%mm1, %%mm5)
 	"movq	(%2), %%mm3		\n\t"
 	PAVGB(%%mm3, %%mm4, %%mm0, %%mm6)
@@ -450,11 +469,11 @@ static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line
 	PAVGB(%%mm3, %%mm5, %%mm1, %%mm6)
 	"movq	%%mm0, (%2)		\n\t"
 	"movq	%%mm1, (%2, %3)		\n\t"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\n\t"
+	"add	%%"REG_a", %1		\n\t"
+	"add	%%"REG_a", %2		\n\t"
 
 	"movq	(%1, %3), %%mm1		\n\t"
-	"movq	(%1, %%eax), %%mm0	\n\t"
+	"movq	(%1, %%"REG_a"), %%mm0	\n\t"
 	PAVGBP(%%mm1, %%mm2, %%mm4,   %%mm0, %%mm1, %%mm5)
 	"movq	(%2), %%mm3		\n\t"
 	PAVGB(%%mm3, %%mm4, %%mm2, %%mm6)
@@ -462,14 +481,14 @@ static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line
 	PAVGB(%%mm3, %%mm5, %%mm1, %%mm6)
 	"movq	%%mm2, (%2)		\n\t"
 	"movq	%%mm1, (%2, %3)		\n\t"
-	"addl	%%eax, %1		\n\t"
-	"addl	%%eax, %2		\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"(line_size)
-	:"eax", "memory");
+	:"r"((long)line_size)
+	:REG_a, "memory");
 }
 
 // this routine is 'slightly' suboptimal but mostly unused
@@ -488,12 +507,12 @@ static void DEF(avg, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int lin
 	"punpckhbw %%mm7, %%mm5		\n\t"
 	"paddusw %%mm0, %%mm4		\n\t"
 	"paddusw %%mm1, %%mm5		\n\t"
-	"xorl	%%eax, %%eax		\n\t"
-	"addl	%3, %1			\n\t"
+	"xor	%%"REG_a", %%"REG_a"	\n\t"
+	"add	%3, %1			\n\t"
 	".balign 8			\n\t"
 	"1:				\n\t"
-	"movq	(%1, %%eax), %%mm0	\n\t"
-	"movq	1(%1, %%eax), %%mm2	\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"
@@ -508,16 +527,16 @@ static void DEF(avg, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int lin
 	"paddusw %%mm1, %%mm5		\n\t"
 	"psrlw	$2, %%mm4		\n\t"
 	"psrlw	$2, %%mm5		\n\t"
-		"movq	(%2, %%eax), %%mm3	\n\t"
+		"movq	(%2, %%"REG_a"), %%mm3	\n\t"
 	"packuswb  %%mm5, %%mm4		\n\t"
 		"pcmpeqd %%mm2, %%mm2	\n\t"
 		"paddb %%mm2, %%mm2	\n\t"
 		PAVGB(%%mm3, %%mm4, %%mm5, %%mm2)
-		"movq	%%mm5, (%2, %%eax)	\n\t"
-	"addl	%3, %%eax		\n\t"
+		"movq	%%mm5, (%2, %%"REG_a")	\n\t"
+	"add	%3, %%"REG_a"		\n\t"
 
-	"movq	(%1, %%eax), %%mm2	\n\t" // 0 <-> 2   1 <-> 3
-	"movq	1(%1, %%eax), %%mm4	\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"
@@ -532,19 +551,19 @@ static void DEF(avg, pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int lin
 	"paddusw %%mm5, %%mm1		\n\t"
 	"psrlw	$2, %%mm0		\n\t"
 	"psrlw	$2, %%mm1		\n\t"
-		"movq	(%2, %%eax), %%mm3	\n\t"
+		"movq	(%2, %%"REG_a"), %%mm3	\n\t"
 	"packuswb  %%mm1, %%mm0		\n\t"
 		"pcmpeqd %%mm2, %%mm2	\n\t"
 		"paddb %%mm2, %%mm2	\n\t"
 		PAVGB(%%mm3, %%mm0, %%mm1, %%mm2)
-		"movq	%%mm1, (%2, %%eax)	\n\t"
-	"addl	%3, %%eax		\n\t"
+		"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"(line_size)
-	:"eax", "memory");
+	:"D"(block), "r"((long)line_size)
+	:REG_a, "memory");
 }
 
 //FIXME optimize
diff --git a/src/libffmpeg/libavcodec/i386/fdct_mmx.c b/src/libffmpeg/libavcodec/i386/fdct_mmx.c
index 7f348329a..aacbe5743 100644
--- a/src/libffmpeg/libavcodec/i386/fdct_mmx.c
+++ b/src/libffmpeg/libavcodec/i386/fdct_mmx.c
@@ -47,13 +47,13 @@ static const int16_t ocos_4_16[4] ATTR_ALIGN(8) = {
     23170, 23170, 23170, 23170,	//cos * (2<<15) + 0.5
 };
 
-static const long long fdct_one_corr ATTR_ALIGN(8) = 0x0001000100010001LL;
+static const int64_t fdct_one_corr ATTR_ALIGN(8) = 0x0001000100010001LL;
 
-static const long fdct_r_row[2] ATTR_ALIGN(8) = {RND_FRW_ROW, RND_FRW_ROW };
+static const int32_t fdct_r_row[2] ATTR_ALIGN(8) = {RND_FRW_ROW, RND_FRW_ROW };
 
 struct 
 {
- const long fdct_r_row_sse2[4] ATTR_ALIGN(16);
+ const int32_t fdct_r_row_sse2[4] ATTR_ALIGN(16);
 } fdct_r_row_sse2 ATTR_ALIGN(16)=
 {{
  RND_FRW_ROW, RND_FRW_ROW, RND_FRW_ROW, RND_FRW_ROW
diff --git a/src/libffmpeg/libavcodec/i386/mmx.h b/src/libffmpeg/libavcodec/i386/mmx.h
index ad684bc5a..f0ef1b79e 100644
--- a/src/libffmpeg/libavcodec/i386/mmx.h
+++ b/src/libffmpeg/libavcodec/i386/mmx.h
@@ -5,6 +5,12 @@
 #ifndef AVCODEC_I386MMX_H
 #define AVCODEC_I386MMX_H
 
+#ifdef ARCH_X86_64
+#  define REG_a "rax"
+#else
+#  define REG_a "eax"
+#endif
+
 /*
  * The type of an value that fits in an MMX register (note that long
  * long constant values MUST be suffixed by LL and unsigned long long
diff --git a/src/libffmpeg/libavcodec/i386/motion_est_mmx.c b/src/libffmpeg/libavcodec/i386/motion_est_mmx.c
index 39246d905..1b90f8e40 100644
--- a/src/libffmpeg/libavcodec/i386/motion_est_mmx.c
+++ b/src/libffmpeg/libavcodec/i386/motion_est_mmx.c
@@ -20,6 +20,7 @@
  * mostly by Michael Niedermayer <michaelni@gmx.at>
  */
 #include "../dsputil.h"
+#include "mmx.h"
 
 static const __attribute__ ((aligned(8))) uint64_t round_tab[3]={
 0x0000000000000000ULL,
@@ -31,19 +32,19 @@ static attribute_used __attribute__ ((aligned(8))) uint64_t bone= 0x010101010101
 
 static inline void sad8_1_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 {
-    int len= -(stride*h);
+    long len= -(stride*h);
     asm volatile(
         ".balign 16			\n\t"
         "1:				\n\t"
-        "movq (%1, %%eax), %%mm0	\n\t"
-        "movq (%2, %%eax), %%mm2	\n\t"
-        "movq (%2, %%eax), %%mm4	\n\t"
-        "addl %3, %%eax			\n\t"
+        "movq (%1, %%"REG_a"), %%mm0	\n\t"
+        "movq (%2, %%"REG_a"), %%mm2	\n\t"
+        "movq (%2, %%"REG_a"), %%mm4	\n\t"
+        "add %3, %%"REG_a"		\n\t"
         "psubusb %%mm0, %%mm2		\n\t"
         "psubusb %%mm4, %%mm0		\n\t"
-        "movq (%1, %%eax), %%mm1	\n\t"
-        "movq (%2, %%eax), %%mm3	\n\t"
-        "movq (%2, %%eax), %%mm5	\n\t"
+        "movq (%1, %%"REG_a"), %%mm1	\n\t"
+        "movq (%2, %%"REG_a"), %%mm3	\n\t"
+        "movq (%2, %%"REG_a"), %%mm5	\n\t"
         "psubusb %%mm1, %%mm3		\n\t"
         "psubusb %%mm5, %%mm1		\n\t"
         "por %%mm2, %%mm0		\n\t"
@@ -58,116 +59,116 @@ static inline void sad8_1_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
         "paddw %%mm3, %%mm2		\n\t"
         "paddw %%mm2, %%mm0		\n\t"
         "paddw %%mm0, %%mm6		\n\t"
-        "addl %3, %%eax			\n\t"
+        "add %3, %%"REG_a"		\n\t"
         " js 1b				\n\t"
         : "+a" (len)
-        : "r" (blk1 - len), "r" (blk2 - len), "r" (stride)
+        : "r" (blk1 - len), "r" (blk2 - len), "r" ((long)stride)
     );
 }
 
 static inline void sad8_1_mmx2(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 {
-    int len= -(stride*h);
+    long len= -(stride*h);
     asm volatile(
         ".balign 16			\n\t"
         "1:				\n\t"
-        "movq (%1, %%eax), %%mm0	\n\t"
-        "movq (%2, %%eax), %%mm2	\n\t"
+        "movq (%1, %%"REG_a"), %%mm0	\n\t"
+        "movq (%2, %%"REG_a"), %%mm2	\n\t"
         "psadbw %%mm2, %%mm0		\n\t"
-        "addl %3, %%eax			\n\t"
-        "movq (%1, %%eax), %%mm1	\n\t"
-        "movq (%2, %%eax), %%mm3	\n\t"
+        "add %3, %%"REG_a"		\n\t"
+        "movq (%1, %%"REG_a"), %%mm1	\n\t"
+        "movq (%2, %%"REG_a"), %%mm3	\n\t"
         "psadbw %%mm1, %%mm3		\n\t"
         "paddw %%mm3, %%mm0		\n\t"
         "paddw %%mm0, %%mm6		\n\t"
-        "addl %3, %%eax			\n\t"
+        "add %3, %%"REG_a"		\n\t"
         " js 1b				\n\t"
         : "+a" (len)
-        : "r" (blk1 - len), "r" (blk2 - len), "r" (stride)
+        : "r" (blk1 - len), "r" (blk2 - len), "r" ((long)stride)
     );
 }
 
 static inline void sad8_2_mmx2(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int stride, int h)
 {
-    int len= -(stride*h);
+    long len= -(stride*h);
     asm volatile(
         ".balign 16			\n\t"
         "1:				\n\t"
-        "movq (%1, %%eax), %%mm0	\n\t"
-        "movq (%2, %%eax), %%mm2	\n\t"
+        "movq (%1, %%"REG_a"), %%mm0	\n\t"
+        "movq (%2, %%"REG_a"), %%mm2	\n\t"
         "pavgb %%mm2, %%mm0		\n\t"
-        "movq (%3, %%eax), %%mm2	\n\t"
+        "movq (%3, %%"REG_a"), %%mm2	\n\t"
         "psadbw %%mm2, %%mm0		\n\t"
-        "addl %4, %%eax			\n\t"
-        "movq (%1, %%eax), %%mm1	\n\t"
-        "movq (%2, %%eax), %%mm3	\n\t"
+        "add %4, %%"REG_a"		\n\t"
+        "movq (%1, %%"REG_a"), %%mm1	\n\t"
+        "movq (%2, %%"REG_a"), %%mm3	\n\t"
         "pavgb %%mm1, %%mm3		\n\t"
-        "movq (%3, %%eax), %%mm1	\n\t"
+        "movq (%3, %%"REG_a"), %%mm1	\n\t"
         "psadbw %%mm1, %%mm3		\n\t"
         "paddw %%mm3, %%mm0		\n\t"
         "paddw %%mm0, %%mm6		\n\t"
-        "addl %4, %%eax			\n\t"
+        "add %4, %%"REG_a"		\n\t"
         " js 1b				\n\t"
         : "+a" (len)
-        : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" (stride)
+        : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" ((long)stride)
     );
 }
 
 static inline void sad8_4_mmx2(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 { //FIXME reuse src
-    int len= -(stride*h);
+    long len= -(stride*h);
     asm volatile(
         ".balign 16			\n\t"
         "movq "MANGLE(bone)", %%mm5	\n\t"
         "1:				\n\t"
-        "movq (%1, %%eax), %%mm0	\n\t"
-        "movq (%2, %%eax), %%mm2	\n\t"
-        "movq 1(%1, %%eax), %%mm1	\n\t"
-        "movq 1(%2, %%eax), %%mm3	\n\t"
+        "movq (%1, %%"REG_a"), %%mm0	\n\t"
+        "movq (%2, %%"REG_a"), %%mm2	\n\t"
+        "movq 1(%1, %%"REG_a"), %%mm1	\n\t"
+        "movq 1(%2, %%"REG_a"), %%mm3	\n\t"
         "pavgb %%mm2, %%mm0		\n\t"
         "pavgb %%mm1, %%mm3		\n\t"
         "psubusb %%mm5, %%mm3		\n\t"
         "pavgb %%mm3, %%mm0		\n\t"
-        "movq (%3, %%eax), %%mm2	\n\t"
+        "movq (%3, %%"REG_a"), %%mm2	\n\t"
         "psadbw %%mm2, %%mm0		\n\t"
-        "addl %4, %%eax			\n\t"
-        "movq (%1, %%eax), %%mm1	\n\t"
-        "movq (%2, %%eax), %%mm3	\n\t"
-        "movq 1(%1, %%eax), %%mm2	\n\t"
-        "movq 1(%2, %%eax), %%mm4	\n\t"
+        "add %4, %%"REG_a"		\n\t"
+        "movq (%1, %%"REG_a"), %%mm1	\n\t"
+        "movq (%2, %%"REG_a"), %%mm3	\n\t"
+        "movq 1(%1, %%"REG_a"), %%mm2	\n\t"
+        "movq 1(%2, %%"REG_a"), %%mm4	\n\t"
         "pavgb %%mm3, %%mm1		\n\t"
         "pavgb %%mm4, %%mm2		\n\t"
         "psubusb %%mm5, %%mm2		\n\t"
         "pavgb %%mm1, %%mm2		\n\t"
-        "movq (%3, %%eax), %%mm1	\n\t"
+        "movq (%3, %%"REG_a"), %%mm1	\n\t"
         "psadbw %%mm1, %%mm2		\n\t"
         "paddw %%mm2, %%mm0		\n\t"
         "paddw %%mm0, %%mm6		\n\t"
-        "addl %4, %%eax			\n\t"
+        "add %4, %%"REG_a"		\n\t"
         " js 1b				\n\t"
         : "+a" (len)
-        : "r" (blk1 - len), "r" (blk1 - len + stride), "r" (blk2 - len), "r" (stride)
+        : "r" (blk1 - len), "r" (blk1 - len + stride), "r" (blk2 - len), "r" ((long)stride)
     );
 }
 
 static inline void sad8_2_mmx(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int stride, int h)
 {
-    int len= -(stride*h);
+    long len= -(stride*h);
     asm volatile(
         ".balign 16			\n\t"
         "1:				\n\t"
-        "movq (%1, %%eax), %%mm0	\n\t"
-        "movq (%2, %%eax), %%mm1	\n\t"
-        "movq (%1, %%eax), %%mm2	\n\t"
-        "movq (%2, %%eax), %%mm3	\n\t"
+        "movq (%1, %%"REG_a"), %%mm0	\n\t"
+        "movq (%2, %%"REG_a"), %%mm1	\n\t"
+        "movq (%1, %%"REG_a"), %%mm2	\n\t"
+        "movq (%2, %%"REG_a"), %%mm3	\n\t"
         "punpcklbw %%mm7, %%mm0		\n\t"
         "punpcklbw %%mm7, %%mm1		\n\t"
         "punpckhbw %%mm7, %%mm2		\n\t"
         "punpckhbw %%mm7, %%mm3		\n\t"
         "paddw %%mm0, %%mm1		\n\t"
         "paddw %%mm2, %%mm3		\n\t"
-        "movq (%3, %%eax), %%mm4	\n\t"
-        "movq (%3, %%eax), %%mm2	\n\t"
+        "movq (%3, %%"REG_a"), %%mm4	\n\t"
+        "movq (%3, %%"REG_a"), %%mm2	\n\t"
         "paddw %%mm5, %%mm1		\n\t"
         "paddw %%mm5, %%mm3		\n\t"
         "psrlw $1, %%mm1		\n\t"
@@ -181,21 +182,21 @@ static inline void sad8_2_mmx(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2, int
         "punpckhbw %%mm7, %%mm1		\n\t"
         "paddw %%mm1, %%mm0		\n\t"
         "paddw %%mm0, %%mm6		\n\t"
-        "addl %4, %%eax			\n\t"
+        "add %4, %%"REG_a"		\n\t"
         " js 1b				\n\t"
         : "+a" (len)
-        : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" (stride)
+        : "r" (blk1a - len), "r" (blk1b -len), "r" (blk2 - len), "r" ((long)stride)
     );
 }
 
 static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 {
-    int len= -(stride*h);
+    long len= -(stride*h);
     asm volatile(
         ".balign 16			\n\t"
         "1:				\n\t"
-        "movq (%1, %%eax), %%mm0	\n\t"
-        "movq (%2, %%eax), %%mm1	\n\t"
+        "movq (%1, %%"REG_a"), %%mm0	\n\t"
+        "movq (%2, %%"REG_a"), %%mm1	\n\t"
         "movq %%mm0, %%mm4		\n\t"
         "movq %%mm1, %%mm2		\n\t"
         "punpcklbw %%mm7, %%mm0		\n\t"
@@ -204,8 +205,8 @@ static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
         "punpckhbw %%mm7, %%mm2		\n\t"
         "paddw %%mm1, %%mm0		\n\t"
         "paddw %%mm2, %%mm4		\n\t"
-        "movq 1(%1, %%eax), %%mm2	\n\t"
-        "movq 1(%2, %%eax), %%mm3	\n\t"
+        "movq 1(%1, %%"REG_a"), %%mm2	\n\t"
+        "movq 1(%2, %%"REG_a"), %%mm3	\n\t"
         "movq %%mm2, %%mm1		\n\t"
         "punpcklbw %%mm7, %%mm2		\n\t"
         "punpckhbw %%mm7, %%mm1		\n\t"
@@ -216,8 +217,8 @@ static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
         "punpckhbw %%mm7, %%mm4		\n\t"
         "paddw %%mm3, %%mm2		\n\t"
         "paddw %%mm4, %%mm1		\n\t"
-        "movq (%3, %%eax), %%mm3	\n\t"
-        "movq (%3, %%eax), %%mm4	\n\t"
+        "movq (%3, %%"REG_a"), %%mm3	\n\t"
+        "movq (%3, %%"REG_a"), %%mm4	\n\t"
         "paddw %%mm5, %%mm2		\n\t"
         "paddw %%mm5, %%mm1		\n\t"
         "psrlw $2, %%mm2		\n\t"
@@ -231,10 +232,10 @@ static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
         "punpckhbw %%mm7, %%mm2		\n\t"
         "paddw %%mm2, %%mm0		\n\t"
         "paddw %%mm0, %%mm6		\n\t"
-        "addl %4, %%eax			\n\t"
+        "add %4, %%"REG_a"		\n\t"
         " js 1b				\n\t"
         : "+a" (len)
-        : "r" (blk1 - len), "r" (blk1 -len + stride), "r" (blk2 - len), "r" (stride)
+        : "r" (blk1 - len), "r" (blk1 -len + stride), "r" (blk2 - len), "r" ((long)stride)
     );
 }
 
diff --git a/src/libffmpeg/libavcodec/i386/mpegvideo_mmx.c b/src/libffmpeg/libavcodec/i386/mpegvideo_mmx.c
index f19de73d6..70c81f675 100644
--- a/src/libffmpeg/libavcodec/i386/mpegvideo_mmx.c
+++ b/src/libffmpeg/libavcodec/i386/mpegvideo_mmx.c
@@ -23,6 +23,7 @@
 #include "../dsputil.h"
 #include "../mpegvideo.h"
 #include "../avcodec.h"
+#include "mmx.h"
 
 extern uint8_t zigzag_direct_noperm[64];
 extern uint16_t inv_zigzag_direct16[64];
@@ -34,7 +35,7 @@ static const unsigned long long int mm_wone __attribute__ ((aligned(8))) = 0x000
 static void dct_unquantize_h263_intra_mmx(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale)
 {
-    int level, qmul, qadd, nCoeffs;
+    long level, qmul, qadd, nCoeffs;
 
     qmul = qscale << 1;
 
@@ -97,7 +98,7 @@ asm volatile(
 		"movq %%mm0, (%0, %3)		\n\t"
 		"movq %%mm1, 8(%0, %3)		\n\t"
 
-		"addl $16, %3			\n\t"
+		"add $16, %3			\n\t"
 		"jng 1b				\n\t"
 		::"r" (block+nCoeffs), "g"(qmul), "g" (qadd), "r" (2*(-nCoeffs))
 		: "memory"
@@ -109,7 +110,7 @@ asm volatile(
 static void dct_unquantize_h263_inter_mmx(MpegEncContext *s,
                                   DCTELEM *block, int n, int qscale)
 {
-    int qmul, qadd, nCoeffs;
+    long qmul, qadd, nCoeffs;
 
     qmul = qscale << 1;
     qadd = (qscale - 1) | 1;
@@ -160,7 +161,7 @@ asm volatile(
 		"movq %%mm0, (%0, %3)		\n\t"
 		"movq %%mm1, 8(%0, %3)		\n\t"
 
-		"addl $16, %3			\n\t"
+		"add $16, %3			\n\t"
 		"jng 1b				\n\t"
 		::"r" (block+nCoeffs), "g"(qmul), "g" (qadd), "r" (2*(-nCoeffs))
 		: "memory"
@@ -200,7 +201,7 @@ asm volatile(
 static void dct_unquantize_mpeg1_intra_mmx(MpegEncContext *s,
                                      DCTELEM *block, int n, int qscale)
 {
-    int nCoeffs;
+    long nCoeffs;
     const uint16_t *quant_matrix;
     int block0;
 
@@ -220,13 +221,13 @@ asm volatile(
 		"movd %2, %%mm6			\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
-                "movl %3, %%eax			\n\t"
+		"mov %3, %%"REG_a"		\n\t"
 		".balign 16\n\t"
 		"1:				\n\t"
-		"movq (%0, %%eax), %%mm0	\n\t"
-		"movq 8(%0, %%eax), %%mm1	\n\t"
-		"movq (%1, %%eax), %%mm4	\n\t"
-		"movq 8(%1, %%eax), %%mm5	\n\t"
+		"movq (%0, %%"REG_a"), %%mm0	\n\t"
+		"movq 8(%0, %%"REG_a"), %%mm1	\n\t"
+		"movq (%1, %%"REG_a"), %%mm4	\n\t"
+		"movq 8(%1, %%"REG_a"), %%mm5	\n\t"
 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]
 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]
 		"pxor %%mm2, %%mm2		\n\t"
@@ -241,8 +242,8 @@ asm volatile(
 		"pmullw %%mm5, %%mm1		\n\t" // abs(block[i])*q
 		"pxor %%mm4, %%mm4		\n\t"
 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow
-		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
-		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw (%0, %%"REG_a"), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw 8(%0, %%"REG_a"), %%mm5\n\t" // block[i] == 0 ? -1 : 0
 		"psraw $3, %%mm0		\n\t"
 		"psraw $3, %%mm1		\n\t"
 		"psubw %%mm7, %%mm0		\n\t"
@@ -255,13 +256,13 @@ asm volatile(
 		"psubw %%mm3, %%mm1		\n\t"
 		"pandn %%mm0, %%mm4		\n\t"
 		"pandn %%mm1, %%mm5		\n\t"
-		"movq %%mm4, (%0, %%eax)	\n\t"
-		"movq %%mm5, 8(%0, %%eax)	\n\t"
+		"movq %%mm4, (%0, %%"REG_a")	\n\t"
+		"movq %%mm5, 8(%0, %%"REG_a")	\n\t"
 
-		"addl $16, %%eax		\n\t"
+		"add $16, %%"REG_a"		\n\t"
 		"js 1b				\n\t"
 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)
-		: "%eax", "memory"
+		: "%"REG_a, "memory"
 	);    
     block[0]= block0;
 }
@@ -269,7 +270,7 @@ asm volatile(
 static void dct_unquantize_mpeg1_inter_mmx(MpegEncContext *s,
                                      DCTELEM *block, int n, int qscale)
 {
-    int nCoeffs;
+    long nCoeffs;
     const uint16_t *quant_matrix;
 
     assert(s->block_last_index[n]>=0);
@@ -283,13 +284,13 @@ asm volatile(
 		"movd %2, %%mm6			\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
-                "movl %3, %%eax			\n\t"
+		"mov %3, %%"REG_a"		\n\t"
 		".balign 16\n\t"
 		"1:				\n\t"
-		"movq (%0, %%eax), %%mm0	\n\t"
-		"movq 8(%0, %%eax), %%mm1	\n\t"
-		"movq (%1, %%eax), %%mm4	\n\t"
-		"movq 8(%1, %%eax), %%mm5	\n\t"
+		"movq (%0, %%"REG_a"), %%mm0	\n\t"
+		"movq 8(%0, %%"REG_a"), %%mm1	\n\t"
+		"movq (%1, %%"REG_a"), %%mm4	\n\t"
+		"movq 8(%1, %%"REG_a"), %%mm5	\n\t"
 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]
 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]
 		"pxor %%mm2, %%mm2		\n\t"
@@ -308,8 +309,8 @@ asm volatile(
 		"pmullw %%mm5, %%mm1		\n\t" // (abs(block[i])*2 + 1)*q
 		"pxor %%mm4, %%mm4		\n\t"
 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow
-		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
-		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw (%0, %%"REG_a"), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw 8(%0, %%"REG_a"), %%mm5\n\t" // block[i] == 0 ? -1 : 0
 		"psraw $4, %%mm0		\n\t"
 		"psraw $4, %%mm1		\n\t"
 		"psubw %%mm7, %%mm0		\n\t"
@@ -322,20 +323,20 @@ asm volatile(
 		"psubw %%mm3, %%mm1		\n\t"
 		"pandn %%mm0, %%mm4		\n\t"
 		"pandn %%mm1, %%mm5		\n\t"
-		"movq %%mm4, (%0, %%eax)	\n\t"
-		"movq %%mm5, 8(%0, %%eax)	\n\t"
+		"movq %%mm4, (%0, %%"REG_a")	\n\t"
+		"movq %%mm5, 8(%0, %%"REG_a")	\n\t"
 
-		"addl $16, %%eax		\n\t"
+		"add $16, %%"REG_a"		\n\t"
 		"js 1b				\n\t"
 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)
-		: "%eax", "memory"
+		: "%"REG_a, "memory"
 	);
 }
 
 static void dct_unquantize_mpeg2_intra_mmx(MpegEncContext *s,
                                      DCTELEM *block, int n, int qscale)
 {
-    int nCoeffs;
+    long nCoeffs;
     const uint16_t *quant_matrix;
     int block0;
     
@@ -355,13 +356,13 @@ asm volatile(
 		"movd %2, %%mm6			\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
-                "movl %3, %%eax			\n\t"
+		"mov %3, %%"REG_a"		\n\t"
 		".balign 16\n\t"
 		"1:				\n\t"
-		"movq (%0, %%eax), %%mm0	\n\t"
-		"movq 8(%0, %%eax), %%mm1	\n\t"
-		"movq (%1, %%eax), %%mm4	\n\t"
-		"movq 8(%1, %%eax), %%mm5	\n\t"
+		"movq (%0, %%"REG_a"), %%mm0	\n\t"
+		"movq 8(%0, %%"REG_a"), %%mm1	\n\t"
+		"movq (%1, %%"REG_a"), %%mm4	\n\t"
+		"movq 8(%1, %%"REG_a"), %%mm5	\n\t"
 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]
 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]
 		"pxor %%mm2, %%mm2		\n\t"
@@ -376,8 +377,8 @@ asm volatile(
 		"pmullw %%mm5, %%mm1		\n\t" // abs(block[i])*q
 		"pxor %%mm4, %%mm4		\n\t"
 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow
-		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
-		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw (%0, %%"REG_a"), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw 8(%0, %%"REG_a"), %%mm5\n\t" // block[i] == 0 ? -1 : 0
 		"psraw $3, %%mm0		\n\t"
 		"psraw $3, %%mm1		\n\t"
 		"pxor %%mm2, %%mm0		\n\t"
@@ -386,13 +387,13 @@ asm volatile(
 		"psubw %%mm3, %%mm1		\n\t"
 		"pandn %%mm0, %%mm4		\n\t"
 		"pandn %%mm1, %%mm5		\n\t"
-		"movq %%mm4, (%0, %%eax)	\n\t"
-		"movq %%mm5, 8(%0, %%eax)	\n\t"
+		"movq %%mm4, (%0, %%"REG_a")	\n\t"
+		"movq %%mm5, 8(%0, %%"REG_a")	\n\t"
 
-		"addl $16, %%eax		\n\t"
+		"add $16, %%"REG_a"		\n\t"
 		"jng 1b				\n\t"
 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "g" (-2*nCoeffs)
-		: "%eax", "memory"
+		: "%"REG_a, "memory"
 	);    
     block[0]= block0;
         //Note, we dont do mismatch control for intra as errors cannot accumulate
@@ -401,7 +402,7 @@ asm volatile(
 static void dct_unquantize_mpeg2_inter_mmx(MpegEncContext *s,
                                      DCTELEM *block, int n, int qscale)
 {
-    int nCoeffs;
+    long nCoeffs;
     const uint16_t *quant_matrix;
     
     assert(s->block_last_index[n]>=0);
@@ -416,13 +417,13 @@ asm volatile(
 		"movd %2, %%mm6			\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
 		"packssdw %%mm6, %%mm6		\n\t"
-                "movl %3, %%eax			\n\t"
+		"mov %3, %%"REG_a"		\n\t"
 		".balign 16\n\t"
 		"1:				\n\t"
-		"movq (%0, %%eax), %%mm0	\n\t"
-		"movq 8(%0, %%eax), %%mm1	\n\t"
-		"movq (%1, %%eax), %%mm4	\n\t"
-		"movq 8(%1, %%eax), %%mm5	\n\t"
+		"movq (%0, %%"REG_a"), %%mm0	\n\t"
+		"movq 8(%0, %%"REG_a"), %%mm1	\n\t"
+		"movq (%1, %%"REG_a"), %%mm4	\n\t"
+		"movq 8(%1, %%"REG_a"), %%mm5	\n\t"
 		"pmullw %%mm6, %%mm4		\n\t" // q=qscale*quant_matrix[i]
 		"pmullw %%mm6, %%mm5		\n\t" // q=qscale*quant_matrix[i]
 		"pxor %%mm2, %%mm2		\n\t"
@@ -441,8 +442,8 @@ asm volatile(
 		"paddw %%mm5, %%mm1		\n\t" // (abs(block[i])*2 + 1)*q
 		"pxor %%mm4, %%mm4		\n\t"
 		"pxor %%mm5, %%mm5		\n\t" // FIXME slow
-		"pcmpeqw (%0, %%eax), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
-		"pcmpeqw 8(%0, %%eax), %%mm5	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw (%0, %%"REG_a"), %%mm4	\n\t" // block[i] == 0 ? -1 : 0
+		"pcmpeqw 8(%0, %%"REG_a"), %%mm5\n\t" // block[i] == 0 ? -1 : 0
 		"psrlw $4, %%mm0		\n\t"
 		"psrlw $4, %%mm1		\n\t"
 		"pxor %%mm2, %%mm0		\n\t"
@@ -453,10 +454,10 @@ asm volatile(
 		"pandn %%mm1, %%mm5		\n\t"
                 "pxor %%mm4, %%mm7		\n\t"
                 "pxor %%mm5, %%mm7		\n\t"
-		"movq %%mm4, (%0, %%eax)	\n\t"
-		"movq %%mm5, 8(%0, %%eax)	\n\t"
+		"movq %%mm4, (%0, %%"REG_a")	\n\t"
+		"movq %%mm5, 8(%0, %%"REG_a")	\n\t"
 
-		"addl $16, %%eax		\n\t"
+		"add $16, %%"REG_a"		\n\t"
 		"jng 1b				\n\t"
                 "movd 124(%0, %3), %%mm0	\n\t"
                 "movq %%mm7, %%mm6		\n\t"
@@ -471,7 +472,7 @@ asm volatile(
                 "movd %%mm0, 124(%0, %3)	\n\t"
                 
 		::"r" (block+nCoeffs), "r"(quant_matrix+nCoeffs), "g" (qscale), "r" (-2*nCoeffs)
-		: "%eax", "memory"
+		: "%"REG_a, "memory"
 	);
 }
 
@@ -499,11 +500,11 @@ static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
 		"punpckhwd %%mm1, %%mm1		\n\t"
 		"punpckhdq %%mm1, %%mm1		\n\t"
 		"movq %%mm1, (%0, %2)		\n\t"
-		"addl %1, %0			\n\t"
-		"cmpl %3, %0			\n\t"
+		"add %1, %0			\n\t"
+		"cmp %3, %0			\n\t"
 		" jb 1b				\n\t"
 		: "+r" (ptr)
-		: "r" (wrap), "r" (width), "r" (ptr + wrap*height)
+		: "r" ((long)wrap), "r" ((long)width), "r" (ptr + wrap*height)
 	);
     }
     else
@@ -522,11 +523,11 @@ static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
 		"punpckhdq %%mm1, %%mm1		\n\t"
 		"movq %%mm1, (%0, %2)		\n\t"
 		"movq %%mm1, 8(%0, %2)		\n\t"
-		"addl %1, %0			\n\t"
-		"cmpl %3, %0			\n\t"
+		"add %1, %0			\n\t"
+		"cmp %3, %0			\n\t"
 		" jb 1b				\n\t"		
 		: "+r" (ptr)
-		: "r" (wrap), "r" (width), "r" (ptr + wrap*height)
+		: "r" ((long)wrap), "r" ((long)width), "r" (ptr + wrap*height)
 	);
     }
     
@@ -540,11 +541,11 @@ static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
 		"movq %%mm0, (%0, %2)		\n\t"
 		"movq %%mm0, (%0, %2, 2)	\n\t"
 		"movq %%mm0, (%0, %3)		\n\t"
-		"addl $8, %0			\n\t"
-		"cmpl %4, %0			\n\t"
+		"add $8, %0			\n\t"
+		"cmp %4, %0			\n\t"
 		" jb 1b				\n\t"
 		: "+r" (ptr)
-		: "r" ((int)buf - (int)ptr - w), "r" (-wrap), "r" (-wrap*3), "r" (ptr+width+2*w)
+		: "r" ((long)buf - (long)ptr - w), "r" ((long)-wrap), "r" ((long)-wrap*3), "r" (ptr+width+2*w)
 	);
 	ptr= last_line + (i + 1) * wrap - w;
 	asm volatile(
@@ -554,11 +555,11 @@ static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
 		"movq %%mm0, (%0, %2)		\n\t"
 		"movq %%mm0, (%0, %2, 2)	\n\t"
 		"movq %%mm0, (%0, %3)		\n\t"
-		"addl $8, %0			\n\t"
-		"cmpl %4, %0			\n\t"
+		"add $8, %0			\n\t"
+		"cmp %4, %0			\n\t"
 		" jb 1b				\n\t"
 		: "+r" (ptr)
-		: "r" ((int)last_line - (int)ptr - w), "r" (wrap), "r" (wrap*3), "r" (ptr+width+2*w)
+		: "r" ((long)last_line - (long)ptr - w), "r" ((long)wrap), "r" ((long)wrap*3), "r" (ptr+width+2*w)
 	);
     }
 }
@@ -607,10 +608,10 @@ static void  denoise_dct_mmx(MpegEncContext *s, DCTELEM *block){
         "movq %%mm2, 8(%1)		\n\t"
         "movq %%mm5, 16(%1)		\n\t"
         "movq %%mm3, 24(%1)		\n\t"
-        "addl $16, %0			\n\t"
-        "addl $32, %1			\n\t"
-        "addl $16, %2			\n\t"
-        "cmpl %3, %0			\n\t"
+        "add $16, %0			\n\t"
+        "add $32, %1			\n\t"
+        "add $16, %2			\n\t"
+        "cmp %3, %0			\n\t"
             " jb 1b			\n\t"
         : "+r" (block), "+r" (sum), "+r" (offset)
         : "r"(block+64)
@@ -661,10 +662,10 @@ static void  denoise_dct_sse2(MpegEncContext *s, DCTELEM *block){
         "movdqa %%xmm6, 16(%1)		\n\t"
         "movdqa %%xmm5, 32(%1)		\n\t"
         "movdqa %%xmm0, 48(%1)		\n\t"
-        "addl $32, %0			\n\t"
-        "addl $64, %1			\n\t"
-        "addl $32, %2			\n\t"
-        "cmpl %3, %0			\n\t"
+        "add $32, %0			\n\t"
+        "add $64, %1			\n\t"
+        "add $32, %2			\n\t"
+        "cmp %3, %0			\n\t"
             " jb 1b			\n\t"
         : "+r" (block), "+r" (sum), "+r" (offset)
         : "r"(block+64)
diff --git a/src/libffmpeg/libavcodec/i386/mpegvideo_mmx_template.c b/src/libffmpeg/libavcodec/i386/mpegvideo_mmx_template.c
index d4ed61ecb..c9354dc1b 100644
--- a/src/libffmpeg/libavcodec/i386/mpegvideo_mmx_template.c
+++ b/src/libffmpeg/libavcodec/i386/mpegvideo_mmx_template.c
@@ -36,7 +36,8 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
                             DCTELEM *block, int n,
                             int qscale, int *overflow)
 {
-    int level=0, last_non_zero_p1, q; //=0 is cuz gcc says uninitalized ...
+    long last_non_zero_p1;
+    int level=0, q; //=0 is cuz gcc says uninitalized ...
     const uint16_t *qmat, *bias;
     __align8 int16_t temp_block[64];
     
@@ -58,7 +59,7 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
         if (!s->h263_aic) {
 #if 1
         asm volatile (
-        	"imul %%ecx		\n\t"
+        	"mul %%ecx		\n\t"
         	: "=d" (level), "=a"(dummy)
         	: "a" ((block[0]>>2) + q), "c" (inverse[q<<1])
         );
@@ -87,21 +88,21 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
         qmat = s->q_inter_matrix16[qscale][0];
     }
 
-    if(s->out_format == FMT_H263 && s->mpeg_quant==0){
+    if((s->out_format == FMT_H263 || s->out_format == FMT_H261) && s->mpeg_quant==0){
     
         asm volatile(
-            "movd %%eax, %%mm3			\n\t" // last_non_zero_p1
+            "movd %%"REG_a", %%mm3		\n\t" // last_non_zero_p1
             SPREADW(%%mm3)
             "pxor %%mm7, %%mm7			\n\t" // 0
             "pxor %%mm4, %%mm4			\n\t" // 0
             "movq (%2), %%mm5			\n\t" // qmat[0]
             "pxor %%mm6, %%mm6			\n\t"
             "psubw (%3), %%mm6			\n\t" // -bias[0]
-            "movl $-128, %%eax			\n\t"
+            "mov $-128, %%"REG_a"		\n\t"
             ".balign 16				\n\t"
             "1:					\n\t"
             "pxor %%mm1, %%mm1			\n\t" // 0
-            "movq (%1, %%eax), %%mm0		\n\t" // block[i]
+            "movq (%1, %%"REG_a"), %%mm0	\n\t" // block[i]
             "pcmpgtw %%mm0, %%mm1		\n\t" // block[i] <= 0 ? 0xFF : 0x00
             "pxor %%mm1, %%mm0			\n\t" 
             "psubw %%mm1, %%mm0			\n\t" // ABS(block[i])
@@ -110,13 +111,13 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
             "por %%mm0, %%mm4			\n\t" 
             "pxor %%mm1, %%mm0			\n\t" 
             "psubw %%mm1, %%mm0			\n\t" // out=((ABS(block[i])*qmat[0] - bias[0]*qmat[0])>>16)*sign(block[i])
-            "movq %%mm0, (%5, %%eax)		\n\t"
+            "movq %%mm0, (%5, %%"REG_a")	\n\t"
             "pcmpeqw %%mm7, %%mm0		\n\t" // out==0 ? 0xFF : 0x00
-            "movq (%4, %%eax), %%mm1		\n\t" 
-            "movq %%mm7, (%1, %%eax)		\n\t" // 0
+            "movq (%4, %%"REG_a"), %%mm1	\n\t" 
+            "movq %%mm7, (%1, %%"REG_a")	\n\t" // 0
             "pandn %%mm1, %%mm0			\n\t"
 	    PMAXW(%%mm0, %%mm3)
-            "addl $8, %%eax			\n\t"
+            "add $8, %%"REG_a"			\n\t"
             " js 1b				\n\t"
             "movq %%mm3, %%mm0			\n\t"
             "psrlq $32, %%mm3			\n\t"
@@ -124,8 +125,8 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
             "movq %%mm3, %%mm0			\n\t"
             "psrlq $16, %%mm3			\n\t"
 	    PMAXW(%%mm0, %%mm3)
-            "movd %%mm3, %%eax			\n\t"
-            "movzbl %%al, %%eax			\n\t" // last_non_zero_p1
+            "movd %%mm3, %%"REG_a"		\n\t"
+            "movzb %%al, %%"REG_a"		\n\t" // last_non_zero_p1
 	    : "+a" (last_non_zero_p1)
             : "r" (block+64), "r" (qmat), "r" (bias),
               "r" (inv_zigzag_direct16+64), "r" (temp_block+64)
@@ -142,32 +143,32 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
         );
     }else{ // FMT_H263
         asm volatile(
-            "movd %%eax, %%mm3			\n\t" // last_non_zero_p1
+            "movd %%"REG_a", %%mm3		\n\t" // last_non_zero_p1
             SPREADW(%%mm3)
             "pxor %%mm7, %%mm7			\n\t" // 0
             "pxor %%mm4, %%mm4			\n\t" // 0
-            "movl $-128, %%eax			\n\t"
+            "mov $-128, %%"REG_a"		\n\t"
             ".balign 16				\n\t"
             "1:					\n\t"
             "pxor %%mm1, %%mm1			\n\t" // 0
-            "movq (%1, %%eax), %%mm0		\n\t" // block[i]
+            "movq (%1, %%"REG_a"), %%mm0	\n\t" // block[i]
             "pcmpgtw %%mm0, %%mm1		\n\t" // block[i] <= 0 ? 0xFF : 0x00
             "pxor %%mm1, %%mm0			\n\t" 
             "psubw %%mm1, %%mm0			\n\t" // ABS(block[i])
-            "movq (%3, %%eax), %%mm6		\n\t" // bias[0]
+            "movq (%3, %%"REG_a"), %%mm6	\n\t" // bias[0]
             "paddusw %%mm6, %%mm0		\n\t" // ABS(block[i]) + bias[0]
-            "movq (%2, %%eax), %%mm5		\n\t" // qmat[i]
+            "movq (%2, %%"REG_a"), %%mm5		\n\t" // qmat[i]
             "pmulhw %%mm5, %%mm0		\n\t" // (ABS(block[i])*qmat[0] + bias[0]*qmat[0])>>16
             "por %%mm0, %%mm4			\n\t" 
             "pxor %%mm1, %%mm0			\n\t" 
             "psubw %%mm1, %%mm0			\n\t" // out=((ABS(block[i])*qmat[0] - bias[0]*qmat[0])>>16)*sign(block[i])
-            "movq %%mm0, (%5, %%eax)		\n\t"
+            "movq %%mm0, (%5, %%"REG_a")	\n\t"
             "pcmpeqw %%mm7, %%mm0		\n\t" // out==0 ? 0xFF : 0x00
-            "movq (%4, %%eax), %%mm1		\n\t" 
-            "movq %%mm7, (%1, %%eax)		\n\t" // 0
+            "movq (%4, %%"REG_a"), %%mm1		\n\t" 
+            "movq %%mm7, (%1, %%"REG_a")		\n\t" // 0
             "pandn %%mm1, %%mm0			\n\t"
 	    PMAXW(%%mm0, %%mm3)
-            "addl $8, %%eax			\n\t"
+            "add $8, %%"REG_a"			\n\t"
             " js 1b				\n\t"
             "movq %%mm3, %%mm0			\n\t"
             "psrlq $32, %%mm3			\n\t"
@@ -175,8 +176,8 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
             "movq %%mm3, %%mm0			\n\t"
             "psrlq $16, %%mm3			\n\t"
 	    PMAXW(%%mm0, %%mm3)
-            "movd %%mm3, %%eax			\n\t"
-            "movzbl %%al, %%eax			\n\t" // last_non_zero_p1
+            "movd %%mm3, %%"REG_a"		\n\t"
+            "movzb %%al, %%"REG_a"		\n\t" // last_non_zero_p1
 	    : "+a" (last_non_zero_p1)
             : "r" (block+64), "r" (qmat+64), "r" (bias+64),
               "r" (inv_zigzag_direct16+64), "r" (temp_block+64)
-- 
cgit v1.2.3