Ticket #1647: #1647-rename-the-remaining-instances-of-HAVE_MMX2-to-HAVE_.patch

File #1647-rename-the-remaining-instances-of-HAVE_MMX2-to-HAVE_.patch, 24.9 KB (added by xhmikosr, 9 months ago)

  • configure 

    From dd9765bf4ca9f94a3d44b205c247a84d44f6b8bf Mon Sep 17 00:00:00 2001
From: XhmikosR <xhmikosr@users.sourceforge.net>
Date: Thu, 16 Aug 2012 23:46:54 +0300
Subject: [PATCH] rename the remaining instances of HAVE_MMX2 to HAVE_MMXEXT

---
 configure                                  |  1 -
 libavfilter/libmpcodecs/libvo/fastmemcpy.h |  2 +-
 libavfilter/libmpcodecs/vf_fspp.c          |  2 +-
 libavfilter/libmpcodecs/vf_noise.c         |  6 +-
 libavfilter/libmpcodecs/vf_pp7.c           |  2 +-
 libavfilter/libmpcodecs/vf_spp.c           |  2 +-
 libavfilter/libmpcodecs/vf_unsharp.c       |  2 +-
 libavfilter/libmpcodecs/vf_uspp.c          |  2 +-
 libavutil/utils.c                          |  1 -
 libpostproc/postprocess.c                  | 22 +++----
 libpostproc/postprocess_template.c         | 98 +++++++++++++++---------------
 libswscale/swscale.c                       |  2 +-
 libswscale/x86/swscale.c                   |  2 +-
 13 files changed, 71 insertions(+), 73 deletions(-)

diff --git a/configure b/configure
index 10973b9..487da66 100755
    a b cat > $TMPH <<EOF 
    40754075#define EXTERN_PREFIX "${extern_prefix}" 
    40764076#define EXTERN_ASM ${extern_prefix} 
    40774077#define SLIBSUF "$SLIBSUF" 
    4078 #define HAVE_MMX2 HAVE_MMXEXT 
    40794078EOF 
    40804079 
    40814080test -n "$assert_level" && 

  • libavfilter/libmpcodecs/libvo/fastmemcpy.h 

    diff --git a/libavfilter/libmpcodecs/libvo/fastmemcpy.h b/libavfilter/libmpcodecs/libvo/fastmemcpy.h
index 5a17d01..f1a9127 100644
    a b  
    2626void * fast_memcpy(void * to, const void * from, size_t len); 
    2727void * mem2agpcpy(void * to, const void * from, size_t len); 
    2828 
    29 #if ! defined(CONFIG_FASTMEMCPY) || ! (HAVE_MMX || HAVE_MMX2 || HAVE_AMD3DNOW /* || HAVE_SSE || HAVE_SSE2 */) 
     29#if ! defined(CONFIG_FASTMEMCPY) || ! (HAVE_MMX || HAVE_MMXEXT || HAVE_AMD3DNOW /* || HAVE_SSE || HAVE_SSE2 */) 
    3030#define mem2agpcpy(a,b,c) memcpy(a,b,c) 
    3131#define fast_memcpy(a,b,c) memcpy(a,b,c) 
    3232#endif 

  • libavfilter/libmpcodecs/vf_fspp.c 

    diff --git a/libavfilter/libmpcodecs/vf_fspp.c b/libavfilter/libmpcodecs/vf_fspp.c
index 3653187..2ef7e19 100644
    a b static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts) 
    566566#if HAVE_MMX 
    567567    if(gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t"); 
    568568#endif 
    569 #if HAVE_MMX2 
     569#if HAVE_MMXEXT 
    570570    if(gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t"); 
    571571#endif 
    572572    return vf_next_put_image(vf,dmpi, pts); 

  • libavfilter/libmpcodecs/vf_noise.c 

    diff --git a/libavfilter/libmpcodecs/vf_noise.c b/libavfilter/libmpcodecs/vf_noise.c
index 9521619..9218ff8 100644
    a b static inline void lineNoise_MMX(uint8_t *dst, uint8_t *src, int8_t *noise, int 
    175175#endif 
    176176 
    177177//duplicate of previous except movntq 
    178 #if HAVE_MMX2 
     178#if HAVE_MMXEXT 
    179179static inline void lineNoise_MMX2(uint8_t *dst, uint8_t *src, int8_t *noise, int len, int shift){ 
    180180        x86_reg mmx_len= len&(~7); 
    181181        noise+=shift; 
    … … static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){ 
    360360#if HAVE_MMX 
    361361        if(gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t"); 
    362362#endif 
    363 #if HAVE_MMX2 
     363#if HAVE_MMXEXT 
    364364        if(gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t"); 
    365365#endif 
    366366 
    … … static int vf_open(vf_instance_t *vf, char *args){ 
    454454        lineNoiseAvg= lineNoiseAvg_MMX; 
    455455    } 
    456456#endif 
    457 #if HAVE_MMX2 
     457#if HAVE_MMXEXT 
    458458    if(gCpuCaps.hasMMX2) lineNoise= lineNoise_MMX2; 
    459459//    if(gCpuCaps.hasMMX) lineNoiseAvg= lineNoiseAvg_MMX2; 
    460460#endif 

  • libavfilter/libmpcodecs/vf_pp7.c 

    diff --git a/libavfilter/libmpcodecs/vf_pp7.c b/libavfilter/libmpcodecs/vf_pp7.c
index eae30bf..9bcc7ab 100644
    a b static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){ 
    402402#if HAVE_MMX 
    403403    if(gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t"); 
    404404#endif 
    405 #if HAVE_MMX2 
     405#if HAVE_MMXEXT 
    406406    if(gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t"); 
    407407#endif 
    408408 

  • libavfilter/libmpcodecs/vf_spp.c 

    diff --git a/libavfilter/libmpcodecs/vf_spp.c b/libavfilter/libmpcodecs/vf_spp.c
index 0b4b230..e747d74 100644
    a b static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){ 
    510510#if HAVE_MMX 
    511511        if(gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t"); 
    512512#endif 
    513 #if HAVE_MMX2 
     513#if HAVE_MMXEXT 
    514514        if(gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t"); 
    515515#endif 
    516516 

  • libavfilter/libmpcodecs/vf_unsharp.c 

    diff --git a/libavfilter/libmpcodecs/vf_unsharp.c b/libavfilter/libmpcodecs/vf_unsharp.c
index db22f78..75d6e5b 100644
    a b static int put_image( struct vf_instance *vf, mp_image_t *mpi, double pts) { 
    196196    if(gCpuCaps.hasMMX) 
    197197        __asm__ volatile ("emms\n\t"); 
    198198#endif 
    199 #if HAVE_MMX2 
     199#if HAVE_MMXEXT 
    200200    if(gCpuCaps.hasMMX2) 
    201201        __asm__ volatile ("sfence\n\t"); 
    202202#endif 

  • libavfilter/libmpcodecs/vf_uspp.c 

    diff --git a/libavfilter/libmpcodecs/vf_uspp.c b/libavfilter/libmpcodecs/vf_uspp.c
index cc9a3db..239f671 100644
    a b static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){ 
    291291#if HAVE_MMX 
    292292    if(gCpuCaps.hasMMX) __asm__ volatile ("emms\n\t"); 
    293293#endif 
    294 #if HAVE_MMX2 
     294#if HAVE_MMXEXT 
    295295    if(gCpuCaps.hasMMX2) __asm__ volatile ("sfence\n\t"); 
    296296#endif 
    297297 

  • libavutil/utils.c 

    diff --git a/libavutil/utils.c b/libavutil/utils.c
index 127c4b1..971b48b 100644
    a b unsigned avutil_version(void) 
    3333    av_assert0(AVMEDIA_TYPE_ATTACHMENT == 4); 
    3434    av_assert0(AV_PICTURE_TYPE_BI == 7); 
    3535    av_assert0(LIBAVUTIL_VERSION_MICRO >= 100); 
    36     av_assert0(HAVE_MMX2 == HAVE_MMXEXT); 
    3736 
    3837    return LIBAVUTIL_VERSION_INT; 
    3938} 

  • libpostproc/postprocess.c 

    diff --git a/libpostproc/postprocess.c b/libpostproc/postprocess.c
index 2234ba8..3c3f68c 100644
    a b try to unroll inner for(x=0 ... loop to avoid these damn if(x ... checks 
    8080#include <stdio.h> 
    8181#include <stdlib.h> 
    8282#include <string.h> 
    83 //#undef HAVE_MMX2 
     83//#undef HAVE_MMXEXT 
    8484//#define HAVE_AMD3DNOW 
    8585//#undef HAVE_MMX 
    8686//#undef ARCH_X86 
    … … static av_always_inline void do_a_deblock_C(uint8_t *src, int step, int stride, 
    546546 
    547547#if ARCH_X86 
    548548 
    549 #if (HAVE_MMX && !HAVE_AMD3DNOW && !HAVE_MMX2) || CONFIG_RUNTIME_CPUDETECT 
     549#if (HAVE_MMX && !HAVE_AMD3DNOW && !HAVE_MMXEXT) || CONFIG_RUNTIME_CPUDETECT 
    550550#define COMPILE_MMX 
    551551#endif 
    552552 
    553 #if HAVE_MMX2 || CONFIG_RUNTIME_CPUDETECT 
     553#if HAVE_MMXEXT || CONFIG_RUNTIME_CPUDETECT 
    554554#define COMPILE_MMX2 
    555555#endif 
    556556 
    557 #if (HAVE_AMD3DNOW && !HAVE_MMX2) || CONFIG_RUNTIME_CPUDETECT 
     557#if (HAVE_AMD3DNOW && !HAVE_MMXEXT) || CONFIG_RUNTIME_CPUDETECT 
    558558#define COMPILE_3DNOW 
    559559#endif 
    560560#endif /* ARCH_X86 */ 
    561561 
    562562#undef HAVE_MMX 
    563563#define HAVE_MMX 0 
    564 #undef HAVE_MMX2 
    565 #define HAVE_MMX2 0 
     564#undef HAVE_MMXEXT 
     565#define HAVE_MMXEXT 0 
    566566#undef HAVE_AMD3DNOW 
    567567#define HAVE_AMD3DNOW 0 
    568568#undef HAVE_ALTIVEC 
    … … static av_always_inline void do_a_deblock_C(uint8_t *src, int step, int stride, 
    595595#ifdef COMPILE_MMX2 
    596596#undef RENAME 
    597597#undef HAVE_MMX 
    598 #undef HAVE_MMX2 
     598#undef HAVE_MMXEXT 
    599599#define HAVE_MMX 1 
    600 #define HAVE_MMX2 1 
     600#define HAVE_MMXEXT 1 
    601601#define RENAME(a) a ## _MMX2 
    602602#include "postprocess_template.c" 
    603603#endif 
    … … static av_always_inline void do_a_deblock_C(uint8_t *src, int step, int stride, 
    606606#ifdef COMPILE_3DNOW 
    607607#undef RENAME 
    608608#undef HAVE_MMX 
    609 #undef HAVE_MMX2 
     609#undef HAVE_MMXEXT 
    610610#undef HAVE_AMD3DNOW 
    611611#define HAVE_MMX 1 
    612 #define HAVE_MMX2 0 
     612#define HAVE_MMXEXT 0 
    613613#define HAVE_AMD3DNOW 1 
    614614#define RENAME(a) a ## _3DNow 
    615615#include "postprocess_template.c" 
    … … static inline void postProcess(const uint8_t src[], int srcStride, uint8_t dst[] 
    652652            postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c); 
    653653#endif 
    654654#else /* CONFIG_RUNTIME_CPUDETECT */ 
    655 #if   HAVE_MMX2 
     655#if   HAVE_MMXEXT 
    656656            postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c); 
    657657#elif HAVE_AMD3DNOW 
    658658            postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c); 

  • libpostproc/postprocess_template.c 

    diff --git a/libpostproc/postprocess_template.c b/libpostproc/postprocess_template.c
index 0fb2da4..a6752df 100644
    a b  
    3030#undef PMINUB 
    3131#undef PMAXUB 
    3232 
    33 #if   HAVE_MMX2 
     33#if   HAVE_MMXEXT 
    3434#define REAL_PAVGB(a,b) "pavgb " #a ", " #b " \n\t" 
    3535#elif HAVE_AMD3DNOW 
    3636#define REAL_PAVGB(a,b) "pavgusb " #a ", " #b " \n\t" 
    3737#endif 
    3838#define PAVGB(a,b)  REAL_PAVGB(a,b) 
    3939 
    40 #if   HAVE_MMX2 
     40#if   HAVE_MMXEXT 
    4141#define PMINUB(a,b,t) "pminub " #a ", " #b " \n\t" 
    4242#elif HAVE_MMX 
    4343#define PMINUB(b,a,t) \ 
    … …  
    4646    "psubb " #t ", " #a " \n\t" 
    4747#endif 
    4848 
    49 #if   HAVE_MMX2 
     49#if   HAVE_MMXEXT 
    5050#define PMAXUB(a,b) "pmaxub " #a ", " #b " \n\t" 
    5151#elif HAVE_MMX 
    5252#define PMAXUB(a,b) \ 
    … … static inline int RENAME(vertClassify)(uint8_t src[], int stride, PPContext *c){ 
    135135        "psubusb %%mm3, %%mm4                   \n\t" 
    136136 
    137137        "                                       \n\t" 
    138 #if HAVE_MMX2 
     138#if HAVE_MMXEXT 
    139139        "pxor %%mm7, %%mm7                      \n\t" 
    140140        "psadbw %%mm7, %%mm0                    \n\t" 
    141141#else 
    … … static inline int RENAME(vertClassify)(uint8_t src[], int stride, PPContext *c){ 
    178178#if !HAVE_ALTIVEC 
    179179static inline void RENAME(doVertLowPass)(uint8_t *src, int stride, PPContext *c) 
    180180{ 
    181 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     181#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    182182    src+= stride*3; 
    183183    __asm__ volatile(        //"movv %0 %1 %2\n\t" 
    184184        "movq %2, %%mm0                         \n\t"  // QP,..., QP 
    … … static inline void RENAME(doVertLowPass)(uint8_t *src, int stride, PPContext *c) 
    305305        : "r" (src), "r" ((x86_reg)stride), "m" (c->pQPb) 
    306306        : "%"REG_a, "%"REG_c 
    307307    ); 
    308 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     308#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    309309    const int l1= stride; 
    310310    const int l2= stride + l1; 
    311311    const int l3= stride + l2; 
    … … static inline void RENAME(doVertLowPass)(uint8_t *src, int stride, PPContext *c) 
    344344 
    345345        src++; 
    346346    } 
    347 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     347#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    348348} 
    349349#endif //HAVE_ALTIVEC 
    350350 
    … … static inline void RENAME(doVertLowPass)(uint8_t *src, int stride, PPContext *c) 
    357357 */ 
    358358static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co) 
    359359{ 
    360 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     360#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    361361    src+= stride*3; 
    362362 
    363363    __asm__ volatile( 
    … … static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co) 
    443443        : "r" (src), "r" ((x86_reg)stride), "m" (co->pQPb) 
    444444        : "%"REG_a, "%"REG_c 
    445445    ); 
    446 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     446#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    447447 
    448448    const int l1= stride; 
    449449    const int l2= stride + l1; 
    … … static inline void RENAME(vertX1Filter)(uint8_t *src, int stride, PPContext *co) 
    477477        } 
    478478        src++; 
    479479    } 
    480 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     480#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    481481} 
    482482 
    483483#if !HAVE_ALTIVEC 
    484484static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext *c) 
    485485{ 
    486 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     486#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    487487/* 
    488488    uint8_t tmp[16]; 
    489489    const int l1= stride; 
    … … static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext 
    872872        "movq (%3), %%mm2                       \n\t" // 2L0 - 5L1 + 5L2 - 2L3 
    873873        "movq 8(%3), %%mm3                      \n\t" // 2H0 - 5H1 + 5H2 - 2H3 
    874874 
    875 #if HAVE_MMX2 
     875#if HAVE_MMXEXT 
    876876        "movq %%mm7, %%mm6                      \n\t" // 0 
    877877        "psubw %%mm0, %%mm6                     \n\t" 
    878878        "pmaxsw %%mm6, %%mm0                    \n\t" // |2L4 - 5L5 + 5L6 - 2L7| 
    … … static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext 
    904904        "psubw %%mm6, %%mm3                     \n\t" // |2H0 - 5H1 + 5H2 - 2H3| 
    905905#endif 
    906906 
    907 #if HAVE_MMX2 
     907#if HAVE_MMXEXT 
    908908        "pminsw %%mm2, %%mm0                    \n\t" 
    909909        "pminsw %%mm3, %%mm1                    \n\t" 
    910910#else 
    … … static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext 
    968968        "pand %%mm2, %%mm4                      \n\t" 
    969969        "pand %%mm3, %%mm5                      \n\t" 
    970970 
    971 #if HAVE_MMX2 
     971#if HAVE_MMXEXT 
    972972        "pminsw %%mm0, %%mm4                    \n\t" 
    973973        "pminsw %%mm1, %%mm5                    \n\t" 
    974974#else 
    … … static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext 
    995995        : "r" ((x86_reg)stride), "m" (c->pQPb), "r"(tmp) 
    996996        : "%"REG_a 
    997997    ); 
    998 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     998#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    999999    const int l1= stride; 
    10001000    const int l2= stride + l1; 
    10011001    const int l3= stride + l2; 
    … … static inline void RENAME(doVertDefFilter)(uint8_t src[], int stride, PPContext 
    10331033        } 
    10341034        src++; 
    10351035    } 
    1036 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     1036#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    10371037} 
    10381038#endif //HAVE_ALTIVEC 
    10391039 
    10401040#if !HAVE_ALTIVEC 
    10411041static inline void RENAME(dering)(uint8_t src[], int stride, PPContext *c) 
    10421042{ 
    1043 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     1043#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    10441044    DECLARE_ALIGNED(8, uint64_t, tmp)[3]; 
    10451045    __asm__ volatile( 
    10461046        "pxor %%mm6, %%mm6                      \n\t" 
    … … static inline void RENAME(dering)(uint8_t src[], int stride, PPContext *c) 
    10601060 
    10611061#undef REAL_FIND_MIN_MAX 
    10621062#undef FIND_MIN_MAX 
    1063 #if HAVE_MMX2 
     1063#if HAVE_MMXEXT 
    10641064#define REAL_FIND_MIN_MAX(addr)\ 
    10651065        "movq " #addr ", %%mm0                  \n\t"\ 
    10661066        "pminub %%mm0, %%mm7                    \n\t"\ 
    … … FIND_MIN_MAX((%0, %1, 8)) 
    10871087 
    10881088        "movq %%mm7, %%mm4                      \n\t" 
    10891089        "psrlq $8, %%mm7                        \n\t" 
    1090 #if HAVE_MMX2 
     1090#if HAVE_MMXEXT 
    10911091        "pminub %%mm4, %%mm7                    \n\t" // min of pixels 
    10921092        "pshufw $0xF9, %%mm7, %%mm4             \n\t" 
    10931093        "pminub %%mm4, %%mm7                    \n\t" // min of pixels 
    … … FIND_MIN_MAX((%0, %1, 8)) 
    11121112 
    11131113        "movq %%mm6, %%mm4                      \n\t" 
    11141114        "psrlq $8, %%mm6                        \n\t" 
    1115 #if HAVE_MMX2 
     1115#if HAVE_MMXEXT 
    11161116        "pmaxub %%mm4, %%mm6                    \n\t" // max of pixels 
    11171117        "pshufw $0xF9, %%mm6, %%mm4             \n\t" 
    11181118        "pmaxub %%mm4, %%mm6                    \n\t" 
    … … DERING_CORE((%0, %1, 8) ,(%%REGd, %1, 4),%%mm2,%%mm4,%%mm0,%%mm3,%%mm5,%%mm1, 
    12661266        : : "r" (src), "r" ((x86_reg)stride), "m" (c->pQPb), "m"(c->pQPb2), "q"(tmp) 
    12671267        : "%"REG_a, "%"REG_d 
    12681268    ); 
    1269 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     1269#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    12701270    int y; 
    12711271    int min=255; 
    12721272    int max=0; 
    … … DERING_CORE((%0, %1, 8) ,(%%REGd, %1, 4),%%mm2,%%mm4,%%mm0,%%mm3,%%mm5,%%mm1, 
    13831383//        src[0] = src[7]=src[stride*7]=src[stride*7 + 7]=255; 
    13841384    } 
    13851385#endif 
    1386 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     1386#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    13871387} 
    13881388#endif //HAVE_ALTIVEC 
    13891389 
    … … DERING_CORE((%0, %1, 8) ,(%%REGd, %1, 4),%%mm2,%%mm4,%%mm0,%%mm3,%%mm5,%%mm1, 
    13951395 */ 
    13961396static inline void RENAME(deInterlaceInterpolateLinear)(uint8_t src[], int stride) 
    13971397{ 
    1398 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     1398#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    13991399    src+= 4*stride; 
    14001400    __asm__ volatile( 
    14011401        "lea (%0, %1), %%"REG_a"                \n\t" 
    … … static inline void RENAME(deInterlaceInterpolateLinear)(uint8_t src[], int strid 
    14481448 */ 
    14491449static inline void RENAME(deInterlaceInterpolateCubic)(uint8_t src[], int stride) 
    14501450{ 
    1451 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     1451#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    14521452    src+= stride*3; 
    14531453    __asm__ volatile( 
    14541454        "lea (%0, %1), %%"REG_a"                \n\t" 
    … … DEINT_CUBIC((%%REGd, %1), (%0, %1, 8) , (%%REGd, %1, 4), (%%REGc) , (%%REGc, 
    14901490        : : "r" (src), "r" ((x86_reg)stride) 
    14911491        : "%"REG_a, "%"REG_d, "%"REG_c 
    14921492    ); 
    1493 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     1493#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    14941494    int x; 
    14951495    src+= stride*3; 
    14961496    for(x=0; x<8; x++){ 
    … … DEINT_CUBIC((%%REGd, %1), (%0, %1, 8) , (%%REGd, %1, 4), (%%REGc) , (%%REGc, 
    15001500        src[stride*9] = CLIP((-src[stride*6] + 9*src[stride*8] + 9*src[stride*10] - src[stride*12])>>4); 
    15011501        src++; 
    15021502    } 
    1503 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     1503#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    15041504} 
    15051505 
    15061506/** 
    … … DEINT_CUBIC((%%REGd, %1), (%0, %1, 8) , (%%REGd, %1, 4), (%%REGc) , (%%REGc, 
    15121512 */ 
    15131513static inline void RENAME(deInterlaceFF)(uint8_t src[], int stride, uint8_t *tmp) 
    15141514{ 
    1515 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     1515#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    15161516    src+= stride*4; 
    15171517    __asm__ volatile( 
    15181518        "lea (%0, %1), %%"REG_a"                \n\t" 
    … … DEINT_FF((%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4)) 
    15611561        : : "r" (src), "r" ((x86_reg)stride), "r"(tmp) 
    15621562        : "%"REG_a, "%"REG_d 
    15631563    ); 
    1564 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     1564#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    15651565    int x; 
    15661566    src+= stride*4; 
    15671567    for(x=0; x<8; x++){ 
    … … DEINT_FF((%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4)) 
    15791579 
    15801580        src++; 
    15811581    } 
    1582 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     1582#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    15831583} 
    15841584 
    15851585/** 
    … … DEINT_FF((%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4)) 
    15911591 */ 
    15921592static inline void RENAME(deInterlaceL5)(uint8_t src[], int stride, uint8_t *tmp, uint8_t *tmp2) 
    15931593{ 
    1594 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     1594#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    15951595    src+= stride*4; 
    15961596    __asm__ volatile( 
    15971597        "lea (%0, %1), %%"REG_a"                \n\t" 
    … … DEINT_L5(%%mm1, %%mm0, (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4)) 
    16511651        : : "r" (src), "r" ((x86_reg)stride), "r"(tmp), "r"(tmp2) 
    16521652        : "%"REG_a, "%"REG_d 
    16531653    ); 
    1654 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     1654#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    16551655    int x; 
    16561656    src+= stride*4; 
    16571657    for(x=0; x<8; x++){ 
    … … DEINT_L5(%%mm1, %%mm0, (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4)) 
    16801680 
    16811681        src++; 
    16821682    } 
    1683 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     1683#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    16841684} 
    16851685 
    16861686/** 
    … … DEINT_L5(%%mm1, %%mm0, (%%REGd, %1, 2), (%0, %1, 8) , (%%REGd, %1, 4)) 
    16921692 */ 
    16931693static inline void RENAME(deInterlaceBlendLinear)(uint8_t src[], int stride, uint8_t *tmp) 
    16941694{ 
    1695 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     1695#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    16961696    src+= 4*stride; 
    16971697    __asm__ volatile( 
    16981698        "lea (%0, %1), %%"REG_a"                \n\t" 
    … … static inline void RENAME(deInterlaceBlendLinear)(uint8_t src[], int stride, uin 
    17391739        : : "r" (src), "r" ((x86_reg)stride), "r" (tmp) 
    17401740        : "%"REG_a, "%"REG_d 
    17411741    ); 
    1742 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     1742#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    17431743    int a, b, c, x; 
    17441744    src+= 4*stride; 
    17451745 
    … … static inline void RENAME(deInterlaceBlendLinear)(uint8_t src[], int stride, uin 
    17821782        src += 4; 
    17831783        tmp += 4; 
    17841784    } 
    1785 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     1785#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    17861786} 
    17871787 
    17881788/** 
    … … static inline void RENAME(deInterlaceMedian)(uint8_t src[], int stride) 
    17951795{ 
    17961796#if HAVE_MMX 
    17971797    src+= 4*stride; 
    1798 #if HAVE_MMX2 
     1798#if HAVE_MMXEXT 
    17991799    __asm__ volatile( 
    18001800        "lea (%0, %1), %%"REG_a"                \n\t" 
    18011801        "lea (%%"REG_a", %1, 4), %%"REG_d"      \n\t" 
    … … MEDIAN((%%REGd, %1), (%%REGd, %1, 2), (%0, %1, 8)) 
    18851885        : : "r" (src), "r" ((x86_reg)stride) 
    18861886        : "%"REG_a, "%"REG_d 
    18871887    ); 
    1888 #endif //HAVE_MMX2 
     1888#endif //HAVE_MMXEXT 
    18891889#else //HAVE_MMX 
    18901890    int x, y; 
    18911891    src+= 4*stride; 
    … … static inline void RENAME(tempNoiseReducer)(uint8_t *src, int stride, 
    20872087 
    20882088#define FAST_L2_DIFF 
    20892089//#define L1_DIFF //u should change the thresholds too if u try that one 
    2090 #if HAVE_MMX2 || HAVE_AMD3DNOW 
     2090#if HAVE_MMXEXT || HAVE_AMD3DNOW 
    20912091    __asm__ volatile( 
    20922092        "lea (%2, %2, 2), %%"REG_a"             \n\t" // 3*stride 
    20932093        "lea (%2, %2, 4), %%"REG_d"             \n\t" // 5*stride 
    … … L2_DIFF_CORE((%0, %%REGc) , (%1, %%REGc)) 
    23752375        :: "r" (src), "r" (tempBlurred), "r"((x86_reg)stride), "m" (tempBlurredPast) 
    23762376        : "%"REG_a, "%"REG_d, "%"REG_c, "memory" 
    23772377    ); 
    2378 #else //HAVE_MMX2 || HAVE_AMD3DNOW 
     2378#else //HAVE_MMXEXT || HAVE_AMD3DNOW 
    23792379{ 
    23802380    int y; 
    23812381    int d=0; 
    … … Switch between 
    24582458        } 
    24592459    } 
    24602460} 
    2461 #endif //HAVE_MMX2 || HAVE_AMD3DNOW 
     2461#endif //HAVE_MMXEXT || HAVE_AMD3DNOW 
    24622462} 
    24632463#endif //HAVE_ALTIVEC 
    24642464 
    … … static av_always_inline void RENAME(do_a_deblock)(uint8_t *src, int step, int st 
    28652865            "movq (%4), %%mm2                       \n\t" // 2L0 - 5L1 + 5L2 - 2L3 
    28662866            "movq 8(%4), %%mm3                      \n\t" // 2H0 - 5H1 + 5H2 - 2H3 
    28672867 
    2868 #if HAVE_MMX2 
     2868#if HAVE_MMXEXT 
    28692869            "movq %%mm7, %%mm6                      \n\t" // 0 
    28702870            "psubw %%mm0, %%mm6                     \n\t" 
    28712871            "pmaxsw %%mm6, %%mm0                    \n\t" // |2L4 - 5L5 + 5L6 - 2L7| 
    … … static av_always_inline void RENAME(do_a_deblock)(uint8_t *src, int step, int st 
    28972897            "psubw %%mm6, %%mm3                     \n\t" // |2H0 - 5H1 + 5H2 - 2H3| 
    28982898#endif 
    28992899 
    2900 #if HAVE_MMX2 
     2900#if HAVE_MMXEXT 
    29012901            "pminsw %%mm2, %%mm0                    \n\t" 
    29022902            "pminsw %%mm3, %%mm1                    \n\t" 
    29032903#else 
    … … static av_always_inline void RENAME(do_a_deblock)(uint8_t *src, int step, int st 
    29612961            "pand %%mm2, %%mm4                      \n\t" 
    29622962            "pand %%mm3, %%mm5                      \n\t" 
    29632963 
    2964 #if HAVE_MMX2 
     2964#if HAVE_MMXEXT 
    29652965            "pminsw %%mm0, %%mm4                    \n\t" 
    29662966            "pminsw %%mm1, %%mm5                    \n\t" 
    29672967#else 
    … … static inline void RENAME(blockCopy)(uint8_t dst[], int dstStride, const uint8_t 
    30243024        "lea (%2,%4), %%"REG_a"         \n\t" 
    30253025        "lea (%3,%5), %%"REG_d"         \n\t" 
    30263026        "pxor %%mm4, %%mm4              \n\t" 
    3027 #if HAVE_MMX2 
     3027#if HAVE_MMXEXT 
    30283028#define REAL_SCALED_CPY(src1, src2, dst1, dst2)                                                \ 
    30293029        "movq " #src1 ", %%mm0          \n\t"\ 
    30303030        "movq " #src1 ", %%mm5          \n\t"\ 
    … … static inline void RENAME(blockCopy)(uint8_t dst[], int dstStride, const uint8_t 
    30473047        "movq %%mm0, " #dst1 "          \n\t"\ 
    30483048        "movq %%mm1, " #dst2 "          \n\t"\ 
    30493049 
    3050 #else //HAVE_MMX2 
     3050#else //HAVE_MMXEXT 
    30513051#define REAL_SCALED_CPY(src1, src2, dst1, dst2)                                        \ 
    30523052        "movq " #src1 ", %%mm0          \n\t"\ 
    30533053        "movq " #src1 ", %%mm5          \n\t"\ 
    … … static inline void RENAME(blockCopy)(uint8_t dst[], int dstStride, const uint8_t 
    30743074        "movq %%mm0, " #dst1 "          \n\t"\ 
    30753075        "movq %%mm1, " #dst2 "          \n\t"\ 
    30763076 
    3077 #endif //HAVE_MMX2 
     3077#endif //HAVE_MMXEXT 
    30783078#define SCALED_CPY(src1, src2, dst1, dst2)\ 
    30793079   REAL_SCALED_CPY(src1, src2, dst1, dst2) 
    30803080 
    … … static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[ 
    32483248 
    32493249        scale= (double)(c.ppMode.maxAllowedY - c.ppMode.minAllowedY) / (double)(white-black); 
    32503250 
    3251 #if HAVE_MMX2 
     3251#if HAVE_MMXEXT 
    32523252        c.packedYScale= (uint16_t)(scale*256.0 + 0.5); 
    32533253        c.packedYOffset= (((black*c.packedYScale)>>8) - c.ppMode.minAllowedY) & 0xFFFF; 
    32543254#else 
    … … static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[ 
    32813281        // with the L1 Cache of the P4 ... or only a few blocks at a time or soemthing 
    32823282        for(x=0; x<width; x+=BLOCK_SIZE){ 
    32833283 
    3284 #if HAVE_MMX2 
     3284#if HAVE_MMXEXT 
    32853285/* 
    32863286            prefetchnta(srcBlock + (((x>>2)&6) + 5)*srcStride + 32); 
    32873287            prefetchnta(srcBlock + (((x>>2)&6) + 6)*srcStride + 32); 
    … … static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[ 
    34173417#endif 
    34183418 
    34193419 
    3420 #if HAVE_MMX2 
     3420#if HAVE_MMXEXT 
    34213421/* 
    34223422            prefetchnta(srcBlock + (((x>>2)&6) + 5)*srcStride + 32); 
    34233423            prefetchnta(srcBlock + (((x>>2)&6) + 6)*srcStride + 32); 

  • libswscale/swscale.c 

    diff --git a/libswscale/swscale.c b/libswscale/swscale.c
index ae79eb6..07443db 100644
    a b static int swScale(SwsContext *c, const uint8_t *src[], 
    422422    ) { 
    423423        static int warnedAlready=0; 
    424424        int cpu_flags = av_get_cpu_flags(); 
    425         if (HAVE_MMX2 && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){ 
     425        if (HAVE_MMXEXT && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){ 
    426426            av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speedloss\n"); 
    427427            warnedAlready=1; 
    428428        } 

  • libswscale/x86/swscale.c 

    diff --git a/libswscale/x86/swscale.c b/libswscale/x86/swscale.c
index 67cda51..b2e06e3 100644
    a b void updateMMXDitherTables(SwsContext *c, int dstY, int lumBufIndex, int chrBufI 
    204204    } 
    205205} 
    206206 
    207 #if HAVE_MMX2 
     207#if HAVE_MMXEXT 
    208208static void yuv2yuvX_sse3(const int16_t *filter, int filterSize, 
    209209                           const int16_t **src, uint8_t *dest, int dstW, 
    210210                           const uint8_t *dither, int offset)