← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/i386/dsputil_mmx.c
22
22
 * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
23
23
 */
24
24
 
25
 
#include "../dsputil.h"
26
 
#include "../simple_idct.h"
27
 
#include "../mpegvideo.h"
 
25
#include "dsputil.h"
 
26
#include "dsputil_mmx.h"
 
27
#include "simple_idct.h"
 
28
#include "mpegvideo.h"
28
29
#include "x86_cpu.h"
29
30
#include "mmx.h"
 
31
#include "vp3dsp_mmx.h"
 
32
#include "vp3dsp_sse2.h"
 
33
#include "idct_xvid.h"
 
34
#include "h263.h"
30
35
 
31
36
//#undef NDEBUG
32
37
//#include <assert.h>
33
38
 
34
 
extern void ff_idct_xvid_mmx(short *block);
35
 
extern void ff_idct_xvid_mmx2(short *block);
36
 
 
37
39
int mm_flags; /* multimedia extension flags */
38
40
 
39
41
/* pixel operations */
40
 
static const uint64_t mm_bone attribute_used __attribute__ ((aligned(8))) = 0x0101010101010101ULL;
41
 
static const uint64_t mm_wone attribute_used __attribute__ ((aligned(8))) = 0x0001000100010001ULL;
42
 
static const uint64_t mm_wtwo attribute_used __attribute__ ((aligned(8))) = 0x0002000200020002ULL;
 
42
DECLARE_ALIGNED_8 (const uint64_t, ff_bone) = 0x0101010101010101ULL;
 
43
DECLARE_ALIGNED_8 (const uint64_t, ff_wtwo) = 0x0002000200020002ULL;
43
44
 
44
 
static const uint64_t ff_pdw_80000000[2] attribute_used __attribute__ ((aligned(16))) =
 
45
DECLARE_ALIGNED_16(const uint64_t, ff_pdw_80000000[2]) =
45
46
{0x8000000080000000ULL, 0x8000000080000000ULL};
46
47
 
47
 
static const uint64_t ff_pw_20 attribute_used __attribute__ ((aligned(8))) = 0x0014001400140014ULL;
48
 
static const uint64_t ff_pw_3  attribute_used __attribute__ ((aligned(8))) = 0x0003000300030003ULL;
49
 
static const uint64_t ff_pw_4  attribute_used __attribute__ ((aligned(8))) = 0x0004000400040004ULL;
50
 
static const uint64_t ff_pw_5  attribute_used __attribute__ ((aligned(8))) = 0x0005000500050005ULL;
51
 
static const uint64_t ff_pw_8  attribute_used __attribute__ ((aligned(8))) = 0x0008000800080008ULL;
52
 
static const uint64_t ff_pw_16 attribute_used __attribute__ ((aligned(8))) = 0x0010001000100010ULL;
53
 
static const uint64_t ff_pw_32 attribute_used __attribute__ ((aligned(8))) = 0x0020002000200020ULL;
54
 
static const uint64_t ff_pw_64 attribute_used __attribute__ ((aligned(8))) = 0x0040004000400040ULL;
55
 
static const uint64_t ff_pw_15 attribute_used __attribute__ ((aligned(8))) = 0x000F000F000F000FULL;
56
 
 
57
 
static const uint64_t ff_pb_1  attribute_used __attribute__ ((aligned(8))) = 0x0101010101010101ULL;
58
 
static const uint64_t ff_pb_3  attribute_used __attribute__ ((aligned(8))) = 0x0303030303030303ULL;
59
 
static const uint64_t ff_pb_7  attribute_used __attribute__ ((aligned(8))) = 0x0707070707070707ULL;
60
 
static const uint64_t ff_pb_3F attribute_used __attribute__ ((aligned(8))) = 0x3F3F3F3F3F3F3F3FULL;
61
 
static const uint64_t ff_pb_A1 attribute_used __attribute__ ((aligned(8))) = 0xA1A1A1A1A1A1A1A1ULL;
62
 
static const uint64_t ff_pb_5F attribute_used __attribute__ ((aligned(8))) = 0x5F5F5F5F5F5F5F5FULL;
63
 
static const uint64_t ff_pb_FC attribute_used __attribute__ ((aligned(8))) = 0xFCFCFCFCFCFCFCFCULL;
64
 
 
65
 
#define JUMPALIGN() __asm __volatile (ASMALIGN(3)::)
66
 
#define MOVQ_ZERO(regd)  __asm __volatile ("pxor %%" #regd ", %%" #regd ::)
67
 
 
68
 
#define MOVQ_WONE(regd) \
69
 
    __asm __volatile ( \
70
 
    "pcmpeqd %%" #regd ", %%" #regd " \n\t" \
71
 
    "psrlw $15, %%" #regd ::)
 
48
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_3  ) = 0x0003000300030003ULL;
 
49
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_4  ) = 0x0004000400040004ULL;
 
50
DECLARE_ALIGNED_16(const xmm_t,    ff_pw_5  ) = {0x0005000500050005ULL, 0x0005000500050005ULL};
 
51
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_8  ) = 0x0008000800080008ULL;
 
52
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_15 ) = 0x000F000F000F000FULL;
 
53
DECLARE_ALIGNED_16(const xmm_t,    ff_pw_16 ) = {0x0010001000100010ULL, 0x0010001000100010ULL};
 
54
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_20 ) = 0x0014001400140014ULL;
 
55
DECLARE_ALIGNED_16(const xmm_t,    ff_pw_28 ) = {0x001C001C001C001CULL, 0x001C001C001C001CULL};
 
56
DECLARE_ALIGNED_16(const xmm_t,    ff_pw_32 ) = {0x0020002000200020ULL, 0x0020002000200020ULL};
 
57
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_42 ) = 0x002A002A002A002AULL;
 
58
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_64 ) = 0x0040004000400040ULL;
 
59
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_96 ) = 0x0060006000600060ULL;
 
60
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_128) = 0x0080008000800080ULL;
 
61
DECLARE_ALIGNED_8 (const uint64_t, ff_pw_255) = 0x00ff00ff00ff00ffULL;
 
62
 
 
63
DECLARE_ALIGNED_8 (const uint64_t, ff_pb_1  ) = 0x0101010101010101ULL;
 
64
DECLARE_ALIGNED_8 (const uint64_t, ff_pb_3  ) = 0x0303030303030303ULL;
 
65
DECLARE_ALIGNED_8 (const uint64_t, ff_pb_7  ) = 0x0707070707070707ULL;
 
66
DECLARE_ALIGNED_8 (const uint64_t, ff_pb_3F ) = 0x3F3F3F3F3F3F3F3FULL;
 
67
DECLARE_ALIGNED_8 (const uint64_t, ff_pb_A1 ) = 0xA1A1A1A1A1A1A1A1ULL;
 
68
DECLARE_ALIGNED_8 (const uint64_t, ff_pb_FC ) = 0xFCFCFCFCFCFCFCFCULL;
 
69
 
 
70
DECLARE_ALIGNED_16(const double, ff_pd_1[2]) = { 1.0, 1.0 };
 
71
DECLARE_ALIGNED_16(const double, ff_pd_2[2]) = { 2.0, 2.0 };
 
72
 
 
73
#define JUMPALIGN() asm volatile (ASMALIGN(3)::)
 
74
#define MOVQ_ZERO(regd)  asm volatile ("pxor %%" #regd ", %%" #regd ::)
72
75
 
73
76
#define MOVQ_BFE(regd) \
74
 
    __asm __volatile ( \
 
77
    asm volatile ( \
75
78
    "pcmpeqd %%" #regd ", %%" #regd " \n\t"\
76
79
    "paddb %%" #regd ", %%" #regd " \n\t" ::)
77
80
 
78
81
#ifndef PIC
79
 
#define MOVQ_BONE(regd)  __asm __volatile ("movq %0, %%" #regd " \n\t" ::"m"(mm_bone))
80
 
#define MOVQ_WTWO(regd)  __asm __volatile ("movq %0, %%" #regd " \n\t" ::"m"(mm_wtwo))
 
82
#define MOVQ_BONE(regd)  asm volatile ("movq %0, %%" #regd " \n\t" ::"m"(ff_bone))
 
83
#define MOVQ_WTWO(regd)  asm volatile ("movq %0, %%" #regd " \n\t" ::"m"(ff_wtwo))
81
84
#else
82
85
// for shared library it's better to use this way for accessing constants
83
86
// pcmpeqd -> -1
84
87
#define MOVQ_BONE(regd) \
85
 
    __asm __volatile ( \
 
88
    asm volatile ( \
86
89
    "pcmpeqd %%" #regd ", %%" #regd " \n\t" \
87
90
    "psrlw $15, %%" #regd " \n\t" \
88
91
    "packuswb %%" #regd ", %%" #regd " \n\t" ::)
89
92
 
90
93
#define MOVQ_WTWO(regd) \
91
 
    __asm __volatile ( \
 
94
    asm volatile ( \
92
95
    "pcmpeqd %%" #regd ", %%" #regd " \n\t" \
93
96
    "psrlw $15, %%" #regd " \n\t" \
94
97
    "psllw $1, %%" #regd " \n\t"::)
175
178
/* 3Dnow specific */
176
179
 
177
180
#define DEF(x) x ## _3dnow
178
 
/* for Athlons PAVGUSB is prefered */
179
181
#define PAVGB "pavgusb"
180
182
 
181
183
#include "dsputil_mmx_avg.h"
196
198
#undef DEF
197
199
#undef PAVGB
198
200
 
199
 
#define SBUTTERFLY(a,b,t,n)\
200
 
    "movq " #a ", " #t "              \n\t" /* abcd */\
201
 
    "punpckl" #n " " #b ", " #a "     \n\t" /* aebf */\
202
 
    "punpckh" #n " " #b ", " #t "     \n\t" /* cgdh */\
 
201
#define put_no_rnd_pixels16_mmx put_pixels16_mmx
 
202
#define put_no_rnd_pixels8_mmx put_pixels8_mmx
 
203
#define put_pixels16_mmx2 put_pixels16_mmx
 
204
#define put_pixels8_mmx2 put_pixels8_mmx
 
205
#define put_pixels4_mmx2 put_pixels4_mmx
 
206
#define put_no_rnd_pixels16_mmx2 put_no_rnd_pixels16_mmx
 
207
#define put_no_rnd_pixels8_mmx2 put_no_rnd_pixels8_mmx
 
208
#define put_pixels16_3dnow put_pixels16_mmx
 
209
#define put_pixels8_3dnow put_pixels8_mmx
 
210
#define put_pixels4_3dnow put_pixels4_mmx
 
211
#define put_no_rnd_pixels16_3dnow put_no_rnd_pixels16_mmx
 
212
#define put_no_rnd_pixels8_3dnow put_no_rnd_pixels8_mmx
203
213
 
204
214
/***********************************/
205
215
/* standard MMX */
206
216
 
207
 
#ifdef CONFIG_ENCODERS
208
 
static void get_pixels_mmx(DCTELEM *block, const uint8_t *pixels, int line_size)
209
 
{
210
 
    asm volatile(
211
 
        "mov $-128, %%"REG_a"           \n\t"
212
 
        "pxor %%mm7, %%mm7              \n\t"
213
 
        ASMALIGN(4)
214
 
        "1:                             \n\t"
215
 
        "movq (%0), %%mm0               \n\t"
216
 
        "movq (%0, %2), %%mm2           \n\t"
217
 
        "movq %%mm0, %%mm1              \n\t"
218
 
        "movq %%mm2, %%mm3              \n\t"
219
 
        "punpcklbw %%mm7, %%mm0         \n\t"
220
 
        "punpckhbw %%mm7, %%mm1         \n\t"
221
 
        "punpcklbw %%mm7, %%mm2         \n\t"
222
 
        "punpckhbw %%mm7, %%mm3         \n\t"
223
 
        "movq %%mm0, (%1, %%"REG_a")    \n\t"
224
 
        "movq %%mm1, 8(%1, %%"REG_a")   \n\t"
225
 
        "movq %%mm2, 16(%1, %%"REG_a")  \n\t"
226
 
        "movq %%mm3, 24(%1, %%"REG_a")  \n\t"
227
 
        "add %3, %0                     \n\t"
228
 
        "add $32, %%"REG_a"             \n\t"
229
 
        "js 1b                          \n\t"
230
 
        : "+r" (pixels)
231
 
        : "r" (block+64), "r" ((long)line_size), "r" ((long)line_size*2)
232
 
        : "%"REG_a
233
 
    );
234
 
}
235
 
 
236
 
static inline void diff_pixels_mmx(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride)
237
 
{
238
 
    asm volatile(
239
 
        "pxor %%mm7, %%mm7              \n\t"
240
 
        "mov $-128, %%"REG_a"           \n\t"
241
 
        ASMALIGN(4)
242
 
        "1:                             \n\t"
243
 
        "movq (%0), %%mm0               \n\t"
244
 
        "movq (%1), %%mm2               \n\t"
245
 
        "movq %%mm0, %%mm1              \n\t"
246
 
        "movq %%mm2, %%mm3              \n\t"
247
 
        "punpcklbw %%mm7, %%mm0         \n\t"
248
 
        "punpckhbw %%mm7, %%mm1         \n\t"
249
 
        "punpcklbw %%mm7, %%mm2         \n\t"
250
 
        "punpckhbw %%mm7, %%mm3         \n\t"
251
 
        "psubw %%mm2, %%mm0             \n\t"
252
 
        "psubw %%mm3, %%mm1             \n\t"
253
 
        "movq %%mm0, (%2, %%"REG_a")    \n\t"
254
 
        "movq %%mm1, 8(%2, %%"REG_a")   \n\t"
255
 
        "add %3, %0                     \n\t"
256
 
        "add %3, %1                     \n\t"
257
 
        "add $16, %%"REG_a"             \n\t"
258
 
        "jnz 1b                         \n\t"
259
 
        : "+r" (s1), "+r" (s2)
260
 
        : "r" (block+64), "r" ((long)stride)
261
 
        : "%"REG_a
262
 
    );
263
 
}
264
 
#endif //CONFIG_ENCODERS
265
 
 
266
217
void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size)
267
218
{
268
219
    const DCTELEM *p;
272
223
    p = block;
273
224
    pix = pixels;
274
225
    /* unrolled loop */
275
 
        __asm __volatile(
 
226
        asm volatile(
276
227
                "movq   %3, %%mm0               \n\t"
277
228
                "movq   8%3, %%mm1              \n\t"
278
229
                "movq   16%3, %%mm2             \n\t"
297
248
    // if here would be an exact copy of the code above
298
249
    // compiler would generate some very strange code
299
250
    // thus using "r"
300
 
    __asm __volatile(
 
251
    asm volatile(
301
252
            "movq       (%3), %%mm0             \n\t"
302
253
            "movq       8(%3), %%mm1            \n\t"
303
254
            "movq       16(%3), %%mm2           \n\t"
348
299
    MOVQ_ZERO(mm7);
349
300
    i = 4;
350
301
    do {
351
 
        __asm __volatile(
 
302
        asm volatile(
352
303
                "movq   (%2), %%mm0     \n\t"
353
304
                "movq   8(%2), %%mm1    \n\t"
354
305
                "movq   16(%2), %%mm2   \n\t"
379
330
 
380
331
static void put_pixels4_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
381
332
{
382
 
    __asm __volatile(
 
333
    asm volatile(
383
334
         "lea (%3, %3), %%"REG_a"       \n\t"
384
335
         ASMALIGN(3)
385
336
         "1:                            \n\t"
405
356
 
406
357
static void put_pixels8_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
407
358
{
408
 
    __asm __volatile(
 
359
    asm volatile(
409
360
         "lea (%3, %3), %%"REG_a"       \n\t"
410
361
         ASMALIGN(3)
411
362
         "1:                            \n\t"
431
382
 
432
383
static void put_pixels16_mmx(uint8_t *block, const uint8_t *pixels, int line_size, int h)
433
384
{
434
 
    __asm __volatile(
 
385
    asm volatile(
435
386
         "lea (%3, %3), %%"REG_a"       \n\t"
436
387
         ASMALIGN(3)
437
388
         "1:                            \n\t"
463
414
        );
464
415
}
465
416
 
 
417
static void put_pixels16_sse2(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 
418
{
 
419
    asm volatile(
 
420
         "1:                            \n\t"
 
421
         "movdqu (%1), %%xmm0           \n\t"
 
422
         "movdqu (%1,%3), %%xmm1        \n\t"
 
423
         "movdqu (%1,%3,2), %%xmm2      \n\t"
 
424
         "movdqu (%1,%4), %%xmm3        \n\t"
 
425
         "movdqa %%xmm0, (%2)           \n\t"
 
426
         "movdqa %%xmm1, (%2,%3)        \n\t"
 
427
         "movdqa %%xmm2, (%2,%3,2)      \n\t"
 
428
         "movdqa %%xmm3, (%2,%4)        \n\t"
 
429
         "subl $4, %0                   \n\t"
 
430
         "lea (%1,%3,4), %1             \n\t"
 
431
         "lea (%2,%3,4), %2             \n\t"
 
432
         "jnz 1b                        \n\t"
 
433
         : "+g"(h), "+r" (pixels),  "+r" (block)
 
434
         : "r"((long)line_size), "r"(3L*line_size)
 
435
         : "memory"
 
436
        );
 
437
}
 
438
 
 
439
static void avg_pixels16_sse2(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 
440
{
 
441
    asm volatile(
 
442
         "1:                            \n\t"
 
443
         "movdqu (%1), %%xmm0           \n\t"
 
444
         "movdqu (%1,%3), %%xmm1        \n\t"
 
445
         "movdqu (%1,%3,2), %%xmm2      \n\t"
 
446
         "movdqu (%1,%4), %%xmm3        \n\t"
 
447
         "pavgb  (%2), %%xmm0           \n\t"
 
448
         "pavgb  (%2,%3), %%xmm1        \n\t"
 
449
         "pavgb  (%2,%3,2), %%xmm2      \n\t"
 
450
         "pavgb  (%2,%4), %%xmm3        \n\t"
 
451
         "movdqa %%xmm0, (%2)           \n\t"
 
452
         "movdqa %%xmm1, (%2,%3)        \n\t"
 
453
         "movdqa %%xmm2, (%2,%3,2)      \n\t"
 
454
         "movdqa %%xmm3, (%2,%4)        \n\t"
 
455
         "subl $4, %0                   \n\t"
 
456
         "lea (%1,%3,4), %1             \n\t"
 
457
         "lea (%2,%3,4), %2             \n\t"
 
458
         "jnz 1b                        \n\t"
 
459
         : "+g"(h), "+r" (pixels),  "+r" (block)
 
460
         : "r"((long)line_size), "r"(3L*line_size)
 
461
         : "memory"
 
462
        );
 
463
}
 
464
 
466
465
static void clear_blocks_mmx(DCTELEM *blocks)
467
466
{
468
 
    __asm __volatile(
 
467
    asm volatile(
469
468
                "pxor %%mm7, %%mm7              \n\t"
470
469
                "mov $-128*6, %%"REG_a"         \n\t"
471
470
                "1:                             \n\t"
480
479
        );
481
480
}
482
481
 
483
 
#ifdef CONFIG_ENCODERS
484
 
static int pix_sum16_mmx(uint8_t * pix, int line_size){
485
 
    const int h=16;
486
 
    int sum;
487
 
    long index= -line_size*h;
488
 
 
489
 
    __asm __volatile(
490
 
                "pxor %%mm7, %%mm7              \n\t"
491
 
                "pxor %%mm6, %%mm6              \n\t"
492
 
                "1:                             \n\t"
493
 
                "movq (%2, %1), %%mm0           \n\t"
494
 
                "movq (%2, %1), %%mm1           \n\t"
495
 
                "movq 8(%2, %1), %%mm2          \n\t"
496
 
                "movq 8(%2, %1), %%mm3          \n\t"
497
 
                "punpcklbw %%mm7, %%mm0         \n\t"
498
 
                "punpckhbw %%mm7, %%mm1         \n\t"
499
 
                "punpcklbw %%mm7, %%mm2         \n\t"
500
 
                "punpckhbw %%mm7, %%mm3         \n\t"
501
 
                "paddw %%mm0, %%mm1             \n\t"
502
 
                "paddw %%mm2, %%mm3             \n\t"
503
 
                "paddw %%mm1, %%mm3             \n\t"
504
 
                "paddw %%mm3, %%mm6             \n\t"
505
 
                "add %3, %1                     \n\t"
506
 
                " js 1b                         \n\t"
507
 
                "movq %%mm6, %%mm5              \n\t"
508
 
                "psrlq $32, %%mm6               \n\t"
509
 
                "paddw %%mm5, %%mm6             \n\t"
510
 
                "movq %%mm6, %%mm5              \n\t"
511
 
                "psrlq $16, %%mm6               \n\t"
512
 
                "paddw %%mm5, %%mm6             \n\t"
513
 
                "movd %%mm6, %0                 \n\t"
514
 
                "andl $0xFFFF, %0               \n\t"
515
 
                : "=&r" (sum), "+r" (index)
516
 
                : "r" (pix - index), "r" ((long)line_size)
517
 
        );
518
 
 
519
 
        return sum;
520
 
}
521
 
#endif //CONFIG_ENCODERS
522
 
 
523
482
static void add_bytes_mmx(uint8_t *dst, uint8_t *src, int w){
524
483
    long i=0;
525
484
    asm volatile(
542
501
        dst[i+0] += src[i+0];
543
502
}
544
503
 
 
504
static void add_bytes_l2_mmx(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
 
505
    long i=0;
 
506
    asm volatile(
 
507
        "1:                             \n\t"
 
508
        "movq   (%2, %0), %%mm0         \n\t"
 
509
        "movq  8(%2, %0), %%mm1         \n\t"
 
510
        "paddb  (%3, %0), %%mm0         \n\t"
 
511
        "paddb 8(%3, %0), %%mm1         \n\t"
 
512
        "movq %%mm0,  (%1, %0)          \n\t"
 
513
        "movq %%mm1, 8(%1, %0)          \n\t"
 
514
        "add $16, %0                    \n\t"
 
515
        "cmp %4, %0                     \n\t"
 
516
        " jb 1b                         \n\t"
 
517
        : "+r" (i)
 
518
        : "r"(dst), "r"(src1), "r"(src2), "r"((long)w-15)
 
519
    );
 
520
    for(; i<w; i++)
 
521
        dst[i] = src1[i] + src2[i];
 
522
}
 
523
 
545
524
#define H263_LOOP_FILTER \
546
525
        "pxor %%mm7, %%mm7              \n\t"\
547
526
        "movq  %0, %%mm0                \n\t"\
614
593
        "paddb %%mm1, %%mm6             \n\t"
615
594
 
616
595
static void h263_v_loop_filter_mmx(uint8_t *src, int stride, int qscale){
 
596
    if(ENABLE_ANY_H263) {
617
597
    const int strength= ff_h263_loop_filter_strength[qscale];
618
598
 
619
599
    asm volatile(
630
610
          "+m" (*(uint64_t*)(src + 1*stride))
631
611
        : "g" (2*strength), "m"(ff_pb_FC)
632
612
    );
 
613
    }
633
614
}
634
615
 
635
616
static inline void transpose4x4(uint8_t *dst, uint8_t *src, int dst_stride, int src_stride){
662
643
}
663
644
 
664
645
static void h263_h_loop_filter_mmx(uint8_t *src, int stride, int qscale){
 
646
    if(ENABLE_ANY_H263) {
665
647
    const int strength= ff_h263_loop_filter_strength[qscale];
666
 
    uint64_t temp[4] __attribute__ ((aligned(8)));
 
648
    DECLARE_ALIGNED(8, uint64_t, temp[4]);
667
649
    uint8_t *btemp= (uint8_t*)temp;
668
650
 
669
651
    src -= 2;
710
692
           "r" ((long)   stride ),
711
693
           "r" ((long)(3*stride))
712
694
    );
713
 
}
714
 
 
715
 
#ifdef CONFIG_ENCODERS
716
 
static int pix_norm1_mmx(uint8_t *pix, int line_size) {
717
 
    int tmp;
718
 
  asm volatile (
719
 
      "movl $16,%%ecx\n"
720
 
      "pxor %%mm0,%%mm0\n"
721
 
      "pxor %%mm7,%%mm7\n"
722
 
      "1:\n"
723
 
      "movq (%0),%%mm2\n"       /* mm2 = pix[0-7] */
724
 
      "movq 8(%0),%%mm3\n"      /* mm3 = pix[8-15] */
725
 
 
726
 
      "movq %%mm2,%%mm1\n"      /* mm1 = mm2 = pix[0-7] */
727
 
 
728
 
      "punpckhbw %%mm0,%%mm1\n" /* mm1 = [pix4-7] */
729
 
      "punpcklbw %%mm0,%%mm2\n" /* mm2 = [pix0-3] */
730
 
 
731
 
      "movq %%mm3,%%mm4\n"      /* mm4 = mm3 = pix[8-15] */
732
 
      "punpckhbw %%mm0,%%mm3\n" /* mm3 = [pix12-15] */
733
 
      "punpcklbw %%mm0,%%mm4\n" /* mm4 = [pix8-11] */
734
 
 
735
 
      "pmaddwd %%mm1,%%mm1\n"   /* mm1 = (pix0^2+pix1^2,pix2^2+pix3^2) */
736
 
      "pmaddwd %%mm2,%%mm2\n"   /* mm2 = (pix4^2+pix5^2,pix6^2+pix7^2) */
737
 
 
738
 
      "pmaddwd %%mm3,%%mm3\n"
739
 
      "pmaddwd %%mm4,%%mm4\n"
740
 
 
741
 
      "paddd %%mm1,%%mm2\n"     /* mm2 = (pix0^2+pix1^2+pix4^2+pix5^2,
742
 
                                          pix2^2+pix3^2+pix6^2+pix7^2) */
743
 
      "paddd %%mm3,%%mm4\n"
744
 
      "paddd %%mm2,%%mm7\n"
745
 
 
746
 
      "add %2, %0\n"
747
 
      "paddd %%mm4,%%mm7\n"
748
 
      "dec %%ecx\n"
749
 
      "jnz 1b\n"
750
 
 
751
 
      "movq %%mm7,%%mm1\n"
752
 
      "psrlq $32, %%mm7\n"      /* shift hi dword to lo */
753
 
      "paddd %%mm7,%%mm1\n"
754
 
      "movd %%mm1,%1\n"
755
 
      : "+r" (pix), "=r"(tmp) : "r" ((long)line_size) : "%ecx" );
756
 
    return tmp;
757
 
}
758
 
 
759
 
static int sse8_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
760
 
    int tmp;
761
 
  asm volatile (
762
 
      "movl %4,%%ecx\n"
763
 
      "shr $1,%%ecx\n"
764
 
      "pxor %%mm0,%%mm0\n"      /* mm0 = 0 */
765
 
      "pxor %%mm7,%%mm7\n"      /* mm7 holds the sum */
766
 
      "1:\n"
767
 
      "movq (%0),%%mm1\n"       /* mm1 = pix1[0][0-7] */
768
 
      "movq (%1),%%mm2\n"       /* mm2 = pix2[0][0-7] */
769
 
      "movq (%0,%3),%%mm3\n"    /* mm3 = pix1[1][0-7] */
770
 
      "movq (%1,%3),%%mm4\n"    /* mm4 = pix2[1][0-7] */
771
 
 
772
 
      /* todo: mm1-mm2, mm3-mm4 */
773
 
      /* algo: substract mm1 from mm2 with saturation and vice versa */
774
 
      /*       OR the results to get absolute difference */
775
 
      "movq %%mm1,%%mm5\n"
776
 
      "movq %%mm3,%%mm6\n"
777
 
      "psubusb %%mm2,%%mm1\n"
778
 
      "psubusb %%mm4,%%mm3\n"
779
 
      "psubusb %%mm5,%%mm2\n"
780
 
      "psubusb %%mm6,%%mm4\n"
781
 
 
782
 
      "por %%mm1,%%mm2\n"
783
 
      "por %%mm3,%%mm4\n"
784
 
 
785
 
      /* now convert to 16-bit vectors so we can square them */
786
 
      "movq %%mm2,%%mm1\n"
787
 
      "movq %%mm4,%%mm3\n"
788
 
 
789
 
      "punpckhbw %%mm0,%%mm2\n"
790
 
      "punpckhbw %%mm0,%%mm4\n"
791
 
      "punpcklbw %%mm0,%%mm1\n" /* mm1 now spread over (mm1,mm2) */
792
 
      "punpcklbw %%mm0,%%mm3\n" /* mm4 now spread over (mm3,mm4) */
793
 
 
794
 
      "pmaddwd %%mm2,%%mm2\n"
795
 
      "pmaddwd %%mm4,%%mm4\n"
796
 
      "pmaddwd %%mm1,%%mm1\n"
797
 
      "pmaddwd %%mm3,%%mm3\n"
798
 
 
799
 
      "lea (%0,%3,2), %0\n"     /* pix1 += 2*line_size */
800
 
      "lea (%1,%3,2), %1\n"     /* pix2 += 2*line_size */
801
 
 
802
 
      "paddd %%mm2,%%mm1\n"
803
 
      "paddd %%mm4,%%mm3\n"
804
 
      "paddd %%mm1,%%mm7\n"
805
 
      "paddd %%mm3,%%mm7\n"
806
 
 
807
 
      "decl %%ecx\n"
808
 
      "jnz 1b\n"
809
 
 
810
 
      "movq %%mm7,%%mm1\n"
811
 
      "psrlq $32, %%mm7\n"      /* shift hi dword to lo */
812
 
      "paddd %%mm7,%%mm1\n"
813
 
      "movd %%mm1,%2\n"
814
 
      : "+r" (pix1), "+r" (pix2), "=r"(tmp)
815
 
      : "r" ((long)line_size) , "m" (h)
816
 
      : "%ecx");
817
 
    return tmp;
818
 
}
819
 
 
820
 
static int sse16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
821
 
    int tmp;
822
 
  asm volatile (
823
 
      "movl %4,%%ecx\n"
824
 
      "pxor %%mm0,%%mm0\n"      /* mm0 = 0 */
825
 
      "pxor %%mm7,%%mm7\n"      /* mm7 holds the sum */
826
 
      "1:\n"
827
 
      "movq (%0),%%mm1\n"       /* mm1 = pix1[0-7] */
828
 
      "movq (%1),%%mm2\n"       /* mm2 = pix2[0-7] */
829
 
      "movq 8(%0),%%mm3\n"      /* mm3 = pix1[8-15] */
830
 
      "movq 8(%1),%%mm4\n"      /* mm4 = pix2[8-15] */
831
 
 
832
 
      /* todo: mm1-mm2, mm3-mm4 */
833
 
      /* algo: substract mm1 from mm2 with saturation and vice versa */
834
 
      /*       OR the results to get absolute difference */
835
 
      "movq %%mm1,%%mm5\n"
836
 
      "movq %%mm3,%%mm6\n"
837
 
      "psubusb %%mm2,%%mm1\n"
838
 
      "psubusb %%mm4,%%mm3\n"
839
 
      "psubusb %%mm5,%%mm2\n"
840
 
      "psubusb %%mm6,%%mm4\n"
841
 
 
842
 
      "por %%mm1,%%mm2\n"
843
 
      "por %%mm3,%%mm4\n"
844
 
 
845
 
      /* now convert to 16-bit vectors so we can square them */
846
 
      "movq %%mm2,%%mm1\n"
847
 
      "movq %%mm4,%%mm3\n"
848
 
 
849
 
      "punpckhbw %%mm0,%%mm2\n"
850
 
      "punpckhbw %%mm0,%%mm4\n"
851
 
      "punpcklbw %%mm0,%%mm1\n" /* mm1 now spread over (mm1,mm2) */
852
 
      "punpcklbw %%mm0,%%mm3\n" /* mm4 now spread over (mm3,mm4) */
853
 
 
854
 
      "pmaddwd %%mm2,%%mm2\n"
855
 
      "pmaddwd %%mm4,%%mm4\n"
856
 
      "pmaddwd %%mm1,%%mm1\n"
857
 
      "pmaddwd %%mm3,%%mm3\n"
858
 
 
859
 
      "add %3,%0\n"
860
 
      "add %3,%1\n"
861
 
 
862
 
      "paddd %%mm2,%%mm1\n"
863
 
      "paddd %%mm4,%%mm3\n"
864
 
      "paddd %%mm1,%%mm7\n"
865
 
      "paddd %%mm3,%%mm7\n"
866
 
 
867
 
      "decl %%ecx\n"
868
 
      "jnz 1b\n"
869
 
 
870
 
      "movq %%mm7,%%mm1\n"
871
 
      "psrlq $32, %%mm7\n"      /* shift hi dword to lo */
872
 
      "paddd %%mm7,%%mm1\n"
873
 
      "movd %%mm1,%2\n"
874
 
      : "+r" (pix1), "+r" (pix2), "=r"(tmp)
875
 
      : "r" ((long)line_size) , "m" (h)
876
 
      : "%ecx");
877
 
    return tmp;
878
 
}
879
 
 
880
 
static int sse16_sse2(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
881
 
    int tmp;
882
 
  asm volatile (
883
 
      "shr $1,%2\n"
884
 
      "pxor %%xmm0,%%xmm0\n"    /* mm0 = 0 */
885
 
      "pxor %%xmm7,%%xmm7\n"    /* mm7 holds the sum */
886
 
      "1:\n"
887
 
      "movdqu (%0),%%xmm1\n"    /* mm1 = pix1[0][0-15] */
888
 
      "movdqu (%1),%%xmm2\n"    /* mm2 = pix2[0][0-15] */
889
 
      "movdqu (%0,%4),%%xmm3\n" /* mm3 = pix1[1][0-15] */
890
 
      "movdqu (%1,%4),%%xmm4\n" /* mm4 = pix2[1][0-15] */
891
 
 
892
 
      /* todo: mm1-mm2, mm3-mm4 */
893
 
      /* algo: substract mm1 from mm2 with saturation and vice versa */
894
 
      /*       OR the results to get absolute difference */
895
 
      "movdqa %%xmm1,%%xmm5\n"
896
 
      "movdqa %%xmm3,%%xmm6\n"
897
 
      "psubusb %%xmm2,%%xmm1\n"
898
 
      "psubusb %%xmm4,%%xmm3\n"
899
 
      "psubusb %%xmm5,%%xmm2\n"
900
 
      "psubusb %%xmm6,%%xmm4\n"
901
 
 
902
 
      "por %%xmm1,%%xmm2\n"
903
 
      "por %%xmm3,%%xmm4\n"
904
 
 
905
 
      /* now convert to 16-bit vectors so we can square them */
906
 
      "movdqa %%xmm2,%%xmm1\n"
907
 
      "movdqa %%xmm4,%%xmm3\n"
908
 
 
909
 
      "punpckhbw %%xmm0,%%xmm2\n"
910
 
      "punpckhbw %%xmm0,%%xmm4\n"
911
 
      "punpcklbw %%xmm0,%%xmm1\n"  /* mm1 now spread over (mm1,mm2) */
912
 
      "punpcklbw %%xmm0,%%xmm3\n"  /* mm4 now spread over (mm3,mm4) */
913
 
 
914
 
      "pmaddwd %%xmm2,%%xmm2\n"
915
 
      "pmaddwd %%xmm4,%%xmm4\n"
916
 
      "pmaddwd %%xmm1,%%xmm1\n"
917
 
      "pmaddwd %%xmm3,%%xmm3\n"
918
 
 
919
 
      "lea (%0,%4,2), %0\n"        /* pix1 += 2*line_size */
920
 
      "lea (%1,%4,2), %1\n"        /* pix2 += 2*line_size */
921
 
 
922
 
      "paddd %%xmm2,%%xmm1\n"
923
 
      "paddd %%xmm4,%%xmm3\n"
924
 
      "paddd %%xmm1,%%xmm7\n"
925
 
      "paddd %%xmm3,%%xmm7\n"
926
 
 
927
 
      "decl %2\n"
928
 
      "jnz 1b\n"
929
 
 
930
 
      "movdqa %%xmm7,%%xmm1\n"
931
 
      "psrldq $8, %%xmm7\n"        /* shift hi qword to lo */
932
 
      "paddd %%xmm1,%%xmm7\n"
933
 
      "movdqa %%xmm7,%%xmm1\n"
934
 
      "psrldq $4, %%xmm7\n"        /* shift hi dword to lo */
935
 
      "paddd %%xmm1,%%xmm7\n"
936
 
      "movd %%xmm7,%3\n"
937
 
      : "+r" (pix1), "+r" (pix2), "+r"(h), "=r"(tmp)
938
 
      : "r" ((long)line_size));
939
 
    return tmp;
940
 
}
941
 
 
942
 
static int hf_noise8_mmx(uint8_t * pix1, int line_size, int h) {
943
 
    int tmp;
944
 
  asm volatile (
945
 
      "movl %3,%%ecx\n"
946
 
      "pxor %%mm7,%%mm7\n"
947
 
      "pxor %%mm6,%%mm6\n"
948
 
 
949
 
      "movq (%0),%%mm0\n"
950
 
      "movq %%mm0, %%mm1\n"
951
 
      "psllq $8, %%mm0\n"
952
 
      "psrlq $8, %%mm1\n"
953
 
      "psrlq $8, %%mm0\n"
954
 
      "movq %%mm0, %%mm2\n"
955
 
      "movq %%mm1, %%mm3\n"
956
 
      "punpcklbw %%mm7,%%mm0\n"
957
 
      "punpcklbw %%mm7,%%mm1\n"
958
 
      "punpckhbw %%mm7,%%mm2\n"
959
 
      "punpckhbw %%mm7,%%mm3\n"
960
 
      "psubw %%mm1, %%mm0\n"
961
 
      "psubw %%mm3, %%mm2\n"
962
 
 
963
 
      "add %2,%0\n"
964
 
 
965
 
      "movq (%0),%%mm4\n"
966
 
      "movq %%mm4, %%mm1\n"
967
 
      "psllq $8, %%mm4\n"
968
 
      "psrlq $8, %%mm1\n"
969
 
      "psrlq $8, %%mm4\n"
970
 
      "movq %%mm4, %%mm5\n"
971
 
      "movq %%mm1, %%mm3\n"
972
 
      "punpcklbw %%mm7,%%mm4\n"
973
 
      "punpcklbw %%mm7,%%mm1\n"
974
 
      "punpckhbw %%mm7,%%mm5\n"
975
 
      "punpckhbw %%mm7,%%mm3\n"
976
 
      "psubw %%mm1, %%mm4\n"
977
 
      "psubw %%mm3, %%mm5\n"
978
 
      "psubw %%mm4, %%mm0\n"
979
 
      "psubw %%mm5, %%mm2\n"
980
 
      "pxor %%mm3, %%mm3\n"
981
 
      "pxor %%mm1, %%mm1\n"
982
 
      "pcmpgtw %%mm0, %%mm3\n\t"
983
 
      "pcmpgtw %%mm2, %%mm1\n\t"
984
 
      "pxor %%mm3, %%mm0\n"
985
 
      "pxor %%mm1, %%mm2\n"
986
 
      "psubw %%mm3, %%mm0\n"
987
 
      "psubw %%mm1, %%mm2\n"
988
 
      "paddw %%mm0, %%mm2\n"
989
 
      "paddw %%mm2, %%mm6\n"
990
 
 
991
 
      "add %2,%0\n"
992
 
      "1:\n"
993
 
 
994
 
      "movq (%0),%%mm0\n"
995
 
      "movq %%mm0, %%mm1\n"
996
 
      "psllq $8, %%mm0\n"
997
 
      "psrlq $8, %%mm1\n"
998
 
      "psrlq $8, %%mm0\n"
999
 
      "movq %%mm0, %%mm2\n"
1000
 
      "movq %%mm1, %%mm3\n"
1001
 
      "punpcklbw %%mm7,%%mm0\n"
1002
 
      "punpcklbw %%mm7,%%mm1\n"
1003
 
      "punpckhbw %%mm7,%%mm2\n"
1004
 
      "punpckhbw %%mm7,%%mm3\n"
1005
 
      "psubw %%mm1, %%mm0\n"
1006
 
      "psubw %%mm3, %%mm2\n"
1007
 
      "psubw %%mm0, %%mm4\n"
1008
 
      "psubw %%mm2, %%mm5\n"
1009
 
      "pxor %%mm3, %%mm3\n"
1010
 
      "pxor %%mm1, %%mm1\n"
1011
 
      "pcmpgtw %%mm4, %%mm3\n\t"
1012
 
      "pcmpgtw %%mm5, %%mm1\n\t"
1013
 
      "pxor %%mm3, %%mm4\n"
1014
 
      "pxor %%mm1, %%mm5\n"
1015
 
      "psubw %%mm3, %%mm4\n"
1016
 
      "psubw %%mm1, %%mm5\n"
1017
 
      "paddw %%mm4, %%mm5\n"
1018
 
      "paddw %%mm5, %%mm6\n"
1019
 
 
1020
 
      "add %2,%0\n"
1021
 
 
1022
 
      "movq (%0),%%mm4\n"
1023
 
      "movq %%mm4, %%mm1\n"
1024
 
      "psllq $8, %%mm4\n"
1025
 
      "psrlq $8, %%mm1\n"
1026
 
      "psrlq $8, %%mm4\n"
1027
 
      "movq %%mm4, %%mm5\n"
1028
 
      "movq %%mm1, %%mm3\n"
1029
 
      "punpcklbw %%mm7,%%mm4\n"
1030
 
      "punpcklbw %%mm7,%%mm1\n"
1031
 
      "punpckhbw %%mm7,%%mm5\n"
1032
 
      "punpckhbw %%mm7,%%mm3\n"
1033
 
      "psubw %%mm1, %%mm4\n"
1034
 
      "psubw %%mm3, %%mm5\n"
1035
 
      "psubw %%mm4, %%mm0\n"
1036
 
      "psubw %%mm5, %%mm2\n"
1037
 
      "pxor %%mm3, %%mm3\n"
1038
 
      "pxor %%mm1, %%mm1\n"
1039
 
      "pcmpgtw %%mm0, %%mm3\n\t"
1040
 
      "pcmpgtw %%mm2, %%mm1\n\t"
1041
 
      "pxor %%mm3, %%mm0\n"
1042
 
      "pxor %%mm1, %%mm2\n"
1043
 
      "psubw %%mm3, %%mm0\n"
1044
 
      "psubw %%mm1, %%mm2\n"
1045
 
      "paddw %%mm0, %%mm2\n"
1046
 
      "paddw %%mm2, %%mm6\n"
1047
 
 
1048
 
      "add %2,%0\n"
1049
 
      "subl $2, %%ecx\n"
1050
 
      " jnz 1b\n"
1051
 
 
1052
 
      "movq %%mm6, %%mm0\n"
1053
 
      "punpcklwd %%mm7,%%mm0\n"
1054
 
      "punpckhwd %%mm7,%%mm6\n"
1055
 
      "paddd %%mm0, %%mm6\n"
1056
 
 
1057
 
      "movq %%mm6,%%mm0\n"
1058
 
      "psrlq $32, %%mm6\n"
1059
 
      "paddd %%mm6,%%mm0\n"
1060
 
      "movd %%mm0,%1\n"
1061
 
      : "+r" (pix1), "=r"(tmp)
1062
 
      : "r" ((long)line_size) , "g" (h-2)
1063
 
      : "%ecx");
1064
 
      return tmp;
1065
 
}
1066
 
 
1067
 
static int hf_noise16_mmx(uint8_t * pix1, int line_size, int h) {
1068
 
    int tmp;
1069
 
    uint8_t * pix= pix1;
1070
 
  asm volatile (
1071
 
      "movl %3,%%ecx\n"
1072
 
      "pxor %%mm7,%%mm7\n"
1073
 
      "pxor %%mm6,%%mm6\n"
1074
 
 
1075
 
      "movq (%0),%%mm0\n"
1076
 
      "movq 1(%0),%%mm1\n"
1077
 
      "movq %%mm0, %%mm2\n"
1078
 
      "movq %%mm1, %%mm3\n"
1079
 
      "punpcklbw %%mm7,%%mm0\n"
1080
 
      "punpcklbw %%mm7,%%mm1\n"
1081
 
      "punpckhbw %%mm7,%%mm2\n"
1082
 
      "punpckhbw %%mm7,%%mm3\n"
1083
 
      "psubw %%mm1, %%mm0\n"
1084
 
      "psubw %%mm3, %%mm2\n"
1085
 
 
1086
 
      "add %2,%0\n"
1087
 
 
1088
 
      "movq (%0),%%mm4\n"
1089
 
      "movq 1(%0),%%mm1\n"
1090
 
      "movq %%mm4, %%mm5\n"
1091
 
      "movq %%mm1, %%mm3\n"
1092
 
      "punpcklbw %%mm7,%%mm4\n"
1093
 
      "punpcklbw %%mm7,%%mm1\n"
1094
 
      "punpckhbw %%mm7,%%mm5\n"
1095
 
      "punpckhbw %%mm7,%%mm3\n"
1096
 
      "psubw %%mm1, %%mm4\n"
1097
 
      "psubw %%mm3, %%mm5\n"
1098
 
      "psubw %%mm4, %%mm0\n"
1099
 
      "psubw %%mm5, %%mm2\n"
1100
 
      "pxor %%mm3, %%mm3\n"
1101
 
      "pxor %%mm1, %%mm1\n"
1102
 
      "pcmpgtw %%mm0, %%mm3\n\t"
1103
 
      "pcmpgtw %%mm2, %%mm1\n\t"
1104
 
      "pxor %%mm3, %%mm0\n"
1105
 
      "pxor %%mm1, %%mm2\n"
1106
 
      "psubw %%mm3, %%mm0\n"
1107
 
      "psubw %%mm1, %%mm2\n"
1108
 
      "paddw %%mm0, %%mm2\n"
1109
 
      "paddw %%mm2, %%mm6\n"
1110
 
 
1111
 
      "add %2,%0\n"
1112
 
      "1:\n"
1113
 
 
1114
 
      "movq (%0),%%mm0\n"
1115
 
      "movq 1(%0),%%mm1\n"
1116
 
      "movq %%mm0, %%mm2\n"
1117
 
      "movq %%mm1, %%mm3\n"
1118
 
      "punpcklbw %%mm7,%%mm0\n"
1119
 
      "punpcklbw %%mm7,%%mm1\n"
1120
 
      "punpckhbw %%mm7,%%mm2\n"
1121
 
      "punpckhbw %%mm7,%%mm3\n"
1122
 
      "psubw %%mm1, %%mm0\n"
1123
 
      "psubw %%mm3, %%mm2\n"
1124
 
      "psubw %%mm0, %%mm4\n"
1125
 
      "psubw %%mm2, %%mm5\n"
1126
 
      "pxor %%mm3, %%mm3\n"
1127
 
      "pxor %%mm1, %%mm1\n"
1128
 
      "pcmpgtw %%mm4, %%mm3\n\t"
1129
 
      "pcmpgtw %%mm5, %%mm1\n\t"
1130
 
      "pxor %%mm3, %%mm4\n"
1131
 
      "pxor %%mm1, %%mm5\n"
1132
 
      "psubw %%mm3, %%mm4\n"
1133
 
      "psubw %%mm1, %%mm5\n"
1134
 
      "paddw %%mm4, %%mm5\n"
1135
 
      "paddw %%mm5, %%mm6\n"
1136
 
 
1137
 
      "add %2,%0\n"
1138
 
 
1139
 
      "movq (%0),%%mm4\n"
1140
 
      "movq 1(%0),%%mm1\n"
1141
 
      "movq %%mm4, %%mm5\n"
1142
 
      "movq %%mm1, %%mm3\n"
1143
 
      "punpcklbw %%mm7,%%mm4\n"
1144
 
      "punpcklbw %%mm7,%%mm1\n"
1145
 
      "punpckhbw %%mm7,%%mm5\n"
1146
 
      "punpckhbw %%mm7,%%mm3\n"
1147
 
      "psubw %%mm1, %%mm4\n"
1148
 
      "psubw %%mm3, %%mm5\n"
1149
 
      "psubw %%mm4, %%mm0\n"
1150
 
      "psubw %%mm5, %%mm2\n"
1151
 
      "pxor %%mm3, %%mm3\n"
1152
 
      "pxor %%mm1, %%mm1\n"
1153
 
      "pcmpgtw %%mm0, %%mm3\n\t"
1154
 
      "pcmpgtw %%mm2, %%mm1\n\t"
1155
 
      "pxor %%mm3, %%mm0\n"
1156
 
      "pxor %%mm1, %%mm2\n"
1157
 
      "psubw %%mm3, %%mm0\n"
1158
 
      "psubw %%mm1, %%mm2\n"
1159
 
      "paddw %%mm0, %%mm2\n"
1160
 
      "paddw %%mm2, %%mm6\n"
1161
 
 
1162
 
      "add %2,%0\n"
1163
 
      "subl $2, %%ecx\n"
1164
 
      " jnz 1b\n"
1165
 
 
1166
 
      "movq %%mm6, %%mm0\n"
1167
 
      "punpcklwd %%mm7,%%mm0\n"
1168
 
      "punpckhwd %%mm7,%%mm6\n"
1169
 
      "paddd %%mm0, %%mm6\n"
1170
 
 
1171
 
      "movq %%mm6,%%mm0\n"
1172
 
      "psrlq $32, %%mm6\n"
1173
 
      "paddd %%mm6,%%mm0\n"
1174
 
      "movd %%mm0,%1\n"
1175
 
      : "+r" (pix1), "=r"(tmp)
1176
 
      : "r" ((long)line_size) , "g" (h-2)
1177
 
      : "%ecx");
1178
 
      return tmp + hf_noise8_mmx(pix+8, line_size, h);
1179
 
}
1180
 
 
1181
 
static int nsse16_mmx(void *p, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
1182
 
    MpegEncContext *c = p;
1183
 
    int score1, score2;
1184
 
 
1185
 
    if(c) score1 = c->dsp.sse[0](c, pix1, pix2, line_size, h);
1186
 
    else  score1 = sse16_mmx(c, pix1, pix2, line_size, h);
1187
 
    score2= hf_noise16_mmx(pix1, line_size, h) - hf_noise16_mmx(pix2, line_size, h);
1188
 
 
1189
 
    if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1190
 
    else  return score1 + FFABS(score2)*8;
1191
 
}
1192
 
 
1193
 
static int nsse8_mmx(void *p, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
1194
 
    MpegEncContext *c = p;
1195
 
    int score1= sse8_mmx(c, pix1, pix2, line_size, h);
1196
 
    int score2= hf_noise8_mmx(pix1, line_size, h) - hf_noise8_mmx(pix2, line_size, h);
1197
 
 
1198
 
    if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1199
 
    else  return score1 + FFABS(score2)*8;
1200
 
}
1201
 
 
1202
 
static int vsad_intra16_mmx(void *v, uint8_t * pix, uint8_t * dummy, int line_size, int h) {
1203
 
    int tmp;
1204
 
 
1205
 
    assert( (((int)pix) & 7) == 0);
1206
 
    assert((line_size &7) ==0);
1207
 
 
1208
 
#define SUM(in0, in1, out0, out1) \
1209
 
      "movq (%0), %%mm2\n"\
1210
 
      "movq 8(%0), %%mm3\n"\
1211
 
      "add %2,%0\n"\
1212
 
      "movq %%mm2, " #out0 "\n"\
1213
 
      "movq %%mm3, " #out1 "\n"\
1214
 
      "psubusb " #in0 ", %%mm2\n"\
1215
 
      "psubusb " #in1 ", %%mm3\n"\
1216
 
      "psubusb " #out0 ", " #in0 "\n"\
1217
 
      "psubusb " #out1 ", " #in1 "\n"\
1218
 
      "por %%mm2, " #in0 "\n"\
1219
 
      "por %%mm3, " #in1 "\n"\
1220
 
      "movq " #in0 ", %%mm2\n"\
1221
 
      "movq " #in1 ", %%mm3\n"\
1222
 
      "punpcklbw %%mm7, " #in0 "\n"\
1223
 
      "punpcklbw %%mm7, " #in1 "\n"\
1224
 
      "punpckhbw %%mm7, %%mm2\n"\
1225
 
      "punpckhbw %%mm7, %%mm3\n"\
1226
 
      "paddw " #in1 ", " #in0 "\n"\
1227
 
      "paddw %%mm3, %%mm2\n"\
1228
 
      "paddw %%mm2, " #in0 "\n"\
1229
 
      "paddw " #in0 ", %%mm6\n"
1230
 
 
1231
 
 
1232
 
  asm volatile (
1233
 
      "movl %3,%%ecx\n"
1234
 
      "pxor %%mm6,%%mm6\n"
1235
 
      "pxor %%mm7,%%mm7\n"
1236
 
      "movq (%0),%%mm0\n"
1237
 
      "movq 8(%0),%%mm1\n"
1238
 
      "add %2,%0\n"
1239
 
      "subl $2, %%ecx\n"
1240
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1241
 
      "1:\n"
1242
 
 
1243
 
      SUM(%%mm4, %%mm5, %%mm0, %%mm1)
1244
 
 
1245
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1246
 
 
1247
 
      "subl $2, %%ecx\n"
1248
 
      "jnz 1b\n"
1249
 
 
1250
 
      "movq %%mm6,%%mm0\n"
1251
 
      "psrlq $32, %%mm6\n"
1252
 
      "paddw %%mm6,%%mm0\n"
1253
 
      "movq %%mm0,%%mm6\n"
1254
 
      "psrlq $16, %%mm0\n"
1255
 
      "paddw %%mm6,%%mm0\n"
1256
 
      "movd %%mm0,%1\n"
1257
 
      : "+r" (pix), "=r"(tmp)
1258
 
      : "r" ((long)line_size) , "m" (h)
1259
 
      : "%ecx");
1260
 
    return tmp & 0xFFFF;
1261
 
}
1262
 
#undef SUM
1263
 
 
1264
 
static int vsad_intra16_mmx2(void *v, uint8_t * pix, uint8_t * dummy, int line_size, int h) {
1265
 
    int tmp;
1266
 
 
1267
 
    assert( (((int)pix) & 7) == 0);
1268
 
    assert((line_size &7) ==0);
1269
 
 
1270
 
#define SUM(in0, in1, out0, out1) \
1271
 
      "movq (%0), " #out0 "\n"\
1272
 
      "movq 8(%0), " #out1 "\n"\
1273
 
      "add %2,%0\n"\
1274
 
      "psadbw " #out0 ", " #in0 "\n"\
1275
 
      "psadbw " #out1 ", " #in1 "\n"\
1276
 
      "paddw " #in1 ", " #in0 "\n"\
1277
 
      "paddw " #in0 ", %%mm6\n"
1278
 
 
1279
 
  asm volatile (
1280
 
      "movl %3,%%ecx\n"
1281
 
      "pxor %%mm6,%%mm6\n"
1282
 
      "pxor %%mm7,%%mm7\n"
1283
 
      "movq (%0),%%mm0\n"
1284
 
      "movq 8(%0),%%mm1\n"
1285
 
      "add %2,%0\n"
1286
 
      "subl $2, %%ecx\n"
1287
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1288
 
      "1:\n"
1289
 
 
1290
 
      SUM(%%mm4, %%mm5, %%mm0, %%mm1)
1291
 
 
1292
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1293
 
 
1294
 
      "subl $2, %%ecx\n"
1295
 
      "jnz 1b\n"
1296
 
 
1297
 
      "movd %%mm6,%1\n"
1298
 
      : "+r" (pix), "=r"(tmp)
1299
 
      : "r" ((long)line_size) , "m" (h)
1300
 
      : "%ecx");
1301
 
    return tmp;
1302
 
}
1303
 
#undef SUM
1304
 
 
1305
 
static int vsad16_mmx(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
1306
 
    int tmp;
1307
 
 
1308
 
    assert( (((int)pix1) & 7) == 0);
1309
 
    assert( (((int)pix2) & 7) == 0);
1310
 
    assert((line_size &7) ==0);
1311
 
 
1312
 
#define SUM(in0, in1, out0, out1) \
1313
 
      "movq (%0),%%mm2\n"\
1314
 
      "movq (%1)," #out0 "\n"\
1315
 
      "movq 8(%0),%%mm3\n"\
1316
 
      "movq 8(%1)," #out1 "\n"\
1317
 
      "add %3,%0\n"\
1318
 
      "add %3,%1\n"\
1319
 
      "psubb " #out0 ", %%mm2\n"\
1320
 
      "psubb " #out1 ", %%mm3\n"\
1321
 
      "pxor %%mm7, %%mm2\n"\
1322
 
      "pxor %%mm7, %%mm3\n"\
1323
 
      "movq %%mm2, " #out0 "\n"\
1324
 
      "movq %%mm3, " #out1 "\n"\
1325
 
      "psubusb " #in0 ", %%mm2\n"\
1326
 
      "psubusb " #in1 ", %%mm3\n"\
1327
 
      "psubusb " #out0 ", " #in0 "\n"\
1328
 
      "psubusb " #out1 ", " #in1 "\n"\
1329
 
      "por %%mm2, " #in0 "\n"\
1330
 
      "por %%mm3, " #in1 "\n"\
1331
 
      "movq " #in0 ", %%mm2\n"\
1332
 
      "movq " #in1 ", %%mm3\n"\
1333
 
      "punpcklbw %%mm7, " #in0 "\n"\
1334
 
      "punpcklbw %%mm7, " #in1 "\n"\
1335
 
      "punpckhbw %%mm7, %%mm2\n"\
1336
 
      "punpckhbw %%mm7, %%mm3\n"\
1337
 
      "paddw " #in1 ", " #in0 "\n"\
1338
 
      "paddw %%mm3, %%mm2\n"\
1339
 
      "paddw %%mm2, " #in0 "\n"\
1340
 
      "paddw " #in0 ", %%mm6\n"
1341
 
 
1342
 
 
1343
 
  asm volatile (
1344
 
      "movl %4,%%ecx\n"
1345
 
      "pxor %%mm6,%%mm6\n"
1346
 
      "pcmpeqw %%mm7,%%mm7\n"
1347
 
      "psllw $15, %%mm7\n"
1348
 
      "packsswb %%mm7, %%mm7\n"
1349
 
      "movq (%0),%%mm0\n"
1350
 
      "movq (%1),%%mm2\n"
1351
 
      "movq 8(%0),%%mm1\n"
1352
 
      "movq 8(%1),%%mm3\n"
1353
 
      "add %3,%0\n"
1354
 
      "add %3,%1\n"
1355
 
      "subl $2, %%ecx\n"
1356
 
      "psubb %%mm2, %%mm0\n"
1357
 
      "psubb %%mm3, %%mm1\n"
1358
 
      "pxor %%mm7, %%mm0\n"
1359
 
      "pxor %%mm7, %%mm1\n"
1360
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1361
 
      "1:\n"
1362
 
 
1363
 
      SUM(%%mm4, %%mm5, %%mm0, %%mm1)
1364
 
 
1365
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1366
 
 
1367
 
      "subl $2, %%ecx\n"
1368
 
      "jnz 1b\n"
1369
 
 
1370
 
      "movq %%mm6,%%mm0\n"
1371
 
      "psrlq $32, %%mm6\n"
1372
 
      "paddw %%mm6,%%mm0\n"
1373
 
      "movq %%mm0,%%mm6\n"
1374
 
      "psrlq $16, %%mm0\n"
1375
 
      "paddw %%mm6,%%mm0\n"
1376
 
      "movd %%mm0,%2\n"
1377
 
      : "+r" (pix1), "+r" (pix2), "=r"(tmp)
1378
 
      : "r" ((long)line_size) , "m" (h)
1379
 
      : "%ecx");
1380
 
    return tmp & 0x7FFF;
1381
 
}
1382
 
#undef SUM
1383
 
 
1384
 
static int vsad16_mmx2(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h) {
1385
 
    int tmp;
1386
 
 
1387
 
    assert( (((int)pix1) & 7) == 0);
1388
 
    assert( (((int)pix2) & 7) == 0);
1389
 
    assert((line_size &7) ==0);
1390
 
 
1391
 
#define SUM(in0, in1, out0, out1) \
1392
 
      "movq (%0)," #out0 "\n"\
1393
 
      "movq (%1),%%mm2\n"\
1394
 
      "movq 8(%0)," #out1 "\n"\
1395
 
      "movq 8(%1),%%mm3\n"\
1396
 
      "add %3,%0\n"\
1397
 
      "add %3,%1\n"\
1398
 
      "psubb %%mm2, " #out0 "\n"\
1399
 
      "psubb %%mm3, " #out1 "\n"\
1400
 
      "pxor %%mm7, " #out0 "\n"\
1401
 
      "pxor %%mm7, " #out1 "\n"\
1402
 
      "psadbw " #out0 ", " #in0 "\n"\
1403
 
      "psadbw " #out1 ", " #in1 "\n"\
1404
 
      "paddw " #in1 ", " #in0 "\n"\
1405
 
      "paddw " #in0 ", %%mm6\n"
1406
 
 
1407
 
  asm volatile (
1408
 
      "movl %4,%%ecx\n"
1409
 
      "pxor %%mm6,%%mm6\n"
1410
 
      "pcmpeqw %%mm7,%%mm7\n"
1411
 
      "psllw $15, %%mm7\n"
1412
 
      "packsswb %%mm7, %%mm7\n"
1413
 
      "movq (%0),%%mm0\n"
1414
 
      "movq (%1),%%mm2\n"
1415
 
      "movq 8(%0),%%mm1\n"
1416
 
      "movq 8(%1),%%mm3\n"
1417
 
      "add %3,%0\n"
1418
 
      "add %3,%1\n"
1419
 
      "subl $2, %%ecx\n"
1420
 
      "psubb %%mm2, %%mm0\n"
1421
 
      "psubb %%mm3, %%mm1\n"
1422
 
      "pxor %%mm7, %%mm0\n"
1423
 
      "pxor %%mm7, %%mm1\n"
1424
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1425
 
      "1:\n"
1426
 
 
1427
 
      SUM(%%mm4, %%mm5, %%mm0, %%mm1)
1428
 
 
1429
 
      SUM(%%mm0, %%mm1, %%mm4, %%mm5)
1430
 
 
1431
 
      "subl $2, %%ecx\n"
1432
 
      "jnz 1b\n"
1433
 
 
1434
 
      "movd %%mm6,%2\n"
1435
 
      : "+r" (pix1), "+r" (pix2), "=r"(tmp)
1436
 
      : "r" ((long)line_size) , "m" (h)
1437
 
      : "%ecx");
1438
 
    return tmp;
1439
 
}
1440
 
#undef SUM
1441
 
 
1442
 
static void diff_bytes_mmx(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
1443
 
    long i=0;
1444
 
    asm volatile(
1445
 
        "1:                             \n\t"
1446
 
        "movq  (%2, %0), %%mm0          \n\t"
1447
 
        "movq  (%1, %0), %%mm1          \n\t"
1448
 
        "psubb %%mm0, %%mm1             \n\t"
1449
 
        "movq %%mm1, (%3, %0)           \n\t"
1450
 
        "movq 8(%2, %0), %%mm0          \n\t"
1451
 
        "movq 8(%1, %0), %%mm1          \n\t"
1452
 
        "psubb %%mm0, %%mm1             \n\t"
1453
 
        "movq %%mm1, 8(%3, %0)          \n\t"
1454
 
        "add $16, %0                    \n\t"
1455
 
        "cmp %4, %0                     \n\t"
1456
 
        " jb 1b                         \n\t"
1457
 
        : "+r" (i)
1458
 
        : "r"(src1), "r"(src2), "r"(dst), "r"((long)w-15)
1459
 
    );
1460
 
    for(; i<w; i++)
1461
 
        dst[i+0] = src1[i+0]-src2[i+0];
1462
 
}
1463
 
 
1464
 
static void sub_hfyu_median_prediction_mmx2(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
1465
 
    long i=0;
1466
 
    uint8_t l, lt;
1467
 
 
1468
 
    asm volatile(
1469
 
        "1:                             \n\t"
1470
 
        "movq  -1(%1, %0), %%mm0        \n\t" // LT
1471
 
        "movq  (%1, %0), %%mm1          \n\t" // T
1472
 
        "movq  -1(%2, %0), %%mm2        \n\t" // L
1473
 
        "movq  (%2, %0), %%mm3          \n\t" // X
1474
 
        "movq %%mm2, %%mm4              \n\t" // L
1475
 
        "psubb %%mm0, %%mm2             \n\t"
1476
 
        "paddb %%mm1, %%mm2             \n\t" // L + T - LT
1477
 
        "movq %%mm4, %%mm5              \n\t" // L
1478
 
        "pmaxub %%mm1, %%mm4            \n\t" // max(T, L)
1479
 
        "pminub %%mm5, %%mm1            \n\t" // min(T, L)
1480
 
        "pminub %%mm2, %%mm4            \n\t"
1481
 
        "pmaxub %%mm1, %%mm4            \n\t"
1482
 
        "psubb %%mm4, %%mm3             \n\t" // dst - pred
1483
 
        "movq %%mm3, (%3, %0)           \n\t"
1484
 
        "add $8, %0                     \n\t"
1485
 
        "cmp %4, %0                     \n\t"
1486
 
        " jb 1b                         \n\t"
1487
 
        : "+r" (i)
1488
 
        : "r"(src1), "r"(src2), "r"(dst), "r"((long)w)
1489
 
    );
1490
 
 
1491
 
    l= *left;
1492
 
    lt= *left_top;
1493
 
 
1494
 
    dst[0]= src2[0] - mid_pred(l, src1[0], (l + src1[0] - lt)&0xFF);
1495
 
 
1496
 
    *left_top= src1[w-1];
1497
 
    *left    = src2[w-1];
1498
 
}
1499
 
 
1500
 
#define LBUTTERFLY2(a1,b1,a2,b2)\
1501
 
    "paddw " #b1 ", " #a1 "           \n\t"\
1502
 
    "paddw " #b2 ", " #a2 "           \n\t"\
1503
 
    "paddw " #b1 ", " #b1 "           \n\t"\
1504
 
    "paddw " #b2 ", " #b2 "           \n\t"\
1505
 
    "psubw " #a1 ", " #b1 "           \n\t"\
1506
 
    "psubw " #a2 ", " #b2 "           \n\t"
1507
 
 
1508
 
#define HADAMARD48\
1509
 
        LBUTTERFLY2(%%mm0, %%mm1, %%mm2, %%mm3)\
1510
 
        LBUTTERFLY2(%%mm4, %%mm5, %%mm6, %%mm7)\
1511
 
        LBUTTERFLY2(%%mm0, %%mm2, %%mm1, %%mm3)\
1512
 
        LBUTTERFLY2(%%mm4, %%mm6, %%mm5, %%mm7)\
1513
 
        LBUTTERFLY2(%%mm0, %%mm4, %%mm1, %%mm5)\
1514
 
        LBUTTERFLY2(%%mm2, %%mm6, %%mm3, %%mm7)\
1515
 
 
1516
 
#define MMABS(a,z)\
1517
 
    "pxor " #z ", " #z "              \n\t"\
1518
 
    "pcmpgtw " #a ", " #z "           \n\t"\
1519
 
    "pxor " #z ", " #a "              \n\t"\
1520
 
    "psubw " #z ", " #a "             \n\t"
1521
 
 
1522
 
#define MMABS_SUM(a,z, sum)\
1523
 
    "pxor " #z ", " #z "              \n\t"\
1524
 
    "pcmpgtw " #a ", " #z "           \n\t"\
1525
 
    "pxor " #z ", " #a "              \n\t"\
1526
 
    "psubw " #z ", " #a "             \n\t"\
1527
 
    "paddusw " #a ", " #sum "         \n\t"
1528
 
 
1529
 
#define MMABS_MMX2(a,z)\
1530
 
    "pxor " #z ", " #z "              \n\t"\
1531
 
    "psubw " #a ", " #z "             \n\t"\
1532
 
    "pmaxsw " #z ", " #a "            \n\t"
1533
 
 
1534
 
#define MMABS_SUM_MMX2(a,z, sum)\
1535
 
    "pxor " #z ", " #z "              \n\t"\
1536
 
    "psubw " #a ", " #z "             \n\t"\
1537
 
    "pmaxsw " #z ", " #a "            \n\t"\
1538
 
    "paddusw " #a ", " #sum "         \n\t"
1539
 
 
1540
 
#define TRANSPOSE4(a,b,c,d,t)\
1541
 
    SBUTTERFLY(a,b,t,wd) /* a=aebf t=cgdh */\
1542
 
    SBUTTERFLY(c,d,b,wd) /* c=imjn b=kolp */\
1543
 
    SBUTTERFLY(a,c,d,dq) /* a=aeim d=bfjn */\
1544
 
    SBUTTERFLY(t,b,c,dq) /* t=cgko c=dhlp */
1545
 
 
1546
 
#define LOAD4(o, a, b, c, d)\
1547
 
        "movq "#o"(%1), " #a "        \n\t"\
1548
 
        "movq "#o"+16(%1), " #b "     \n\t"\
1549
 
        "movq "#o"+32(%1), " #c "     \n\t"\
1550
 
        "movq "#o"+48(%1), " #d "     \n\t"
1551
 
 
1552
 
#define STORE4(o, a, b, c, d)\
1553
 
        "movq "#a", "#o"(%1)          \n\t"\
1554
 
        "movq "#b", "#o"+16(%1)       \n\t"\
1555
 
        "movq "#c", "#o"+32(%1)       \n\t"\
1556
 
        "movq "#d", "#o"+48(%1)       \n\t"\
1557
 
 
1558
 
static int hadamard8_diff_mmx(void *s, uint8_t *src1, uint8_t *src2, int stride, int h){
1559
 
    DECLARE_ALIGNED_8(uint64_t, temp[16]);
1560
 
    int sum=0;
1561
 
 
1562
 
    assert(h==8);
1563
 
 
1564
 
    diff_pixels_mmx((DCTELEM*)temp, src1, src2, stride);
1565
 
 
1566
 
    asm volatile(
1567
 
        LOAD4(0 , %%mm0, %%mm1, %%mm2, %%mm3)
1568
 
        LOAD4(64, %%mm4, %%mm5, %%mm6, %%mm7)
1569
 
 
1570
 
        HADAMARD48
1571
 
 
1572
 
        "movq %%mm7, 112(%1)            \n\t"
1573
 
 
1574
 
        TRANSPOSE4(%%mm0, %%mm1, %%mm2, %%mm3, %%mm7)
1575
 
        STORE4(0 , %%mm0, %%mm3, %%mm7, %%mm2)
1576
 
 
1577
 
        "movq 112(%1), %%mm7            \n\t"
1578
 
        TRANSPOSE4(%%mm4, %%mm5, %%mm6, %%mm7, %%mm0)
1579
 
        STORE4(64, %%mm4, %%mm7, %%mm0, %%mm6)
1580
 
 
1581
 
        LOAD4(8 , %%mm0, %%mm1, %%mm2, %%mm3)
1582
 
        LOAD4(72, %%mm4, %%mm5, %%mm6, %%mm7)
1583
 
 
1584
 
        HADAMARD48
1585
 
 
1586
 
        "movq %%mm7, 120(%1)            \n\t"
1587
 
 
1588
 
        TRANSPOSE4(%%mm0, %%mm1, %%mm2, %%mm3, %%mm7)
1589
 
        STORE4(8 , %%mm0, %%mm3, %%mm7, %%mm2)
1590
 
 
1591
 
        "movq 120(%1), %%mm7            \n\t"
1592
 
        TRANSPOSE4(%%mm4, %%mm5, %%mm6, %%mm7, %%mm0)
1593
 
        "movq %%mm7, %%mm5              \n\t"//FIXME remove
1594
 
        "movq %%mm6, %%mm7              \n\t"
1595
 
        "movq %%mm0, %%mm6              \n\t"
1596
 
//        STORE4(72, %%mm4, %%mm7, %%mm0, %%mm6) //FIXME remove
1597
 
 
1598
 
        LOAD4(64, %%mm0, %%mm1, %%mm2, %%mm3)
1599
 
//        LOAD4(72, %%mm4, %%mm5, %%mm6, %%mm7)
1600
 
 
1601
 
        HADAMARD48
1602
 
        "movq %%mm7, 64(%1)             \n\t"
1603
 
        MMABS(%%mm0, %%mm7)
1604
 
        MMABS_SUM(%%mm1, %%mm7, %%mm0)
1605
 
        MMABS_SUM(%%mm2, %%mm7, %%mm0)
1606
 
        MMABS_SUM(%%mm3, %%mm7, %%mm0)
1607
 
        MMABS_SUM(%%mm4, %%mm7, %%mm0)
1608
 
        MMABS_SUM(%%mm5, %%mm7, %%mm0)
1609
 
        MMABS_SUM(%%mm6, %%mm7, %%mm0)
1610
 
        "movq 64(%1), %%mm1             \n\t"
1611
 
        MMABS_SUM(%%mm1, %%mm7, %%mm0)
1612
 
        "movq %%mm0, 64(%1)             \n\t"
1613
 
 
1614
 
        LOAD4(0 , %%mm0, %%mm1, %%mm2, %%mm3)
1615
 
        LOAD4(8 , %%mm4, %%mm5, %%mm6, %%mm7)
1616
 
 
1617
 
        HADAMARD48
1618
 
        "movq %%mm7, (%1)               \n\t"
1619
 
        MMABS(%%mm0, %%mm7)
1620
 
        MMABS_SUM(%%mm1, %%mm7, %%mm0)
1621
 
        MMABS_SUM(%%mm2, %%mm7, %%mm0)
1622
 
        MMABS_SUM(%%mm3, %%mm7, %%mm0)
1623
 
        MMABS_SUM(%%mm4, %%mm7, %%mm0)
1624
 
        MMABS_SUM(%%mm5, %%mm7, %%mm0)
1625
 
        MMABS_SUM(%%mm6, %%mm7, %%mm0)
1626
 
        "movq (%1), %%mm1               \n\t"
1627
 
        MMABS_SUM(%%mm1, %%mm7, %%mm0)
1628
 
        "movq 64(%1), %%mm1             \n\t"
1629
 
        MMABS_SUM(%%mm1, %%mm7, %%mm0)
1630
 
 
1631
 
        "movq %%mm0, %%mm1              \n\t"
1632
 
        "psrlq $32, %%mm0               \n\t"
1633
 
        "paddusw %%mm1, %%mm0           \n\t"
1634
 
        "movq %%mm0, %%mm1              \n\t"
1635
 
        "psrlq $16, %%mm0               \n\t"
1636
 
        "paddusw %%mm1, %%mm0           \n\t"
1637
 
        "movd %%mm0, %0                 \n\t"
1638
 
 
1639
 
        : "=r" (sum)
1640
 
        : "r"(temp)
1641
 
    );
1642
 
    return sum&0xFFFF;
1643
 
}
1644
 
 
1645
 
static int hadamard8_diff_mmx2(void *s, uint8_t *src1, uint8_t *src2, int stride, int h){
1646
 
    DECLARE_ALIGNED_8(uint64_t, temp[16]);
1647
 
    int sum=0;
1648
 
 
1649
 
    assert(h==8);
1650
 
 
1651
 
    diff_pixels_mmx((DCTELEM*)temp, src1, src2, stride);
1652
 
 
1653
 
    asm volatile(
1654
 
        LOAD4(0 , %%mm0, %%mm1, %%mm2, %%mm3)
1655
 
        LOAD4(64, %%mm4, %%mm5, %%mm6, %%mm7)
1656
 
 
1657
 
        HADAMARD48
1658
 
 
1659
 
        "movq %%mm7, 112(%1)            \n\t"
1660
 
 
1661
 
        TRANSPOSE4(%%mm0, %%mm1, %%mm2, %%mm3, %%mm7)
1662
 
        STORE4(0 , %%mm0, %%mm3, %%mm7, %%mm2)
1663
 
 
1664
 
        "movq 112(%1), %%mm7            \n\t"
1665
 
        TRANSPOSE4(%%mm4, %%mm5, %%mm6, %%mm7, %%mm0)
1666
 
        STORE4(64, %%mm4, %%mm7, %%mm0, %%mm6)
1667
 
 
1668
 
        LOAD4(8 , %%mm0, %%mm1, %%mm2, %%mm3)
1669
 
        LOAD4(72, %%mm4, %%mm5, %%mm6, %%mm7)
1670
 
 
1671
 
        HADAMARD48
1672
 
 
1673
 
        "movq %%mm7, 120(%1)            \n\t"
1674
 
 
1675
 
        TRANSPOSE4(%%mm0, %%mm1, %%mm2, %%mm3, %%mm7)
1676
 
        STORE4(8 , %%mm0, %%mm3, %%mm7, %%mm2)
1677
 
 
1678
 
        "movq 120(%1), %%mm7            \n\t"
1679
 
        TRANSPOSE4(%%mm4, %%mm5, %%mm6, %%mm7, %%mm0)
1680
 
        "movq %%mm7, %%mm5              \n\t"//FIXME remove
1681
 
        "movq %%mm6, %%mm7              \n\t"
1682
 
        "movq %%mm0, %%mm6              \n\t"
1683
 
//        STORE4(72, %%mm4, %%mm7, %%mm0, %%mm6) //FIXME remove
1684
 
 
1685
 
        LOAD4(64, %%mm0, %%mm1, %%mm2, %%mm3)
1686
 
//        LOAD4(72, %%mm4, %%mm5, %%mm6, %%mm7)
1687
 
 
1688
 
        HADAMARD48
1689
 
        "movq %%mm7, 64(%1)             \n\t"
1690
 
        MMABS_MMX2(%%mm0, %%mm7)
1691
 
        MMABS_SUM_MMX2(%%mm1, %%mm7, %%mm0)
1692
 
        MMABS_SUM_MMX2(%%mm2, %%mm7, %%mm0)
1693
 
        MMABS_SUM_MMX2(%%mm3, %%mm7, %%mm0)
1694
 
        MMABS_SUM_MMX2(%%mm4, %%mm7, %%mm0)
1695
 
        MMABS_SUM_MMX2(%%mm5, %%mm7, %%mm0)
1696
 
        MMABS_SUM_MMX2(%%mm6, %%mm7, %%mm0)
1697
 
        "movq 64(%1), %%mm1             \n\t"
1698
 
        MMABS_SUM_MMX2(%%mm1, %%mm7, %%mm0)
1699
 
        "movq %%mm0, 64(%1)             \n\t"
1700
 
 
1701
 
        LOAD4(0 , %%mm0, %%mm1, %%mm2, %%mm3)
1702
 
        LOAD4(8 , %%mm4, %%mm5, %%mm6, %%mm7)
1703
 
 
1704
 
        HADAMARD48
1705
 
        "movq %%mm7, (%1)               \n\t"
1706
 
        MMABS_MMX2(%%mm0, %%mm7)
1707
 
        MMABS_SUM_MMX2(%%mm1, %%mm7, %%mm0)
1708
 
        MMABS_SUM_MMX2(%%mm2, %%mm7, %%mm0)
1709
 
        MMABS_SUM_MMX2(%%mm3, %%mm7, %%mm0)
1710
 
        MMABS_SUM_MMX2(%%mm4, %%mm7, %%mm0)
1711
 
        MMABS_SUM_MMX2(%%mm5, %%mm7, %%mm0)
1712
 
        MMABS_SUM_MMX2(%%mm6, %%mm7, %%mm0)
1713
 
        "movq (%1), %%mm1               \n\t"
1714
 
        MMABS_SUM_MMX2(%%mm1, %%mm7, %%mm0)
1715
 
        "movq 64(%1), %%mm1             \n\t"
1716
 
        MMABS_SUM_MMX2(%%mm1, %%mm7, %%mm0)
1717
 
 
1718
 
        "pshufw $0x0E, %%mm0, %%mm1     \n\t"
1719
 
        "paddusw %%mm1, %%mm0           \n\t"
1720
 
        "pshufw $0x01, %%mm0, %%mm1     \n\t"
1721
 
        "paddusw %%mm1, %%mm0           \n\t"
1722
 
        "movd %%mm0, %0                 \n\t"
1723
 
 
1724
 
        : "=r" (sum)
1725
 
        : "r"(temp)
1726
 
    );
1727
 
    return sum&0xFFFF;
1728
 
}
1729
 
 
1730
 
 
1731
 
WARPER8_16_SQ(hadamard8_diff_mmx, hadamard8_diff16_mmx)
1732
 
WARPER8_16_SQ(hadamard8_diff_mmx2, hadamard8_diff16_mmx2)
1733
 
#endif //CONFIG_ENCODERS
1734
 
 
1735
 
#define put_no_rnd_pixels8_mmx(a,b,c,d) put_pixels8_mmx(a,b,c,d)
1736
 
#define put_no_rnd_pixels16_mmx(a,b,c,d) put_pixels16_mmx(a,b,c,d)
 
695
    }
 
696
}
 
697
 
 
698
/* draw the edges of width 'w' of an image of size width, height
 
699
   this mmx version can only handle w==8 || w==16 */
 
700
static void draw_edges_mmx(uint8_t *buf, int wrap, int width, int height, int w)
 
701
{
 
702
    uint8_t *ptr, *last_line;
 
703
    int i;
 
704
 
 
705
    last_line = buf + (height - 1) * wrap;
 
706
    /* left and right */
 
707
    ptr = buf;
 
708
    if(w==8)
 
709
    {
 
710
        asm volatile(
 
711
                "1:                             \n\t"
 
712
                "movd (%0), %%mm0               \n\t"
 
713
                "punpcklbw %%mm0, %%mm0         \n\t"
 
714
                "punpcklwd %%mm0, %%mm0         \n\t"
 
715
                "punpckldq %%mm0, %%mm0         \n\t"
 
716
                "movq %%mm0, -8(%0)             \n\t"
 
717
                "movq -8(%0, %2), %%mm1         \n\t"
 
718
                "punpckhbw %%mm1, %%mm1         \n\t"
 
719
                "punpckhwd %%mm1, %%mm1         \n\t"
 
720
                "punpckhdq %%mm1, %%mm1         \n\t"
 
721
                "movq %%mm1, (%0, %2)           \n\t"
 
722
                "add %1, %0                     \n\t"
 
723
                "cmp %3, %0                     \n\t"
 
724
                " jb 1b                         \n\t"
 
725
                : "+r" (ptr)
 
726
                : "r" ((long)wrap), "r" ((long)width), "r" (ptr + wrap*height)
 
727
        );
 
728
    }
 
729
    else
 
730
    {
 
731
        asm volatile(
 
732
                "1:                             \n\t"
 
733
                "movd (%0), %%mm0               \n\t"
 
734
                "punpcklbw %%mm0, %%mm0         \n\t"
 
735
                "punpcklwd %%mm0, %%mm0         \n\t"
 
736
                "punpckldq %%mm0, %%mm0         \n\t"
 
737
                "movq %%mm0, -8(%0)             \n\t"
 
738
                "movq %%mm0, -16(%0)            \n\t"
 
739
                "movq -8(%0, %2), %%mm1         \n\t"
 
740
                "punpckhbw %%mm1, %%mm1         \n\t"
 
741
                "punpckhwd %%mm1, %%mm1         \n\t"
 
742
                "punpckhdq %%mm1, %%mm1         \n\t"
 
743
                "movq %%mm1, (%0, %2)           \n\t"
 
744
                "movq %%mm1, 8(%0, %2)          \n\t"
 
745
                "add %1, %0                     \n\t"
 
746
                "cmp %3, %0                     \n\t"
 
747
                " jb 1b                         \n\t"
 
748
                : "+r" (ptr)
 
749
                : "r" ((long)wrap), "r" ((long)width), "r" (ptr + wrap*height)
 
750
        );
 
751
    }
 
752
 
 
753
    for(i=0;i<w;i+=4) {
 
754
        /* top and bottom (and hopefully also the corners) */
 
755
        ptr= buf - (i + 1) * wrap - w;
 
756
        asm volatile(
 
757
                "1:                             \n\t"
 
758
                "movq (%1, %0), %%mm0           \n\t"
 
759
                "movq %%mm0, (%0)               \n\t"
 
760
                "movq %%mm0, (%0, %2)           \n\t"
 
761
                "movq %%mm0, (%0, %2, 2)        \n\t"
 
762
                "movq %%mm0, (%0, %3)           \n\t"
 
763
                "add $8, %0                     \n\t"
 
764
                "cmp %4, %0                     \n\t"
 
765
                " jb 1b                         \n\t"
 
766
                : "+r" (ptr)
 
767
                : "r" ((long)buf - (long)ptr - w), "r" ((long)-wrap), "r" ((long)-wrap*3), "r" (ptr+width+2*w)
 
768
        );
 
769
        ptr= last_line + (i + 1) * wrap - w;
 
770
        asm volatile(
 
771
                "1:                             \n\t"
 
772
                "movq (%1, %0), %%mm0           \n\t"
 
773
                "movq %%mm0, (%0)               \n\t"
 
774
                "movq %%mm0, (%0, %2)           \n\t"
 
775
                "movq %%mm0, (%0, %2, 2)        \n\t"
 
776
                "movq %%mm0, (%0, %3)           \n\t"
 
777
                "add $8, %0                     \n\t"
 
778
                "cmp %4, %0                     \n\t"
 
779
                " jb 1b                         \n\t"
 
780
                : "+r" (ptr)
 
781
                : "r" ((long)last_line - (long)ptr - w), "r" ((long)wrap), "r" ((long)wrap*3), "r" (ptr+width+2*w)
 
782
        );
 
783
    }
 
784
}
 
785
 
 
786
#define PAETH(cpu, abs3)\
 
787
void add_png_paeth_prediction_##cpu(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)\
 
788
{\
 
789
    long i = -bpp;\
 
790
    long end = w-3;\
 
791
    asm volatile(\
 
792
        "pxor      %%mm7, %%mm7 \n"\
 
793
        "movd    (%1,%0), %%mm0 \n"\
 
794
        "movd    (%2,%0), %%mm1 \n"\
 
795
        "punpcklbw %%mm7, %%mm0 \n"\
 
796
        "punpcklbw %%mm7, %%mm1 \n"\
 
797
        "add       %4, %0 \n"\
 
798
        "1: \n"\
 
799
        "movq      %%mm1, %%mm2 \n"\
 
800
        "movd    (%2,%0), %%mm1 \n"\
 
801
        "movq      %%mm2, %%mm3 \n"\
 
802
        "punpcklbw %%mm7, %%mm1 \n"\
 
803
        "movq      %%mm2, %%mm4 \n"\
 
804
        "psubw     %%mm1, %%mm3 \n"\
 
805
        "psubw     %%mm0, %%mm4 \n"\
 
806
        "movq      %%mm3, %%mm5 \n"\
 
807
        "paddw     %%mm4, %%mm5 \n"\
 
808
        abs3\
 
809
        "movq      %%mm4, %%mm6 \n"\
 
810
        "pminsw    %%mm5, %%mm6 \n"\
 
811
        "pcmpgtw   %%mm6, %%mm3 \n"\
 
812
        "pcmpgtw   %%mm5, %%mm4 \n"\
 
813
        "movq      %%mm4, %%mm6 \n"\
 
814
        "pand      %%mm3, %%mm4 \n"\
 
815
        "pandn     %%mm3, %%mm6 \n"\
 
816
        "pandn     %%mm0, %%mm3 \n"\
 
817
        "movd    (%3,%0), %%mm0 \n"\
 
818
        "pand      %%mm1, %%mm6 \n"\
 
819
        "pand      %%mm4, %%mm2 \n"\
 
820
        "punpcklbw %%mm7, %%mm0 \n"\
 
821
        "movq      %6,    %%mm5 \n"\
 
822
        "paddw     %%mm6, %%mm0 \n"\
 
823
        "paddw     %%mm2, %%mm3 \n"\
 
824
        "paddw     %%mm3, %%mm0 \n"\
 
825
        "pand      %%mm5, %%mm0 \n"\
 
826
        "movq      %%mm0, %%mm3 \n"\
 
827
        "packuswb  %%mm3, %%mm3 \n"\
 
828
        "movd      %%mm3, (%1,%0) \n"\
 
829
        "add       %4, %0 \n"\
 
830
        "cmp       %5, %0 \n"\
 
831
        "jle 1b \n"\
 
832
        :"+r"(i)\
 
833
        :"r"(dst), "r"(top), "r"(src), "r"((long)bpp), "g"(end),\
 
834
         "m"(ff_pw_255)\
 
835
        :"memory"\
 
836
    );\
 
837
}
 
838
 
 
839
#define ABS3_MMX2\
 
840
        "psubw     %%mm5, %%mm7 \n"\
 
841
        "pmaxsw    %%mm7, %%mm5 \n"\
 
842
        "pxor      %%mm6, %%mm6 \n"\
 
843
        "pxor      %%mm7, %%mm7 \n"\
 
844
        "psubw     %%mm3, %%mm6 \n"\
 
845
        "psubw     %%mm4, %%mm7 \n"\
 
846
        "pmaxsw    %%mm6, %%mm3 \n"\
 
847
        "pmaxsw    %%mm7, %%mm4 \n"\
 
848
        "pxor      %%mm7, %%mm7 \n"
 
849
 
 
850
#define ABS3_SSSE3\
 
851
        "pabsw     %%mm3, %%mm3 \n"\
 
852
        "pabsw     %%mm4, %%mm4 \n"\
 
853
        "pabsw     %%mm5, %%mm5 \n"
 
854
 
 
855
PAETH(mmx2, ABS3_MMX2)
 
856
#ifdef HAVE_SSSE3
 
857
PAETH(ssse3, ABS3_SSSE3)
 
858
#endif
1737
859
 
1738
860
#define QPEL_V_LOW(m3,m4,m5,m6, pw_20, pw_3, rnd, in0, in1, in2, in7, out, OP)\
1739
861
        "paddw " #m4 ", " #m3 "           \n\t" /* x1 */\
1871
993
        "add %4, %1                       \n\t"\
1872
994
        "decl %2                          \n\t"\
1873
995
        " jnz 1b                          \n\t"\
1874
 
        : "+a"(src), "+c"(dst), "+m"(h)\
 
996
        : "+a"(src), "+c"(dst), "+D"(h)\
1875
997
        : "d"((long)srcStride), "S"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
1876
998
        : "memory"\
1877
999
    );\
1925
1047
}\
1926
1048
\
1927
1049
static void OPNAME ## mpeg4_qpel8_h_lowpass_mmx2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1928
 
    uint64_t temp;\
1929
 
\
1930
1050
    asm volatile(\
1931
1051
        "pxor %%mm7, %%mm7                \n\t"\
1932
1052
        "1:                               \n\t"\
1955
1075
        "paddw %%mm1, %%mm5               \n\t" /* d */\
1956
1076
        "pmullw "MANGLE(ff_pw_20)", %%mm0 \n\t" /* 20a */\
1957
1077
        "psubw %%mm5, %%mm0               \n\t" /* 20a - d */\
1958
 
        "paddw %6, %%mm6                  \n\t"\
 
1078
        "paddw %5, %%mm6                  \n\t"\
1959
1079
        "paddw %%mm6, %%mm0               \n\t" /* 20a - 6b + 3c - d */\
1960
1080
        "psraw $5, %%mm0                  \n\t"\
1961
1081
        /* mm1=EFGH, mm2=DEFG, mm3=CDEF, mm4=BCDE, mm7=0 */\
1974
1094
        "pmullw "MANGLE(ff_pw_20)", %%mm1 \n\t" /* 20a */\
1975
1095
        "pmullw "MANGLE(ff_pw_3)", %%mm3  \n\t" /* 3c - 6b */\
1976
1096
        "psubw %%mm4, %%mm3               \n\t" /* -6b + 3c - d */\
1977
 
        "paddw %6, %%mm1                  \n\t"\
 
1097
        "paddw %5, %%mm1                  \n\t"\
1978
1098
        "paddw %%mm1, %%mm3               \n\t" /* 20a - 6b + 3c - d */\
1979
1099
        "psraw $5, %%mm3                  \n\t"\
1980
1100
        "packuswb %%mm3, %%mm0            \n\t"\
1984
1104
        "add %4, %1                       \n\t"\
1985
1105
        "decl %2                          \n\t"\
1986
1106
        " jnz 1b                          \n\t"\
1987
 
        : "+a"(src), "+c"(dst), "+m"(h)\
1988
 
        : "S"((long)srcStride), "D"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(temp), "m"(ROUNDER)\
 
1107
        : "+a"(src), "+c"(dst), "+d"(h)\
 
1108
        : "S"((long)srcStride), "D"((long)dstStride), /*"m"(ff_pw_20), "m"(ff_pw_3),*/ "m"(ROUNDER)\
1989
1109
        : "memory"\
1990
1110
    );\
1991
1111
}\
2162
1282
}\
2163
1283
\
2164
1284
static void OPNAME ## qpel8_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
2165
 
    OPNAME ## pixels8_mmx(dst, src, stride, 8);\
 
1285
    OPNAME ## pixels8_ ## MMX(dst, src, stride, 8);\
2166
1286
}\
2167
1287
\
2168
1288
static void OPNAME ## qpel8_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
2273
1393
    OPNAME ## mpeg4_qpel8_v_lowpass_ ## MMX(dst, halfH, stride, 8);\
2274
1394
}\
2275
1395
static void OPNAME ## qpel16_mc00_ ## MMX (uint8_t *dst, uint8_t *src, int stride){\
2276
 
    OPNAME ## pixels16_mmx(dst, src, stride, 16);\
 
1396
    OPNAME ## pixels16_ ## MMX(dst, src, stride, 16);\
2277
1397
}\
2278
1398
\
2279
1399
static void OPNAME ## qpel16_mc10_ ## MMX(uint8_t *dst, uint8_t *src, int stride){\
2455
1575
static void just_return() { return; }
2456
1576
#endif
2457
1577
 
2458
 
#define SET_QPEL_FUNC(postfix1, postfix2) \
2459
 
    c->put_ ## postfix1 = put_ ## postfix2;\
2460
 
    c->put_no_rnd_ ## postfix1 = put_no_rnd_ ## postfix2;\
2461
 
    c->avg_ ## postfix1 = avg_ ## postfix2;
2462
 
 
2463
1578
static void gmc_mmx(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
2464
1579
                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height){
2465
1580
    const int w = 8;
2483
1598
    const int dxh = dxy*(h-1);
2484
1599
    const int dyw = dyx*(w-1);
2485
1600
    if( // non-constant fullpel offset (3% of blocks)
2486
 
        (ox^(ox+dxw) | ox^(ox+dxh) | ox^(ox+dxw+dxh) |
2487
 
         oy^(oy+dyw) | oy^(oy+dyh) | oy^(oy+dyw+dyh)) >> (16+shift)
 
1601
        ((ox^(ox+dxw)) | (ox^(ox+dxh)) | (ox^(ox+dxw+dxh)) |
 
1602
         (oy^(oy+dyw)) | (oy^(oy+dyh)) | (oy^(oy+dyw+dyh))) >> (16+shift)
2488
1603
        // uses more than 16 bits of subpel mv (only at huge resolution)
2489
1604
        || (dxx|dxy|dyx|dyy)&15 )
2490
1605
    {
2578
1693
    }
2579
1694
}
2580
1695
 
2581
 
#ifdef CONFIG_ENCODERS
2582
 
static int try_8x8basis_mmx(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
2583
 
    long i=0;
2584
 
 
2585
 
    assert(FFABS(scale) < 256);
2586
 
    scale<<= 16 + 1 - BASIS_SHIFT + RECON_SHIFT;
2587
 
 
2588
 
    asm volatile(
2589
 
        "pcmpeqw %%mm6, %%mm6           \n\t" // -1w
2590
 
        "psrlw $15, %%mm6               \n\t" //  1w
2591
 
        "pxor %%mm7, %%mm7              \n\t"
2592
 
        "movd  %4, %%mm5                \n\t"
2593
 
        "punpcklwd %%mm5, %%mm5         \n\t"
2594
 
        "punpcklwd %%mm5, %%mm5         \n\t"
2595
 
        "1:                             \n\t"
2596
 
        "movq  (%1, %0), %%mm0          \n\t"
2597
 
        "movq  8(%1, %0), %%mm1         \n\t"
2598
 
        "pmulhw %%mm5, %%mm0            \n\t"
2599
 
        "pmulhw %%mm5, %%mm1            \n\t"
2600
 
        "paddw %%mm6, %%mm0             \n\t"
2601
 
        "paddw %%mm6, %%mm1             \n\t"
2602
 
        "psraw $1, %%mm0                \n\t"
2603
 
        "psraw $1, %%mm1                \n\t"
2604
 
        "paddw (%2, %0), %%mm0          \n\t"
2605
 
        "paddw 8(%2, %0), %%mm1         \n\t"
2606
 
        "psraw $6, %%mm0                \n\t"
2607
 
        "psraw $6, %%mm1                \n\t"
2608
 
        "pmullw (%3, %0), %%mm0         \n\t"
2609
 
        "pmullw 8(%3, %0), %%mm1        \n\t"
2610
 
        "pmaddwd %%mm0, %%mm0           \n\t"
2611
 
        "pmaddwd %%mm1, %%mm1           \n\t"
2612
 
        "paddd %%mm1, %%mm0             \n\t"
2613
 
        "psrld $4, %%mm0                \n\t"
2614
 
        "paddd %%mm0, %%mm7             \n\t"
2615
 
        "add $16, %0                    \n\t"
2616
 
        "cmp $128, %0                   \n\t" //FIXME optimize & bench
2617
 
        " jb 1b                         \n\t"
2618
 
        "movq %%mm7, %%mm6              \n\t"
2619
 
        "psrlq $32, %%mm7               \n\t"
2620
 
        "paddd %%mm6, %%mm7             \n\t"
2621
 
        "psrld $2, %%mm7                \n\t"
2622
 
        "movd %%mm7, %0                 \n\t"
2623
 
 
2624
 
        : "+r" (i)
2625
 
        : "r"(basis), "r"(rem), "r"(weight), "g"(scale)
2626
 
    );
2627
 
    return i;
2628
 
}
2629
 
 
2630
 
static void add_8x8basis_mmx(int16_t rem[64], int16_t basis[64], int scale){
2631
 
    long i=0;
2632
 
 
2633
 
    if(FFABS(scale) < 256){
2634
 
        scale<<= 16 + 1 - BASIS_SHIFT + RECON_SHIFT;
2635
 
        asm volatile(
2636
 
                "pcmpeqw %%mm6, %%mm6   \n\t" // -1w
2637
 
                "psrlw $15, %%mm6       \n\t" //  1w
2638
 
                "movd  %3, %%mm5        \n\t"
2639
 
                "punpcklwd %%mm5, %%mm5 \n\t"
2640
 
                "punpcklwd %%mm5, %%mm5 \n\t"
2641
 
                "1:                     \n\t"
2642
 
                "movq  (%1, %0), %%mm0  \n\t"
2643
 
                "movq  8(%1, %0), %%mm1 \n\t"
2644
 
                "pmulhw %%mm5, %%mm0    \n\t"
2645
 
                "pmulhw %%mm5, %%mm1    \n\t"
2646
 
                "paddw %%mm6, %%mm0     \n\t"
2647
 
                "paddw %%mm6, %%mm1     \n\t"
2648
 
                "psraw $1, %%mm0        \n\t"
2649
 
                "psraw $1, %%mm1        \n\t"
2650
 
                "paddw (%2, %0), %%mm0  \n\t"
2651
 
                "paddw 8(%2, %0), %%mm1 \n\t"
2652
 
                "movq %%mm0, (%2, %0)   \n\t"
2653
 
                "movq %%mm1, 8(%2, %0)  \n\t"
2654
 
                "add $16, %0            \n\t"
2655
 
                "cmp $128, %0           \n\t" //FIXME optimize & bench
2656
 
                " jb 1b                 \n\t"
2657
 
 
2658
 
                : "+r" (i)
2659
 
                : "r"(basis), "r"(rem), "g"(scale)
2660
 
        );
2661
 
    }else{
2662
 
        for(i=0; i<8*8; i++){
2663
 
            rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
2664
 
        }
2665
 
    }
2666
 
}
2667
 
#endif /* CONFIG_ENCODERS */
2668
 
 
2669
1696
#define PREFETCH(name, op) \
2670
1697
static void name(void *mem, int stride, int h){\
2671
1698
    const uint8_t *p= mem;\
2680
1707
 
2681
1708
#include "h264dsp_mmx.c"
2682
1709
 
2683
 
/* AVS specific */
 
1710
/* CAVS specific */
2684
1711
void ff_cavsdsp_init_mmx2(DSPContext* c, AVCodecContext *avctx);
 
1712
void ff_cavsdsp_init_3dnow(DSPContext* c, AVCodecContext *avctx);
2685
1713
 
2686
1714
void ff_put_cavs_qpel8_mc00_mmx2(uint8_t *dst, uint8_t *src, int stride) {
2687
1715
    put_pixels8_mmx(dst, src, stride, 8);
2696
1724
    avg_pixels16_mmx(dst, src, stride, 16);
2697
1725
}
2698
1726
 
 
1727
/* VC1 specific */
 
1728
void ff_vc1dsp_init_mmx(DSPContext* dsp, AVCodecContext *avctx);
 
1729
 
 
1730
void ff_put_vc1_mspel_mc00_mmx(uint8_t *dst, const uint8_t *src, int stride, int rnd) {
 
1731
    put_pixels8_mmx(dst, src, stride, 8);
 
1732
}
 
1733
 
2699
1734
/* external functions, from idct_mmx.c */
2700
1735
void ff_mmx_idct(DCTELEM *block);
2701
1736
void ff_mmxext_idct(DCTELEM *block);
2702
1737
 
2703
 
void ff_vp3_idct_sse2(int16_t *input_data);
2704
 
void ff_vp3_idct_mmx(int16_t *data);
2705
 
void ff_vp3_dsp_init_mmx(void);
2706
 
 
2707
1738
/* XXX: those functions should be suppressed ASAP when all IDCTs are
2708
1739
   converted */
2709
1740
#ifdef CONFIG_GPL
2728
1759
    add_pixels_clamped_mmx(block, dest, line_size);
2729
1760
}
2730
1761
#endif
2731
 
static void ff_vp3_idct_put_sse2(uint8_t *dest, int line_size, DCTELEM *block)
2732
 
{
2733
 
    ff_vp3_idct_sse2(block);
2734
 
    put_signed_pixels_clamped_mmx(block, dest, line_size);
2735
 
}
2736
 
static void ff_vp3_idct_add_sse2(uint8_t *dest, int line_size, DCTELEM *block)
2737
 
{
2738
 
    ff_vp3_idct_sse2(block);
2739
 
    add_pixels_clamped_mmx(block, dest, line_size);
2740
 
}
2741
 
static void ff_vp3_idct_put_mmx(uint8_t *dest, int line_size, DCTELEM *block)
2742
 
{
2743
 
    ff_vp3_idct_mmx(block);
2744
 
    put_signed_pixels_clamped_mmx(block, dest, line_size);
2745
 
}
2746
 
static void ff_vp3_idct_add_mmx(uint8_t *dest, int line_size, DCTELEM *block)
2747
 
{
2748
 
    ff_vp3_idct_mmx(block);
2749
 
    add_pixels_clamped_mmx(block, dest, line_size);
2750
 
}
2751
1762
static void ff_idct_xvid_mmx_put(uint8_t *dest, int line_size, DCTELEM *block)
2752
1763
{
2753
1764
    ff_idct_xvid_mmx (block);
3037
2048
    asm volatile("emms");
3038
2049
}
3039
2050
 
3040
 
#ifdef CONFIG_SNOW_DECODER
3041
 
extern void ff_snow_horizontal_compose97i_sse2(DWTELEM *b, int width);
3042
 
extern void ff_snow_horizontal_compose97i_mmx(DWTELEM *b, int width);
3043
 
extern void ff_snow_vertical_compose97i_sse2(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, DWTELEM *b3, DWTELEM *b4, DWTELEM *b5, int width);
3044
 
extern void ff_snow_vertical_compose97i_mmx(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, DWTELEM *b3, DWTELEM *b4, DWTELEM *b5, int width);
 
2051
extern void ff_snow_horizontal_compose97i_sse2(IDWTELEM *b, int width);
 
2052
extern void ff_snow_horizontal_compose97i_mmx(IDWTELEM *b, int width);
 
2053
extern void ff_snow_vertical_compose97i_sse2(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width);
 
2054
extern void ff_snow_vertical_compose97i_mmx(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width);
3045
2055
extern void ff_snow_inner_add_yblock_sse2(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
3046
2056
                           int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8);
3047
2057
extern void ff_snow_inner_add_yblock_mmx(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
3048
2058
                          int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8);
3049
 
#endif
3050
2059
 
3051
2060
void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
3052
2061
{
3077
2086
    if (mm_flags & MM_MMX) {
3078
2087
        const int idct_algo= avctx->idct_algo;
3079
2088
 
3080
 
#ifdef CONFIG_ENCODERS
3081
 
        const int dct_algo = avctx->dct_algo;
3082
 
        if(dct_algo==FF_DCT_AUTO || dct_algo==FF_DCT_MMX){
3083
 
            if(mm_flags & MM_SSE2){
3084
 
                c->fdct = ff_fdct_sse2;
3085
 
            }else if(mm_flags & MM_MMXEXT){
3086
 
                c->fdct = ff_fdct_mmx2;
3087
 
            }else{
3088
 
                c->fdct = ff_fdct_mmx;
3089
 
            }
3090
 
        }
3091
 
#endif //CONFIG_ENCODERS
3092
2089
        if(avctx->lowres==0){
3093
2090
            if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SIMPLEMMX){
3094
2091
                c->idct_put= ff_simple_idct_put_mmx;
3108
2105
                }
3109
2106
                c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
3110
2107
#endif
3111
 
            }else if(idct_algo==FF_IDCT_VP3 &&
 
2108
            }else if((ENABLE_VP3_DECODER || ENABLE_VP5_DECODER || ENABLE_VP6_DECODER) &&
 
2109
                     idct_algo==FF_IDCT_VP3 &&
3112
2110
                     avctx->codec->id!=CODEC_ID_THEORA &&
3113
2111
                     !(avctx->flags & CODEC_FLAG_BITEXACT)){
3114
2112
                if(mm_flags & MM_SSE2){
3126
2124
            }else if(idct_algo==FF_IDCT_CAVS){
3127
2125
                    c->idct_permutation_type= FF_TRANSPOSE_IDCT_PERM;
3128
2126
            }else if(idct_algo==FF_IDCT_XVIDMMX){
3129
 
                if(mm_flags & MM_MMXEXT){
 
2127
                if(mm_flags & MM_SSE2){
 
2128
                    c->idct_put= ff_idct_xvid_sse2_put;
 
2129
                    c->idct_add= ff_idct_xvid_sse2_add;
 
2130
                    c->idct    = ff_idct_xvid_sse2;
 
2131
                    c->idct_permutation_type= FF_SSE2_IDCT_PERM;
 
2132
                }else if(mm_flags & MM_MMXEXT){
3130
2133
                    c->idct_put= ff_idct_xvid_mmx2_put;
3131
2134
                    c->idct_add= ff_idct_xvid_mmx2_add;
3132
2135
                    c->idct    = ff_idct_xvid_mmx2;
3138
2141
            }
3139
2142
        }
3140
2143
 
3141
 
#ifdef CONFIG_ENCODERS
3142
 
        c->get_pixels = get_pixels_mmx;
3143
 
        c->diff_pixels = diff_pixels_mmx;
3144
 
#endif //CONFIG_ENCODERS
3145
2144
        c->put_pixels_clamped = put_pixels_clamped_mmx;
3146
2145
        c->put_signed_pixels_clamped = put_signed_pixels_clamped_mmx;
3147
2146
        c->add_pixels_clamped = add_pixels_clamped_mmx;
3148
2147
        c->clear_blocks = clear_blocks_mmx;
3149
 
#ifdef CONFIG_ENCODERS
3150
 
        c->pix_sum = pix_sum16_mmx;
3151
 
#endif //CONFIG_ENCODERS
3152
 
 
3153
 
        c->put_pixels_tab[0][0] = put_pixels16_mmx;
3154
 
        c->put_pixels_tab[0][1] = put_pixels16_x2_mmx;
3155
 
        c->put_pixels_tab[0][2] = put_pixels16_y2_mmx;
3156
 
        c->put_pixels_tab[0][3] = put_pixels16_xy2_mmx;
3157
 
 
3158
 
        c->put_no_rnd_pixels_tab[0][0] = put_pixels16_mmx;
3159
 
        c->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_mmx;
3160
 
        c->put_no_rnd_pixels_tab[0][2] = put_no_rnd_pixels16_y2_mmx;
3161
 
        c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_mmx;
3162
 
 
3163
 
        c->avg_pixels_tab[0][0] = avg_pixels16_mmx;
3164
 
        c->avg_pixels_tab[0][1] = avg_pixels16_x2_mmx;
3165
 
        c->avg_pixels_tab[0][2] = avg_pixels16_y2_mmx;
3166
 
        c->avg_pixels_tab[0][3] = avg_pixels16_xy2_mmx;
3167
 
 
3168
 
        c->avg_no_rnd_pixels_tab[0][0] = avg_no_rnd_pixels16_mmx;
3169
 
        c->avg_no_rnd_pixels_tab[0][1] = avg_no_rnd_pixels16_x2_mmx;
3170
 
        c->avg_no_rnd_pixels_tab[0][2] = avg_no_rnd_pixels16_y2_mmx;
3171
 
        c->avg_no_rnd_pixels_tab[0][3] = avg_no_rnd_pixels16_xy2_mmx;
3172
 
 
3173
 
        c->put_pixels_tab[1][0] = put_pixels8_mmx;
3174
 
        c->put_pixels_tab[1][1] = put_pixels8_x2_mmx;
3175
 
        c->put_pixels_tab[1][2] = put_pixels8_y2_mmx;
3176
 
        c->put_pixels_tab[1][3] = put_pixels8_xy2_mmx;
3177
 
 
3178
 
        c->put_no_rnd_pixels_tab[1][0] = put_pixels8_mmx;
3179
 
        c->put_no_rnd_pixels_tab[1][1] = put_no_rnd_pixels8_x2_mmx;
3180
 
        c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_mmx;
3181
 
        c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels8_xy2_mmx;
3182
 
 
3183
 
        c->avg_pixels_tab[1][0] = avg_pixels8_mmx;
3184
 
        c->avg_pixels_tab[1][1] = avg_pixels8_x2_mmx;
3185
 
        c->avg_pixels_tab[1][2] = avg_pixels8_y2_mmx;
3186
 
        c->avg_pixels_tab[1][3] = avg_pixels8_xy2_mmx;
3187
 
 
3188
 
        c->avg_no_rnd_pixels_tab[1][0] = avg_no_rnd_pixels8_mmx;
3189
 
        c->avg_no_rnd_pixels_tab[1][1] = avg_no_rnd_pixels8_x2_mmx;
3190
 
        c->avg_no_rnd_pixels_tab[1][2] = avg_no_rnd_pixels8_y2_mmx;
3191
 
        c->avg_no_rnd_pixels_tab[1][3] = avg_no_rnd_pixels8_xy2_mmx;
 
2148
 
 
2149
#define SET_HPEL_FUNCS(PFX, IDX, SIZE, CPU) \
 
2150
        c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## SIZE ## _ ## CPU; \
 
2151
        c->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## SIZE ## _x2_ ## CPU; \
 
2152
        c->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## SIZE ## _y2_ ## CPU; \
 
2153
        c->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## SIZE ## _xy2_ ## CPU
 
2154
 
 
2155
        SET_HPEL_FUNCS(put, 0, 16, mmx);
 
2156
        SET_HPEL_FUNCS(put_no_rnd, 0, 16, mmx);
 
2157
        SET_HPEL_FUNCS(avg, 0, 16, mmx);
 
2158
        SET_HPEL_FUNCS(avg_no_rnd, 0, 16, mmx);
 
2159
        SET_HPEL_FUNCS(put, 1, 8, mmx);
 
2160
        SET_HPEL_FUNCS(put_no_rnd, 1, 8, mmx);
 
2161
        SET_HPEL_FUNCS(avg, 1, 8, mmx);
 
2162
        SET_HPEL_FUNCS(avg_no_rnd, 1, 8, mmx);
3192
2163
 
3193
2164
        c->gmc= gmc_mmx;
3194
2165
 
3195
2166
        c->add_bytes= add_bytes_mmx;
3196
 
#ifdef CONFIG_ENCODERS
3197
 
        c->diff_bytes= diff_bytes_mmx;
3198
 
 
3199
 
        c->hadamard8_diff[0]= hadamard8_diff16_mmx;
3200
 
        c->hadamard8_diff[1]= hadamard8_diff_mmx;
3201
 
 
3202
 
        c->pix_norm1 = pix_norm1_mmx;
3203
 
        c->sse[0] = (mm_flags & MM_SSE2) ? sse16_sse2 : sse16_mmx;
3204
 
          c->sse[1] = sse8_mmx;
3205
 
        c->vsad[4]= vsad_intra16_mmx;
3206
 
 
3207
 
        c->nsse[0] = nsse16_mmx;
3208
 
        c->nsse[1] = nsse8_mmx;
3209
 
        if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
3210
 
            c->vsad[0] = vsad16_mmx;
3211
 
        }
3212
 
 
3213
 
        if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
3214
 
            c->try_8x8basis= try_8x8basis_mmx;
3215
 
        }
3216
 
        c->add_8x8basis= add_8x8basis_mmx;
3217
 
 
3218
 
#endif //CONFIG_ENCODERS
3219
 
 
3220
 
        c->h263_v_loop_filter= h263_v_loop_filter_mmx;
3221
 
        c->h263_h_loop_filter= h263_h_loop_filter_mmx;
3222
 
        c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_mmx;
 
2167
        c->add_bytes_l2= add_bytes_l2_mmx;
 
2168
 
 
2169
        c->draw_edges = draw_edges_mmx;
 
2170
 
 
2171
        if (ENABLE_ANY_H263) {
 
2172
            c->h263_v_loop_filter= h263_v_loop_filter_mmx;
 
2173
            c->h263_h_loop_filter= h263_h_loop_filter_mmx;
 
2174
        }
 
2175
        c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_mmx_rnd;
3223
2176
        c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_mmx;
 
2177
        c->put_no_rnd_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_mmx_nornd;
3224
2178
 
3225
2179
        c->h264_idct_dc_add=
3226
2180
        c->h264_idct_add= ff_h264_idct_add_mmx;
3227
2181
        c->h264_idct8_dc_add=
3228
2182
        c->h264_idct8_add= ff_h264_idct8_add_mmx;
 
2183
        if (mm_flags & MM_SSE2)
 
2184
            c->h264_idct8_add= ff_h264_idct8_add_sse2;
3229
2185
 
3230
2186
        if (mm_flags & MM_MMXEXT) {
3231
2187
            c->prefetch = prefetch_mmx2;
3244
2200
            c->avg_pixels_tab[1][1] = avg_pixels8_x2_mmx2;
3245
2201
            c->avg_pixels_tab[1][2] = avg_pixels8_y2_mmx2;
3246
2202
 
3247
 
#ifdef CONFIG_ENCODERS
3248
 
            c->hadamard8_diff[0]= hadamard8_diff16_mmx2;
3249
 
            c->hadamard8_diff[1]= hadamard8_diff_mmx2;
3250
 
            c->vsad[4]= vsad_intra16_mmx2;
3251
 
#endif //CONFIG_ENCODERS
3252
 
 
3253
2203
            c->h264_idct_dc_add= ff_h264_idct_dc_add_mmx2;
3254
2204
            c->h264_idct8_dc_add= ff_h264_idct8_dc_add_mmx2;
3255
2205
 
3260
2210
                c->put_no_rnd_pixels_tab[1][2] = put_no_rnd_pixels8_y2_mmx2;
3261
2211
                c->avg_pixels_tab[0][3] = avg_pixels16_xy2_mmx2;
3262
2212
                c->avg_pixels_tab[1][3] = avg_pixels8_xy2_mmx2;
3263
 
#ifdef CONFIG_ENCODERS
3264
 
                c->vsad[0] = vsad16_mmx2;
3265
 
#endif //CONFIG_ENCODERS
3266
2213
            }
3267
2214
 
3268
 
#if 1
3269
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 0], qpel16_mc00_mmx2)
3270
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 1], qpel16_mc10_mmx2)
3271
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 2], qpel16_mc20_mmx2)
3272
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 3], qpel16_mc30_mmx2)
3273
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 4], qpel16_mc01_mmx2)
3274
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_mmx2)
3275
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 6], qpel16_mc21_mmx2)
3276
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_mmx2)
3277
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 8], qpel16_mc02_mmx2)
3278
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_mmx2)
3279
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][10], qpel16_mc22_mmx2)
3280
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_mmx2)
3281
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][12], qpel16_mc03_mmx2)
3282
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_mmx2)
3283
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][14], qpel16_mc23_mmx2)
3284
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_mmx2)
3285
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 0], qpel8_mc00_mmx2)
3286
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 1], qpel8_mc10_mmx2)
3287
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 2], qpel8_mc20_mmx2)
3288
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 3], qpel8_mc30_mmx2)
3289
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 4], qpel8_mc01_mmx2)
3290
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_mmx2)
3291
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 6], qpel8_mc21_mmx2)
3292
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_mmx2)
3293
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 8], qpel8_mc02_mmx2)
3294
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_mmx2)
3295
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][10], qpel8_mc22_mmx2)
3296
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_mmx2)
3297
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][12], qpel8_mc03_mmx2)
3298
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_mmx2)
3299
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][14], qpel8_mc23_mmx2)
3300
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_mmx2)
3301
 
#endif
3302
 
 
3303
 
//FIXME 3dnow too
3304
 
#define dspfunc(PFX, IDX, NUM) \
3305
 
    c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_mmx2; \
3306
 
    c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_mmx2; \
3307
 
    c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_mmx2; \
3308
 
    c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_mmx2; \
3309
 
    c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_mmx2; \
3310
 
    c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_mmx2; \
3311
 
    c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_mmx2; \
3312
 
    c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_mmx2; \
3313
 
    c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_mmx2; \
3314
 
    c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_mmx2; \
3315
 
    c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_mmx2; \
3316
 
    c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_mmx2; \
3317
 
    c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_mmx2; \
3318
 
    c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_mmx2; \
3319
 
    c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_mmx2; \
3320
 
    c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_mmx2
3321
 
 
3322
 
            dspfunc(put_h264_qpel, 0, 16);
3323
 
            dspfunc(put_h264_qpel, 1, 8);
3324
 
            dspfunc(put_h264_qpel, 2, 4);
3325
 
            dspfunc(avg_h264_qpel, 0, 16);
3326
 
            dspfunc(avg_h264_qpel, 1, 8);
3327
 
            dspfunc(avg_h264_qpel, 2, 4);
3328
 
 
3329
 
            dspfunc(put_2tap_qpel, 0, 16);
3330
 
            dspfunc(put_2tap_qpel, 1, 8);
3331
 
            dspfunc(avg_2tap_qpel, 0, 16);
3332
 
            dspfunc(avg_2tap_qpel, 1, 8);
3333
 
#undef dspfunc
3334
 
 
3335
 
            c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_mmx2;
 
2215
#define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU) \
 
2216
            c->PFX ## _pixels_tab[IDX][ 0] = PFX ## SIZE ## _mc00_ ## CPU; \
 
2217
            c->PFX ## _pixels_tab[IDX][ 1] = PFX ## SIZE ## _mc10_ ## CPU; \
 
2218
            c->PFX ## _pixels_tab[IDX][ 2] = PFX ## SIZE ## _mc20_ ## CPU; \
 
2219
            c->PFX ## _pixels_tab[IDX][ 3] = PFX ## SIZE ## _mc30_ ## CPU; \
 
2220
            c->PFX ## _pixels_tab[IDX][ 4] = PFX ## SIZE ## _mc01_ ## CPU; \
 
2221
            c->PFX ## _pixels_tab[IDX][ 5] = PFX ## SIZE ## _mc11_ ## CPU; \
 
2222
            c->PFX ## _pixels_tab[IDX][ 6] = PFX ## SIZE ## _mc21_ ## CPU; \
 
2223
            c->PFX ## _pixels_tab[IDX][ 7] = PFX ## SIZE ## _mc31_ ## CPU; \
 
2224
            c->PFX ## _pixels_tab[IDX][ 8] = PFX ## SIZE ## _mc02_ ## CPU; \
 
2225
            c->PFX ## _pixels_tab[IDX][ 9] = PFX ## SIZE ## _mc12_ ## CPU; \
 
2226
            c->PFX ## _pixels_tab[IDX][10] = PFX ## SIZE ## _mc22_ ## CPU; \
 
2227
            c->PFX ## _pixels_tab[IDX][11] = PFX ## SIZE ## _mc32_ ## CPU; \
 
2228
            c->PFX ## _pixels_tab[IDX][12] = PFX ## SIZE ## _mc03_ ## CPU; \
 
2229
            c->PFX ## _pixels_tab[IDX][13] = PFX ## SIZE ## _mc13_ ## CPU; \
 
2230
            c->PFX ## _pixels_tab[IDX][14] = PFX ## SIZE ## _mc23_ ## CPU; \
 
2231
            c->PFX ## _pixels_tab[IDX][15] = PFX ## SIZE ## _mc33_ ## CPU
 
2232
 
 
2233
            SET_QPEL_FUNCS(put_qpel, 0, 16, mmx2);
 
2234
            SET_QPEL_FUNCS(put_qpel, 1, 8, mmx2);
 
2235
            SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, mmx2);
 
2236
            SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, mmx2);
 
2237
            SET_QPEL_FUNCS(avg_qpel, 0, 16, mmx2);
 
2238
            SET_QPEL_FUNCS(avg_qpel, 1, 8, mmx2);
 
2239
 
 
2240
            SET_QPEL_FUNCS(put_h264_qpel, 0, 16, mmx2);
 
2241
            SET_QPEL_FUNCS(put_h264_qpel, 1, 8, mmx2);
 
2242
            SET_QPEL_FUNCS(put_h264_qpel, 2, 4, mmx2);
 
2243
            SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, mmx2);
 
2244
            SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, mmx2);
 
2245
            SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, mmx2);
 
2246
 
 
2247
            SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, mmx2);
 
2248
            SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, mmx2);
 
2249
            SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, mmx2);
 
2250
            SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, mmx2);
 
2251
 
 
2252
            c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_mmx2_rnd;
3336
2253
            c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_mmx2;
3337
2254
            c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_mmx2;
3338
2255
            c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_mmx2;
3362
2279
            c->biweight_h264_pixels_tab[6]= ff_h264_biweight_4x4_mmx2;
3363
2280
            c->biweight_h264_pixels_tab[7]= ff_h264_biweight_4x2_mmx2;
3364
2281
 
3365
 
#ifdef CONFIG_CAVS_DECODER
3366
 
            ff_cavsdsp_init_mmx2(c, avctx);
3367
 
#endif
3368
 
 
3369
 
#ifdef CONFIG_ENCODERS
3370
 
            c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_mmx2;
3371
 
#endif //CONFIG_ENCODERS
 
2282
            if (ENABLE_CAVS_DECODER)
 
2283
                ff_cavsdsp_init_mmx2(c, avctx);
 
2284
 
 
2285
            if (ENABLE_VC1_DECODER || ENABLE_WMV3_DECODER)
 
2286
                ff_vc1dsp_init_mmx(c, avctx);
 
2287
 
 
2288
            c->add_png_paeth_prediction= add_png_paeth_prediction_mmx2;
3372
2289
        } else if (mm_flags & MM_3DNOW) {
3373
2290
            c->prefetch = prefetch_3dnow;
3374
2291
 
3395
2312
                c->avg_pixels_tab[1][3] = avg_pixels8_xy2_3dnow;
3396
2313
            }
3397
2314
 
3398
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 0], qpel16_mc00_3dnow)
3399
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 1], qpel16_mc10_3dnow)
3400
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 2], qpel16_mc20_3dnow)
3401
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 3], qpel16_mc30_3dnow)
3402
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 4], qpel16_mc01_3dnow)
3403
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_3dnow)
3404
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 6], qpel16_mc21_3dnow)
3405
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_3dnow)
3406
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 8], qpel16_mc02_3dnow)
3407
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_3dnow)
3408
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][10], qpel16_mc22_3dnow)
3409
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_3dnow)
3410
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][12], qpel16_mc03_3dnow)
3411
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_3dnow)
3412
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][14], qpel16_mc23_3dnow)
3413
 
            SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_3dnow)
3414
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 0], qpel8_mc00_3dnow)
3415
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 1], qpel8_mc10_3dnow)
3416
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 2], qpel8_mc20_3dnow)
3417
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 3], qpel8_mc30_3dnow)
3418
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 4], qpel8_mc01_3dnow)
3419
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_3dnow)
3420
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 6], qpel8_mc21_3dnow)
3421
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_3dnow)
3422
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 8], qpel8_mc02_3dnow)
3423
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_3dnow)
3424
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][10], qpel8_mc22_3dnow)
3425
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_3dnow)
3426
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][12], qpel8_mc03_3dnow)
3427
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_3dnow)
3428
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][14], qpel8_mc23_3dnow)
3429
 
            SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_3dnow)
3430
 
 
3431
 
#define dspfunc(PFX, IDX, NUM) \
3432
 
    c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_3dnow; \
3433
 
    c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_3dnow; \
3434
 
    c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_3dnow; \
3435
 
    c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_3dnow; \
3436
 
    c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_3dnow; \
3437
 
    c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_3dnow; \
3438
 
    c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_3dnow; \
3439
 
    c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_3dnow; \
3440
 
    c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_3dnow; \
3441
 
    c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_3dnow; \
3442
 
    c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_3dnow; \
3443
 
    c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_3dnow; \
3444
 
    c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_3dnow; \
3445
 
    c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_3dnow; \
3446
 
    c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_3dnow; \
3447
 
    c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_3dnow
3448
 
 
3449
 
            dspfunc(put_h264_qpel, 0, 16);
3450
 
            dspfunc(put_h264_qpel, 1, 8);
3451
 
            dspfunc(put_h264_qpel, 2, 4);
3452
 
            dspfunc(avg_h264_qpel, 0, 16);
3453
 
            dspfunc(avg_h264_qpel, 1, 8);
3454
 
            dspfunc(avg_h264_qpel, 2, 4);
3455
 
 
3456
 
            dspfunc(put_2tap_qpel, 0, 16);
3457
 
            dspfunc(put_2tap_qpel, 1, 8);
3458
 
            dspfunc(avg_2tap_qpel, 0, 16);
3459
 
            dspfunc(avg_2tap_qpel, 1, 8);
3460
 
 
3461
 
            c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_3dnow;
 
2315
            SET_QPEL_FUNCS(put_qpel, 0, 16, 3dnow);
 
2316
            SET_QPEL_FUNCS(put_qpel, 1, 8, 3dnow);
 
2317
            SET_QPEL_FUNCS(put_no_rnd_qpel, 0, 16, 3dnow);
 
2318
            SET_QPEL_FUNCS(put_no_rnd_qpel, 1, 8, 3dnow);
 
2319
            SET_QPEL_FUNCS(avg_qpel, 0, 16, 3dnow);
 
2320
            SET_QPEL_FUNCS(avg_qpel, 1, 8, 3dnow);
 
2321
 
 
2322
            SET_QPEL_FUNCS(put_h264_qpel, 0, 16, 3dnow);
 
2323
            SET_QPEL_FUNCS(put_h264_qpel, 1, 8, 3dnow);
 
2324
            SET_QPEL_FUNCS(put_h264_qpel, 2, 4, 3dnow);
 
2325
            SET_QPEL_FUNCS(avg_h264_qpel, 0, 16, 3dnow);
 
2326
            SET_QPEL_FUNCS(avg_h264_qpel, 1, 8, 3dnow);
 
2327
            SET_QPEL_FUNCS(avg_h264_qpel, 2, 4, 3dnow);
 
2328
 
 
2329
            SET_QPEL_FUNCS(put_2tap_qpel, 0, 16, 3dnow);
 
2330
            SET_QPEL_FUNCS(put_2tap_qpel, 1, 8, 3dnow);
 
2331
            SET_QPEL_FUNCS(avg_2tap_qpel, 0, 16, 3dnow);
 
2332
            SET_QPEL_FUNCS(avg_2tap_qpel, 1, 8, 3dnow);
 
2333
 
 
2334
            c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_3dnow_rnd;
3462
2335
            c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_3dnow;
3463
 
        }
3464
 
 
3465
 
#ifdef CONFIG_SNOW_DECODER
 
2336
 
 
2337
            if (ENABLE_CAVS_DECODER)
 
2338
                ff_cavsdsp_init_3dnow(c, avctx);
 
2339
        }
 
2340
 
 
2341
 
 
2342
#define H264_QPEL_FUNCS(x, y, CPU)\
 
2343
            c->put_h264_qpel_pixels_tab[0][x+y*4] = put_h264_qpel16_mc##x##y##_##CPU;\
 
2344
            c->put_h264_qpel_pixels_tab[1][x+y*4] = put_h264_qpel8_mc##x##y##_##CPU;\
 
2345
            c->avg_h264_qpel_pixels_tab[0][x+y*4] = avg_h264_qpel16_mc##x##y##_##CPU;\
 
2346
            c->avg_h264_qpel_pixels_tab[1][x+y*4] = avg_h264_qpel8_mc##x##y##_##CPU;
 
2347
        if((mm_flags & MM_SSE2) && !(mm_flags & MM_3DNOW)){
 
2348
            // these functions are slower than mmx on AMD, but faster on Intel
 
2349
/* FIXME works in most codecs, but crashes svq1 due to unaligned chroma
 
2350
            c->put_pixels_tab[0][0] = put_pixels16_sse2;
 
2351
            c->avg_pixels_tab[0][0] = avg_pixels16_sse2;
 
2352
*/
 
2353
            H264_QPEL_FUNCS(0, 0, sse2);
 
2354
        }
3466
2355
        if(mm_flags & MM_SSE2){
 
2356
            H264_QPEL_FUNCS(0, 1, sse2);
 
2357
            H264_QPEL_FUNCS(0, 2, sse2);
 
2358
            H264_QPEL_FUNCS(0, 3, sse2);
 
2359
            H264_QPEL_FUNCS(1, 1, sse2);
 
2360
            H264_QPEL_FUNCS(1, 2, sse2);
 
2361
            H264_QPEL_FUNCS(1, 3, sse2);
 
2362
            H264_QPEL_FUNCS(2, 1, sse2);
 
2363
            H264_QPEL_FUNCS(2, 2, sse2);
 
2364
            H264_QPEL_FUNCS(2, 3, sse2);
 
2365
            H264_QPEL_FUNCS(3, 1, sse2);
 
2366
            H264_QPEL_FUNCS(3, 2, sse2);
 
2367
            H264_QPEL_FUNCS(3, 3, sse2);
 
2368
        }
 
2369
#ifdef HAVE_SSSE3
 
2370
        if(mm_flags & MM_SSSE3){
 
2371
            H264_QPEL_FUNCS(1, 0, ssse3);
 
2372
            H264_QPEL_FUNCS(1, 1, ssse3);
 
2373
            H264_QPEL_FUNCS(1, 2, ssse3);
 
2374
            H264_QPEL_FUNCS(1, 3, ssse3);
 
2375
            H264_QPEL_FUNCS(2, 0, ssse3);
 
2376
            H264_QPEL_FUNCS(2, 1, ssse3);
 
2377
            H264_QPEL_FUNCS(2, 2, ssse3);
 
2378
            H264_QPEL_FUNCS(2, 3, ssse3);
 
2379
            H264_QPEL_FUNCS(3, 0, ssse3);
 
2380
            H264_QPEL_FUNCS(3, 1, ssse3);
 
2381
            H264_QPEL_FUNCS(3, 2, ssse3);
 
2382
            H264_QPEL_FUNCS(3, 3, ssse3);
 
2383
            c->put_no_rnd_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_ssse3_nornd;
 
2384
            c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_ssse3_rnd;
 
2385
            c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_ssse3_rnd;
 
2386
            c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_ssse3;
 
2387
            c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_ssse3;
 
2388
            c->add_png_paeth_prediction= add_png_paeth_prediction_ssse3;
 
2389
        }
 
2390
#endif
 
2391
 
 
2392
#ifdef CONFIG_SNOW_DECODER
 
2393
        if(mm_flags & MM_SSE2 & 0){
3467
2394
            c->horizontal_compose97i = ff_snow_horizontal_compose97i_sse2;
 
2395
#ifdef HAVE_7REGS
3468
2396
            c->vertical_compose97i = ff_snow_vertical_compose97i_sse2;
 
2397
#endif
3469
2398
            c->inner_add_yblock = ff_snow_inner_add_yblock_sse2;
3470
2399
        }
3471
2400
        else{
 
2401
            if(mm_flags & MM_MMXEXT){
3472
2402
            c->horizontal_compose97i = ff_snow_horizontal_compose97i_mmx;
 
2403
#ifdef HAVE_7REGS
3473
2404
            c->vertical_compose97i = ff_snow_vertical_compose97i_mmx;
 
2405
#endif
 
2406
            }
3474
2407
            c->inner_add_yblock = ff_snow_inner_add_yblock_mmx;
3475
2408
        }
3476
2409
#endif
3494
2427
            c->vector_fmul_add_add = vector_fmul_add_add_3dnow; // faster than sse
3495
2428
    }
3496
2429
 
3497
 
#ifdef CONFIG_ENCODERS
3498
 
    dsputil_init_pix_mmx(c, avctx);
3499
 
#endif //CONFIG_ENCODERS
 
2430
    if (ENABLE_ENCODERS)
 
2431
        dsputilenc_init_mmx(c, avctx);
 
2432
 
3500
2433
#if 0
3501
2434
    // for speed testing
3502
2435
    get_pixels = just_return;