← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/x86/dsputil_mmx.c

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/x86/dsputil_mmx.c
42
42
DECLARE_ALIGNED(16, const uint64_t, ff_pdw_80000000)[2] =
43
43
{0x8000000080000000ULL, 0x8000000080000000ULL};
44
44
 
45
 
DECLARE_ALIGNED(8,  const uint64_t, ff_pw_1  ) = 0x0001000100010001ULL;
 
45
DECLARE_ALIGNED(16, const xmm_reg,  ff_pw_1  ) = {0x0001000100010001ULL, 0x0001000100010001ULL};
46
46
DECLARE_ALIGNED(16, const xmm_reg,  ff_pw_2  ) = {0x0002000200020002ULL, 0x0002000200020002ULL};
47
47
DECLARE_ALIGNED(16, const xmm_reg,  ff_pw_3  ) = {0x0003000300030003ULL, 0x0003000300030003ULL};
48
48
DECLARE_ALIGNED(16, const xmm_reg,  ff_pw_4  ) = {0x0004000400040004ULL, 0x0004000400040004ULL};
64
64
DECLARE_ALIGNED(8,  const uint64_t, ff_pw_96 ) = 0x0060006000600060ULL;
65
65
DECLARE_ALIGNED(8,  const uint64_t, ff_pw_128) = 0x0080008000800080ULL;
66
66
DECLARE_ALIGNED(8,  const uint64_t, ff_pw_255) = 0x00ff00ff00ff00ffULL;
 
67
DECLARE_ALIGNED(16, const xmm_reg,  ff_pw_512) = {0x0200020002000200ULL, 0x0200020002000200ULL};
 
68
DECLARE_ALIGNED(16, const xmm_reg,  ff_pw_1019)= {0x03FB03FB03FB03FBULL, 0x03FB03FB03FB03FBULL};
67
69
 
68
70
DECLARE_ALIGNED(16, const xmm_reg,  ff_pb_0  ) = {0x0000000000000000ULL, 0x0000000000000000ULL};
69
71
DECLARE_ALIGNED(16, const xmm_reg,  ff_pb_1  ) = {0x0101010101010101ULL, 0x0101010101010101ULL};
456
458
         "movdqu (%1,%3), %%xmm1        \n\t"
457
459
         "movdqu (%1,%3,2), %%xmm2      \n\t"
458
460
         "movdqu (%1,%4), %%xmm3        \n\t"
 
461
         "lea (%1,%3,4), %1             \n\t"
459
462
         "movdqa %%xmm0, (%2)           \n\t"
460
463
         "movdqa %%xmm1, (%2,%3)        \n\t"
461
464
         "movdqa %%xmm2, (%2,%3,2)      \n\t"
462
465
         "movdqa %%xmm3, (%2,%4)        \n\t"
463
466
         "subl $4, %0                   \n\t"
464
 
         "lea (%1,%3,4), %1             \n\t"
465
467
         "lea (%2,%3,4), %2             \n\t"
466
468
         "jnz 1b                        \n\t"
467
469
         : "+g"(h), "+r" (pixels),  "+r" (block)
478
480
         "movdqu (%1,%3), %%xmm1        \n\t"
479
481
         "movdqu (%1,%3,2), %%xmm2      \n\t"
480
482
         "movdqu (%1,%4), %%xmm3        \n\t"
 
483
         "lea (%1,%3,4), %1             \n\t"
481
484
         "pavgb  (%2), %%xmm0           \n\t"
482
485
         "pavgb  (%2,%3), %%xmm1        \n\t"
483
486
         "pavgb  (%2,%3,2), %%xmm2      \n\t"
487
490
         "movdqa %%xmm2, (%2,%3,2)      \n\t"
488
491
         "movdqa %%xmm3, (%2,%4)        \n\t"
489
492
         "subl $4, %0                   \n\t"
490
 
         "lea (%1,%3,4), %1             \n\t"
491
493
         "lea (%2,%3,4), %2             \n\t"
492
494
         "jnz 1b                        \n\t"
493
495
         : "+g"(h), "+r" (pixels),  "+r" (block)
602
604
        dst[i] = src1[i] + src2[i];
603
605
}
604
606
 
605
 
#if HAVE_7REGS && HAVE_TEN_OPERANDS
 
607
#if HAVE_7REGS
606
608
static void add_hfyu_median_prediction_cmov(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top) {
607
609
    x86_reg w2 = -w;
608
610
    x86_reg x;
1665
1667
QPEL_2TAP(avg_,  8, 3dnow)
1666
1668
 
1667
1669
 
1668
 
#if 0
1669
 
static void just_return(void) { return; }
1670
 
#endif
1671
 
 
1672
1670
#if HAVE_YASM
1673
1671
typedef void emu_edge_core_func (uint8_t *buf, const uint8_t *src,
1674
1672
                                 x86_reg linesize, x86_reg start_y,
1879
1877
                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
1880
1878
{
1881
1879
    gmc(dst, src, stride, h, ox, oy, dxx, dxy, dyx, dyy, shift, r,
1882
 
        width, height, &ff_emulated_edge_mc);
 
1880
        width, height, &ff_emulated_edge_mc_8);
1883
1881
}
1884
1882
#endif
1885
1883
 
1899
1897
 
1900
1898
void ff_put_h264_chroma_mc8_mmx_rnd   (uint8_t *dst, uint8_t *src,
1901
1899
                                       int stride, int h, int x, int y);
1902
 
void ff_put_rv40_chroma_mc8_mmx       (uint8_t *dst, uint8_t *src,
1903
 
                                       int stride, int h, int x, int y);
1904
1900
void ff_avg_h264_chroma_mc8_mmx2_rnd  (uint8_t *dst, uint8_t *src,
1905
1901
                                       int stride, int h, int x, int y);
1906
 
void ff_avg_rv40_chroma_mc8_mmx2      (uint8_t *dst, uint8_t *src,
1907
 
                                       int stride, int h, int x, int y);
1908
1902
void ff_avg_h264_chroma_mc8_3dnow_rnd (uint8_t *dst, uint8_t *src,
1909
1903
                                       int stride, int h, int x, int y);
1910
 
void ff_avg_rv40_chroma_mc8_3dnow     (uint8_t *dst, uint8_t *src,
1911
 
                                       int stride, int h, int x, int y);
1912
1904
 
1913
1905
void ff_put_h264_chroma_mc4_mmx       (uint8_t *dst, uint8_t *src,
1914
1906
                                       int stride, int h, int x, int y);
1915
 
void ff_put_rv40_chroma_mc4_mmx       (uint8_t *dst, uint8_t *src,
1916
 
                                       int stride, int h, int x, int y);
1917
1907
void ff_avg_h264_chroma_mc4_mmx2      (uint8_t *dst, uint8_t *src,
1918
1908
                                       int stride, int h, int x, int y);
1919
 
void ff_avg_rv40_chroma_mc4_mmx2      (uint8_t *dst, uint8_t *src,
1920
 
                                       int stride, int h, int x, int y);
1921
1909
void ff_avg_h264_chroma_mc4_3dnow     (uint8_t *dst, uint8_t *src,
1922
1910
                                       int stride, int h, int x, int y);
1923
 
void ff_avg_rv40_chroma_mc4_3dnow     (uint8_t *dst, uint8_t *src,
1924
 
                                       int stride, int h, int x, int y);
1925
1911
 
1926
1912
void ff_put_h264_chroma_mc2_mmx2      (uint8_t *dst, uint8_t *src,
1927
1913
                                       int stride, int h, int x, int y);
2429
2415
 
2430
2416
float ff_scalarproduct_float_sse(const float *v1, const float *v2, int order);
2431
2417
 
 
2418
void ff_vector_clip_int32_mmx     (int32_t *dst, const int32_t *src, int32_t min,
 
2419
                                   int32_t max, unsigned int len);
 
2420
void ff_vector_clip_int32_sse2    (int32_t *dst, const int32_t *src, int32_t min,
 
2421
                                   int32_t max, unsigned int len);
 
2422
void ff_vector_clip_int32_int_sse2(int32_t *dst, const int32_t *src, int32_t min,
 
2423
                                   int32_t max, unsigned int len);
 
2424
void ff_vector_clip_int32_sse4    (int32_t *dst, const int32_t *src, int32_t min,
 
2425
                                   int32_t max, unsigned int len);
 
2426
 
 
2427
extern void ff_butterflies_float_interleave_sse(float *dst, const float *src0,
 
2428
                                                const float *src1, int len);
 
2429
extern void ff_butterflies_float_interleave_avx(float *dst, const float *src0,
 
2430
                                                const float *src1, int len);
 
2431
 
2432
2432
void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
2433
2433
{
2434
2434
    int mm_flags = av_get_cpu_flags();
2435
 
    const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8;
 
2435
    const int high_bit_depth = avctx->bits_per_raw_sample > 8;
2436
2436
    const int bit_depth = avctx->bits_per_raw_sample;
2437
2437
 
2438
2438
    if (avctx->dsp_mask) {
2460
2460
    if (mm_flags & AV_CPU_FLAG_MMX) {
2461
2461
        const int idct_algo= avctx->idct_algo;
2462
2462
 
2463
 
        if(avctx->lowres==0){
 
2463
        if (avctx->lowres == 0 && avctx->bits_per_raw_sample <= 8) {
2464
2464
            if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SIMPLEMMX){
2465
2465
                c->idct_put= ff_simple_idct_put_mmx;
2466
2466
                c->idct_add= ff_simple_idct_add_mmx;
2563
2563
        }
2564
2564
 
2565
2565
#if HAVE_YASM
2566
 
        if (!high_bit_depth) {
 
2566
        if (!high_bit_depth && CONFIG_H264CHROMA) {
2567
2567
        c->put_h264_chroma_pixels_tab[0]= ff_put_h264_chroma_mc8_mmx_rnd;
2568
2568
        c->put_h264_chroma_pixels_tab[1]= ff_put_h264_chroma_mc4_mmx;
2569
2569
        }
2570
2570
 
2571
 
        c->put_rv40_chroma_pixels_tab[0]= ff_put_rv40_chroma_mc8_mmx;
2572
 
        c->put_rv40_chroma_pixels_tab[1]= ff_put_rv40_chroma_mc4_mmx;
 
2571
        c->vector_clip_int32 = ff_vector_clip_int32_mmx;
2573
2572
#endif
2574
2573
 
2575
2574
        if (mm_flags & AV_CPU_FLAG_MMX2) {
2616
2615
                c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_exact_mmx2;
2617
2616
            }
2618
2617
 
2619
 
#define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU) \
2620
 
            c->PFX ## _pixels_tab[IDX][ 0] = PFX ## SIZE ## _mc00_ ## CPU; \
2621
 
            c->PFX ## _pixels_tab[IDX][ 1] = PFX ## SIZE ## _mc10_ ## CPU; \
2622
 
            c->PFX ## _pixels_tab[IDX][ 2] = PFX ## SIZE ## _mc20_ ## CPU; \
2623
 
            c->PFX ## _pixels_tab[IDX][ 3] = PFX ## SIZE ## _mc30_ ## CPU; \
2624
 
            c->PFX ## _pixels_tab[IDX][ 4] = PFX ## SIZE ## _mc01_ ## CPU; \
2625
 
            c->PFX ## _pixels_tab[IDX][ 5] = PFX ## SIZE ## _mc11_ ## CPU; \
2626
 
            c->PFX ## _pixels_tab[IDX][ 6] = PFX ## SIZE ## _mc21_ ## CPU; \
2627
 
            c->PFX ## _pixels_tab[IDX][ 7] = PFX ## SIZE ## _mc31_ ## CPU; \
2628
 
            c->PFX ## _pixels_tab[IDX][ 8] = PFX ## SIZE ## _mc02_ ## CPU; \
2629
 
            c->PFX ## _pixels_tab[IDX][ 9] = PFX ## SIZE ## _mc12_ ## CPU; \
2630
 
            c->PFX ## _pixels_tab[IDX][10] = PFX ## SIZE ## _mc22_ ## CPU; \
2631
 
            c->PFX ## _pixels_tab[IDX][11] = PFX ## SIZE ## _mc32_ ## CPU; \
2632
 
            c->PFX ## _pixels_tab[IDX][12] = PFX ## SIZE ## _mc03_ ## CPU; \
2633
 
            c->PFX ## _pixels_tab[IDX][13] = PFX ## SIZE ## _mc13_ ## CPU; \
2634
 
            c->PFX ## _pixels_tab[IDX][14] = PFX ## SIZE ## _mc23_ ## CPU; \
2635
 
            c->PFX ## _pixels_tab[IDX][15] = PFX ## SIZE ## _mc33_ ## CPU
2636
 
 
2637
 
            SET_QPEL_FUNCS(put_qpel, 0, 16, mmx2);
2638
 
            SET_QPEL_FUNCS(put_qpel, 1, 8, mmx2);
2639
 
            SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, mmx2);
2640
 
            SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, mmx2);
2641
 
            SET_QPEL_FUNCS(avg_qpel, 0, 16, mmx2);
2642
 
            SET_QPEL_FUNCS(avg_qpel, 1, 8, mmx2);
2643
 
 
2644
 
            if (!high_bit_depth) {
2645
 
            SET_QPEL_FUNCS(put_h264_qpel, 0, 16, mmx2);
2646
 
            SET_QPEL_FUNCS(put_h264_qpel, 1, 8, mmx2);
2647
 
            SET_QPEL_FUNCS(put_h264_qpel, 2, 4, mmx2);
2648
 
            SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, mmx2);
2649
 
            SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, mmx2);
2650
 
            SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, mmx2);
2651
 
            }
2652
 
 
2653
 
            SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, mmx2);
2654
 
            SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, mmx2);
2655
 
            SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, mmx2);
2656
 
            SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, mmx2);
2657
 
 
2658
 
#if HAVE_YASM
2659
 
            c->avg_rv40_chroma_pixels_tab[0]= ff_avg_rv40_chroma_mc8_mmx2;
2660
 
            c->avg_rv40_chroma_pixels_tab[1]= ff_avg_rv40_chroma_mc4_mmx2;
2661
 
 
2662
 
            if (!high_bit_depth) {
 
2618
#define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU, PREFIX) \
 
2619
            c->PFX ## _pixels_tab[IDX][ 0] = PREFIX ## PFX ## SIZE ## _mc00_ ## CPU; \
 
2620
            c->PFX ## _pixels_tab[IDX][ 1] = PREFIX ## PFX ## SIZE ## _mc10_ ## CPU; \
 
2621
            c->PFX ## _pixels_tab[IDX][ 2] = PREFIX ## PFX ## SIZE ## _mc20_ ## CPU; \
 
2622
            c->PFX ## _pixels_tab[IDX][ 3] = PREFIX ## PFX ## SIZE ## _mc30_ ## CPU; \
 
2623
            c->PFX ## _pixels_tab[IDX][ 4] = PREFIX ## PFX ## SIZE ## _mc01_ ## CPU; \
 
2624
            c->PFX ## _pixels_tab[IDX][ 5] = PREFIX ## PFX ## SIZE ## _mc11_ ## CPU; \
 
2625
            c->PFX ## _pixels_tab[IDX][ 6] = PREFIX ## PFX ## SIZE ## _mc21_ ## CPU; \
 
2626
            c->PFX ## _pixels_tab[IDX][ 7] = PREFIX ## PFX ## SIZE ## _mc31_ ## CPU; \
 
2627
            c->PFX ## _pixels_tab[IDX][ 8] = PREFIX ## PFX ## SIZE ## _mc02_ ## CPU; \
 
2628
            c->PFX ## _pixels_tab[IDX][ 9] = PREFIX ## PFX ## SIZE ## _mc12_ ## CPU; \
 
2629
            c->PFX ## _pixels_tab[IDX][10] = PREFIX ## PFX ## SIZE ## _mc22_ ## CPU; \
 
2630
            c->PFX ## _pixels_tab[IDX][11] = PREFIX ## PFX ## SIZE ## _mc32_ ## CPU; \
 
2631
            c->PFX ## _pixels_tab[IDX][12] = PREFIX ## PFX ## SIZE ## _mc03_ ## CPU; \
 
2632
            c->PFX ## _pixels_tab[IDX][13] = PREFIX ## PFX ## SIZE ## _mc13_ ## CPU; \
 
2633
            c->PFX ## _pixels_tab[IDX][14] = PREFIX ## PFX ## SIZE ## _mc23_ ## CPU; \
 
2634
            c->PFX ## _pixels_tab[IDX][15] = PREFIX ## PFX ## SIZE ## _mc33_ ## CPU
 
2635
 
 
2636
            SET_QPEL_FUNCS(put_qpel, 0, 16, mmx2, );
 
2637
            SET_QPEL_FUNCS(put_qpel, 1, 8, mmx2, );
 
2638
            SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, mmx2, );
 
2639
            SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, mmx2, );
 
2640
            SET_QPEL_FUNCS(avg_qpel, 0, 16, mmx2, );
 
2641
            SET_QPEL_FUNCS(avg_qpel, 1, 8, mmx2, );
 
2642
 
 
2643
            if (!high_bit_depth) {
 
2644
            SET_QPEL_FUNCS(put_h264_qpel, 0, 16, mmx2, );
 
2645
            SET_QPEL_FUNCS(put_h264_qpel, 1, 8, mmx2, );
 
2646
            SET_QPEL_FUNCS(put_h264_qpel, 2, 4, mmx2, );
 
2647
            SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, mmx2, );
 
2648
            SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, mmx2, );
 
2649
            SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, mmx2, );
 
2650
            }
 
2651
            else if (bit_depth == 10) {
 
2652
#if HAVE_YASM
 
2653
#if !ARCH_X86_64
 
2654
                SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, 10_mmxext, ff_);
 
2655
                SET_QPEL_FUNCS(put_h264_qpel, 0, 16, 10_mmxext, ff_);
 
2656
                SET_QPEL_FUNCS(put_h264_qpel, 1, 8,  10_mmxext, ff_);
 
2657
                SET_QPEL_FUNCS(avg_h264_qpel, 1, 8,  10_mmxext, ff_);
 
2658
#endif
 
2659
                SET_QPEL_FUNCS(put_h264_qpel, 2, 4,  10_mmxext, ff_);
 
2660
                SET_QPEL_FUNCS(avg_h264_qpel, 2, 4,  10_mmxext, ff_);
 
2661
#endif
 
2662
            }
 
2663
 
 
2664
            SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, mmx2, );
 
2665
            SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, mmx2, );
 
2666
            SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, mmx2, );
 
2667
            SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, mmx2, );
 
2668
 
 
2669
#if HAVE_YASM
 
2670
            if (!high_bit_depth && CONFIG_H264CHROMA) {
2663
2671
            c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_mmx2_rnd;
2664
2672
            c->avg_h264_chroma_pixels_tab[1]= ff_avg_h264_chroma_mc4_mmx2;
2665
2673
            c->avg_h264_chroma_pixels_tab[2]= ff_avg_h264_chroma_mc2_mmx2;
2666
2674
            c->put_h264_chroma_pixels_tab[2]= ff_put_h264_chroma_mc2_mmx2;
2667
2675
            }
2668
 
            if (bit_depth == 10) {
 
2676
            if (bit_depth == 10 && CONFIG_H264CHROMA) {
2669
2677
                c->put_h264_chroma_pixels_tab[2]= ff_put_h264_chroma_mc2_10_mmxext;
2670
2678
                c->avg_h264_chroma_pixels_tab[2]= ff_avg_h264_chroma_mc2_10_mmxext;
2671
2679
                c->put_h264_chroma_pixels_tab[1]= ff_put_h264_chroma_mc4_10_mmxext;
2674
2682
 
2675
2683
            c->add_hfyu_median_prediction = ff_add_hfyu_median_prediction_mmx2;
2676
2684
#endif
2677
 
#if HAVE_7REGS && HAVE_TEN_OPERANDS
2678
 
            if( mm_flags&AV_CPU_FLAG_3DNOW )
 
2685
#if HAVE_7REGS
 
2686
            if (HAVE_AMD3DNOW && (mm_flags & AV_CPU_FLAG_3DNOW))
2679
2687
                c->add_hfyu_median_prediction = add_hfyu_median_prediction_cmov;
2680
2688
#endif
2681
2689
 
2682
2690
            c->add_png_paeth_prediction= add_png_paeth_prediction_mmx2;
2683
 
        } else if (mm_flags & AV_CPU_FLAG_3DNOW) {
 
2691
        } else if (HAVE_AMD3DNOW && (mm_flags & AV_CPU_FLAG_3DNOW)) {
2684
2692
            c->prefetch = prefetch_3dnow;
2685
2693
 
2686
2694
            if (!high_bit_depth) {
2714
2722
                c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_exact_3dnow;
2715
2723
            }
2716
2724
 
2717
 
            SET_QPEL_FUNCS(put_qpel, 0, 16, 3dnow);
2718
 
            SET_QPEL_FUNCS(put_qpel, 1, 8, 3dnow);
2719
 
            SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, 3dnow);
2720
 
            SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, 3dnow);
2721
 
            SET_QPEL_FUNCS(avg_qpel, 0, 16, 3dnow);
2722
 
            SET_QPEL_FUNCS(avg_qpel, 1, 8, 3dnow);
 
2725
            SET_QPEL_FUNCS(put_qpel, 0, 16, 3dnow, );
 
2726
            SET_QPEL_FUNCS(put_qpel, 1, 8, 3dnow, );
 
2727
            SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, 3dnow, );
 
2728
            SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, 3dnow, );
 
2729
            SET_QPEL_FUNCS(avg_qpel, 0, 16, 3dnow, );
 
2730
            SET_QPEL_FUNCS(avg_qpel, 1, 8, 3dnow, );
2723
2731
 
2724
2732
            if (!high_bit_depth) {
2725
 
            SET_QPEL_FUNCS(put_h264_qpel, 0, 16, 3dnow);
2726
 
            SET_QPEL_FUNCS(put_h264_qpel, 1, 8, 3dnow);
2727
 
            SET_QPEL_FUNCS(put_h264_qpel, 2, 4, 3dnow);
2728
 
            SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, 3dnow);
2729
 
            SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, 3dnow);
2730
 
            SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, 3dnow);
 
2733
            SET_QPEL_FUNCS(put_h264_qpel, 0, 16, 3dnow, );
 
2734
            SET_QPEL_FUNCS(put_h264_qpel, 1, 8, 3dnow, );
 
2735
            SET_QPEL_FUNCS(put_h264_qpel, 2, 4, 3dnow, );
 
2736
            SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, 3dnow, );
 
2737
            SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, 3dnow, );
 
2738
            SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, 3dnow, );
2731
2739
            }
2732
2740
 
2733
 
            SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, 3dnow);
2734
 
            SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, 3dnow);
2735
 
            SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, 3dnow);
2736
 
            SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, 3dnow);
 
2741
            SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, 3dnow, );
 
2742
            SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, 3dnow, );
 
2743
            SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, 3dnow, );
 
2744
            SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, 3dnow, );
2737
2745
 
2738
2746
#if HAVE_YASM
2739
 
            if (!high_bit_depth) {
 
2747
            if (!high_bit_depth && CONFIG_H264CHROMA) {
2740
2748
            c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_3dnow_rnd;
2741
2749
            c->avg_h264_chroma_pixels_tab[1]= ff_avg_h264_chroma_mc4_3dnow;
2742
2750
            }
2743
2751
 
2744
 
            c->avg_rv40_chroma_pixels_tab[0]= ff_avg_rv40_chroma_mc8_3dnow;
2745
 
            c->avg_rv40_chroma_pixels_tab[1]= ff_avg_rv40_chroma_mc4_3dnow;
2746
2752
#endif
2747
2753
        }
2748
2754
 
2763
2769
        }
2764
2770
        if(mm_flags & AV_CPU_FLAG_SSE2){
2765
2771
            if (!high_bit_depth) {
2766
 
            H264_QPEL_FUNCS(0, 1, sse2);
2767
 
            H264_QPEL_FUNCS(0, 2, sse2);
2768
 
            H264_QPEL_FUNCS(0, 3, sse2);
2769
 
            H264_QPEL_FUNCS(1, 1, sse2);
2770
 
            H264_QPEL_FUNCS(1, 2, sse2);
2771
 
            H264_QPEL_FUNCS(1, 3, sse2);
2772
 
            H264_QPEL_FUNCS(2, 1, sse2);
2773
 
            H264_QPEL_FUNCS(2, 2, sse2);
2774
 
            H264_QPEL_FUNCS(2, 3, sse2);
2775
 
            H264_QPEL_FUNCS(3, 1, sse2);
2776
 
            H264_QPEL_FUNCS(3, 2, sse2);
2777
 
            H264_QPEL_FUNCS(3, 3, sse2);
 
2772
                H264_QPEL_FUNCS(0, 1, sse2);
 
2773
                H264_QPEL_FUNCS(0, 2, sse2);
 
2774
                H264_QPEL_FUNCS(0, 3, sse2);
 
2775
                H264_QPEL_FUNCS(1, 1, sse2);
 
2776
                H264_QPEL_FUNCS(1, 2, sse2);
 
2777
                H264_QPEL_FUNCS(1, 3, sse2);
 
2778
                H264_QPEL_FUNCS(2, 1, sse2);
 
2779
                H264_QPEL_FUNCS(2, 2, sse2);
 
2780
                H264_QPEL_FUNCS(2, 3, sse2);
 
2781
                H264_QPEL_FUNCS(3, 1, sse2);
 
2782
                H264_QPEL_FUNCS(3, 2, sse2);
 
2783
                H264_QPEL_FUNCS(3, 3, sse2);
2778
2784
            }
2779
2785
#if HAVE_YASM
 
2786
#define H264_QPEL_FUNCS_10(x, y, CPU)\
 
2787
            c->put_h264_qpel_pixels_tab[0][x+y*4] = ff_put_h264_qpel16_mc##x##y##_10_##CPU;\
 
2788
            c->put_h264_qpel_pixels_tab[1][x+y*4] = ff_put_h264_qpel8_mc##x##y##_10_##CPU;\
 
2789
            c->avg_h264_qpel_pixels_tab[0][x+y*4] = ff_avg_h264_qpel16_mc##x##y##_10_##CPU;\
 
2790
            c->avg_h264_qpel_pixels_tab[1][x+y*4] = ff_avg_h264_qpel8_mc##x##y##_10_##CPU;
2780
2791
            if (bit_depth == 10) {
2781
 
                c->put_h264_chroma_pixels_tab[0]= ff_put_h264_chroma_mc8_10_sse2;
2782
 
                c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_10_sse2;
 
2792
                SET_QPEL_FUNCS(put_h264_qpel, 0, 16, 10_sse2, ff_);
 
2793
                SET_QPEL_FUNCS(put_h264_qpel, 1, 8,  10_sse2, ff_);
 
2794
                SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, 10_sse2, ff_);
 
2795
                SET_QPEL_FUNCS(avg_h264_qpel, 1, 8,  10_sse2, ff_);
 
2796
                H264_QPEL_FUNCS_10(1, 0, sse2_cache64)
 
2797
                H264_QPEL_FUNCS_10(2, 0, sse2_cache64)
 
2798
                H264_QPEL_FUNCS_10(3, 0, sse2_cache64)
 
2799
 
 
2800
                if (CONFIG_H264CHROMA) {
 
2801
                    c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_10_sse2;
 
2802
                    c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_10_sse2;
 
2803
                }
2783
2804
            }
2784
2805
#endif
2785
2806
        }
2799
2820
            H264_QPEL_FUNCS(3, 2, ssse3);
2800
2821
            H264_QPEL_FUNCS(3, 3, ssse3);
2801
2822
            }
 
2823
#if HAVE_YASM
 
2824
            else if (bit_depth == 10) {
 
2825
                H264_QPEL_FUNCS_10(1, 0, ssse3_cache64)
 
2826
                H264_QPEL_FUNCS_10(2, 0, ssse3_cache64)
 
2827
                H264_QPEL_FUNCS_10(3, 0, ssse3_cache64)
 
2828
            }
 
2829
#endif
2802
2830
            c->add_png_paeth_prediction= add_png_paeth_prediction_ssse3;
2803
2831
#if HAVE_YASM
2804
 
            if (!high_bit_depth) {
 
2832
            if (!high_bit_depth && CONFIG_H264CHROMA) {
2805
2833
            c->put_h264_chroma_pixels_tab[0]= ff_put_h264_chroma_mc8_ssse3_rnd;
2806
2834
            c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_ssse3_rnd;
2807
2835
            c->put_h264_chroma_pixels_tab[1]= ff_put_h264_chroma_mc4_ssse3;
2814
2842
        }
2815
2843
#endif
2816
2844
 
2817
 
        if(mm_flags & AV_CPU_FLAG_3DNOW){
 
2845
        if (HAVE_AMD3DNOW && (mm_flags & AV_CPU_FLAG_3DNOW)) {
2818
2846
            c->vorbis_inverse_coupling = vorbis_inverse_coupling_3dnow;
2819
2847
            c->vector_fmul = vector_fmul_3dnow;
2820
2848
        }
2821
 
        if(mm_flags & AV_CPU_FLAG_3DNOWEXT){
 
2849
        if (HAVE_AMD3DNOWEXT && (mm_flags & AV_CPU_FLAG_3DNOWEXT)) {
2822
2850
            c->vector_fmul_reverse = vector_fmul_reverse_3dnow2;
2823
2851
#if HAVE_6REGS
2824
2852
            c->vector_fmul_window = vector_fmul_window_3dnow2;
2847
2875
            c->vector_clipf = vector_clipf_sse;
2848
2876
#if HAVE_YASM
2849
2877
            c->scalarproduct_float = ff_scalarproduct_float_sse;
 
2878
            c->butterflies_float_interleave = ff_butterflies_float_interleave_sse;
 
2879
 
 
2880
            if (!high_bit_depth)
 
2881
                c->emulated_edge_mc = emulated_edge_mc_sse;
 
2882
            c->gmc = gmc_sse;
2850
2883
#endif
2851
2884
        }
2852
 
        if(mm_flags & AV_CPU_FLAG_3DNOW)
 
2885
        if (HAVE_AMD3DNOW && (mm_flags & AV_CPU_FLAG_3DNOW))
2853
2886
            c->vector_fmul_add = vector_fmul_add_3dnow; // faster than sse
2854
2887
        if(mm_flags & AV_CPU_FLAG_SSE2){
2855
2888
#if HAVE_YASM
2856
2889
            c->scalarproduct_int16 = ff_scalarproduct_int16_sse2;
2857
2890
            c->scalarproduct_and_madd_int16 = ff_scalarproduct_and_madd_int16_sse2;
 
2891
            if (mm_flags & AV_CPU_FLAG_ATOM) {
 
2892
                c->vector_clip_int32 = ff_vector_clip_int32_int_sse2;
 
2893
            } else {
 
2894
                c->vector_clip_int32 = ff_vector_clip_int32_sse2;
 
2895
            }
2858
2896
            if (avctx->flags & CODEC_FLAG_BITEXACT) {
2859
2897
                c->apply_window_int16 = ff_apply_window_int16_sse2_ba;
2860
2898
            } else {
2862
2900
                    c->apply_window_int16 = ff_apply_window_int16_sse2;
2863
2901
                }
2864
2902
            }
2865
 
 
2866
 
            if (!high_bit_depth)
2867
 
            c->emulated_edge_mc = emulated_edge_mc_sse;
2868
 
            c->gmc= gmc_sse;
2869
2903
#endif
2870
2904
        }
2871
2905
        if (mm_flags & AV_CPU_FLAG_SSSE3) {
2880
2914
            }
2881
2915
#endif
2882
2916
        }
 
2917
 
 
2918
        if (mm_flags & AV_CPU_FLAG_SSE4 && HAVE_SSE) {
 
2919
#if HAVE_YASM
 
2920
            c->vector_clip_int32 = ff_vector_clip_int32_sse4;
 
2921
#endif
 
2922
        }
 
2923
 
2883
2924
#if HAVE_AVX && HAVE_YASM
2884
2925
        if (mm_flags & AV_CPU_FLAG_AVX) {
2885
2926
            if (bit_depth == 10) {
2886
 
                c->put_h264_chroma_pixels_tab[0]= ff_put_h264_chroma_mc8_10_avx;
2887
 
                c->avg_h264_chroma_pixels_tab[0]= ff_avg_h264_chroma_mc8_10_avx;
 
2927
                //AVX implies !cache64.
 
2928
                //TODO: Port cache(32|64) detection from x264.
 
2929
                H264_QPEL_FUNCS_10(1, 0, sse2)
 
2930
                H264_QPEL_FUNCS_10(2, 0, sse2)
 
2931
                H264_QPEL_FUNCS_10(3, 0, sse2)
 
2932
 
 
2933
                if (CONFIG_H264CHROMA) {
 
2934
                    c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_10_avx;
 
2935
                    c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_10_avx;
 
2936
                }
2888
2937
            }
 
2938
            c->butterflies_float_interleave = ff_butterflies_float_interleave_avx;
2889
2939
        }
2890
2940
#endif
2891
2941
    }
2892
2942
 
2893
2943
    if (CONFIG_ENCODERS)
2894
2944
        dsputilenc_init_mmx(c, avctx);
2895
 
 
2896
 
#if 0
2897
 
    // for speed testing
2898
 
    get_pixels = just_return;
2899
 
    put_pixels_clamped = just_return;
2900
 
    add_pixels_clamped = just_return;
2901
 
 
2902
 
    pix_abs16x16 = just_return;
2903
 
    pix_abs16x16_x2 = just_return;
2904
 
    pix_abs16x16_y2 = just_return;
2905
 
    pix_abs16x16_xy2 = just_return;
2906
 
 
2907
 
    put_pixels_tab[0] = just_return;
2908
 
    put_pixels_tab[1] = just_return;
2909
 
    put_pixels_tab[2] = just_return;
2910
 
    put_pixels_tab[3] = just_return;
2911
 
 
2912
 
    put_no_rnd_pixels_tab[0] = just_return;
2913
 
    put_no_rnd_pixels_tab[1] = just_return;
2914
 
    put_no_rnd_pixels_tab[2] = just_return;
2915
 
    put_no_rnd_pixels_tab[3] = just_return;
2916
 
 
2917
 
    avg_pixels_tab[0] = just_return;
2918
 
    avg_pixels_tab[1] = just_return;
2919
 
    avg_pixels_tab[2] = just_return;
2920
 
    avg_pixels_tab[3] = just_return;
2921
 
 
2922
 
    avg_no_rnd_pixels_tab[0] = just_return;
2923
 
    avg_no_rnd_pixels_tab[1] = just_return;
2924
 
    avg_no_rnd_pixels_tab[2] = just_return;
2925
 
    avg_no_rnd_pixels_tab[3] = just_return;
2926
 
 
2927
 
    //av_fdct = just_return;
2928
 
    //ff_idct = just_return;
2929
 
#endif
2930
2945
}