Revision f2217d6f

View differences:

libavcodec/i386/dsputil_mmx_avg.h
33 33
 */
34 34
static void DEF(put_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
35 35
{
36
    __asm __volatile(
36
    asm volatile(
37 37
        "lea (%3, %3), %%"REG_a"        \n\t"
38 38
        "1:                             \n\t"
39 39
        "movq (%1), %%mm0               \n\t"
......
61 61

  
62 62
static void DEF(put_pixels4_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
63 63
{
64
    __asm __volatile(
64
    asm volatile(
65 65
        "testl $1, %0                   \n\t"
66 66
            " jz 1f                     \n\t"
67 67
        "movd   (%1), %%mm0             \n\t"
......
112 112

  
113 113
static void DEF(put_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
114 114
{
115
    __asm __volatile(
115
    asm volatile(
116 116
        "testl $1, %0                   \n\t"
117 117
            " jz 1f                     \n\t"
118 118
        "movq   (%1), %%mm0             \n\t"
......
162 162

  
163 163
static void DEF(put_no_rnd_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
164 164
{
165
    __asm __volatile(
165
    asm volatile(
166 166
        "pcmpeqb %%mm6, %%mm6           \n\t"
167 167
        "testl $1, %0                   \n\t"
168 168
            " jz 1f                     \n\t"
......
232 232

  
233 233
static void DEF(avg_pixels4_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
234 234
{
235
    __asm __volatile(
235
    asm volatile(
236 236
        "testl $1, %0                   \n\t"
237 237
            " jz 1f                     \n\t"
238 238
        "movd   (%1), %%mm0             \n\t"
......
284 284

  
285 285
static void DEF(avg_pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
286 286
{
287
    __asm __volatile(
287
    asm volatile(
288 288
        "testl $1, %0                   \n\t"
289 289
            " jz 1f                     \n\t"
290 290
        "movq   (%1), %%mm0             \n\t"
......
339 339

  
340 340
static void DEF(put_pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
341 341
{
342
    __asm __volatile(
342
    asm volatile(
343 343
        "lea (%3, %3), %%"REG_a"        \n\t"
344 344
        "1:                             \n\t"
345 345
        "movq (%1), %%mm0               \n\t"
......
379 379

  
380 380
static void DEF(put_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
381 381
{
382
    __asm __volatile(
382
    asm volatile(
383 383
        "testl $1, %0                   \n\t"
384 384
            " jz 1f                     \n\t"
385 385
        "movq   (%1), %%mm0             \n\t"
......
427 427

  
428 428
static void DEF(avg_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
429 429
{
430
    __asm __volatile(
430
    asm volatile(
431 431
        "testl $1, %0                   \n\t"
432 432
            " jz 1f                     \n\t"
433 433
        "movq   (%1), %%mm0             \n\t"
......
481 481

  
482 482
static void DEF(put_no_rnd_pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
483 483
{
484
    __asm __volatile(
484
    asm volatile(
485 485
        "pcmpeqb %%mm6, %%mm6           \n\t"
486 486
        "testl $1, %0                   \n\t"
487 487
            " jz 1f                     \n\t"
......
556 556
static void DEF(put_no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
557 557
{
558 558
    MOVQ_BONE(mm6);
559
    __asm __volatile(
559
    asm volatile(
560 560
        "lea (%3, %3), %%"REG_a"        \n\t"
561 561
        "1:                             \n\t"
562 562
        "movq (%1), %%mm0               \n\t"
......
592 592

  
593 593
static void DEF(put_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
594 594
{
595
    __asm __volatile(
595
    asm volatile(
596 596
        "lea (%3, %3), %%"REG_a"        \n\t"
597 597
        "movq (%1), %%mm0               \n\t"
598 598
        "sub %3, %2                     \n\t"
......
624 624
static void DEF(put_no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
625 625
{
626 626
    MOVQ_BONE(mm6);
627
    __asm __volatile(
627
    asm volatile(
628 628
        "lea (%3, %3), %%"REG_a"        \n\t"
629 629
        "movq (%1), %%mm0               \n\t"
630 630
        "sub %3, %2                     \n\t"
......
656 656

  
657 657
static void DEF(avg_pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
658 658
{
659
    __asm __volatile(
659
    asm volatile(
660 660
        "lea (%3, %3), %%"REG_a"        \n\t"
661 661
        "1:                             \n\t"
662 662
        "movq (%2), %%mm0               \n\t"
......
684 684

  
685 685
static void DEF(avg_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
686 686
{
687
    __asm __volatile(
687
    asm volatile(
688 688
        "lea (%3, %3), %%"REG_a"        \n\t"
689 689
        "1:                             \n\t"
690 690
        "movq (%1), %%mm0               \n\t"
......
716 716

  
717 717
static void DEF(avg_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
718 718
{
719
    __asm __volatile(
719
    asm volatile(
720 720
        "lea (%3, %3), %%"REG_a"        \n\t"
721 721
        "movq (%1), %%mm0               \n\t"
722 722
        "sub %3, %2                     \n\t"
......
757 757
static void DEF(avg_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
758 758
{
759 759
    MOVQ_BONE(mm6);
760
    __asm __volatile(
760
    asm volatile(
761 761
        "lea (%3, %3), %%"REG_a"        \n\t"
762 762
        "movq (%1), %%mm0               \n\t"
763 763
        PAVGB" 1(%1), %%mm0             \n\t"
libavcodec/i386/dsputil_mmx_rnd.h
32 32
static void DEF(put, pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
33 33
{
34 34
    MOVQ_BFE(mm6);
35
    __asm __volatile(
35
    asm volatile(
36 36
        "lea    (%3, %3), %%"REG_a"     \n\t"
37 37
        ASMALIGN(3)
38 38
        "1:                             \n\t"
......
64 64
static void av_unused DEF(put, pixels8_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
65 65
{
66 66
    MOVQ_BFE(mm6);
67
    __asm __volatile(
67
    asm volatile(
68 68
        "testl $1, %0                   \n\t"
69 69
        " jz 1f                         \n\t"
70 70
        "movq   (%1), %%mm0             \n\t"
......
114 114
static void DEF(put, pixels16_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
115 115
{
116 116
    MOVQ_BFE(mm6);
117
    __asm __volatile(
117
    asm volatile(
118 118
        "lea        (%3, %3), %%"REG_a" \n\t"
119 119
        ASMALIGN(3)
120 120
        "1:                             \n\t"
......
160 160
static void av_unused DEF(put, pixels16_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int dstStride, int src1Stride, int h)
161 161
{
162 162
    MOVQ_BFE(mm6);
163
    __asm __volatile(
163
    asm volatile(
164 164
        "testl $1, %0                   \n\t"
165 165
        " jz 1f                         \n\t"
166 166
        "movq   (%1), %%mm0             \n\t"
......
209 209
static void DEF(put, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
210 210
{
211 211
    MOVQ_BFE(mm6);
212
    __asm __volatile(
212
    asm volatile(
213 213
        "lea (%3, %3), %%"REG_a"        \n\t"
214 214
        "movq (%1), %%mm0               \n\t"
215 215
        ASMALIGN(3)
......
239 239
{
240 240
    MOVQ_ZERO(mm7);
241 241
    SET_RND(mm6); // =2 for rnd  and  =1 for no_rnd version
242
    __asm __volatile(
242
    asm volatile(
243 243
        "movq   (%1), %%mm0             \n\t"
244 244
        "movq   1(%1), %%mm4            \n\t"
245 245
        "movq   %%mm0, %%mm1            \n\t"
......
307 307
    MOVQ_BFE(mm6);
308 308
    JUMPALIGN();
309 309
    do {
310
        __asm __volatile(
310
        asm volatile(
311 311
             "movd  %0, %%mm0           \n\t"
312 312
             "movd  %1, %%mm1           \n\t"
313 313
             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
......
327 327
    MOVQ_BFE(mm6);
328 328
    JUMPALIGN();
329 329
    do {
330
        __asm __volatile(
330
        asm volatile(
331 331
             "movq  %0, %%mm0           \n\t"
332 332
             "movq  %1, %%mm1           \n\t"
333 333
             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
......
346 346
    MOVQ_BFE(mm6);
347 347
    JUMPALIGN();
348 348
    do {
349
        __asm __volatile(
349
        asm volatile(
350 350
             "movq  %0, %%mm0           \n\t"
351 351
             "movq  %1, %%mm1           \n\t"
352 352
             PAVGB(%%mm0, %%mm1, %%mm2, %%mm6)
......
369 369
    MOVQ_BFE(mm6);
370 370
    JUMPALIGN();
371 371
    do {
372
        __asm __volatile(
372
        asm volatile(
373 373
            "movq  %1, %%mm0            \n\t"
374 374
            "movq  1%1, %%mm1           \n\t"
375 375
            "movq  %0, %%mm3            \n\t"
......
389 389
    MOVQ_BFE(mm6);
390 390
    JUMPALIGN();
391 391
    do {
392
        __asm __volatile(
392
        asm volatile(
393 393
            "movq  %1, %%mm0            \n\t"
394 394
            "movq  %2, %%mm1            \n\t"
395 395
            "movq  %0, %%mm3            \n\t"
......
410 410
    MOVQ_BFE(mm6);
411 411
    JUMPALIGN();
412 412
    do {
413
        __asm __volatile(
413
        asm volatile(
414 414
            "movq  %1, %%mm0            \n\t"
415 415
            "movq  1%1, %%mm1           \n\t"
416 416
            "movq  %0, %%mm3            \n\t"
......
436 436
    MOVQ_BFE(mm6);
437 437
    JUMPALIGN();
438 438
    do {
439
        __asm __volatile(
439
        asm volatile(
440 440
            "movq  %1, %%mm0            \n\t"
441 441
            "movq  %2, %%mm1            \n\t"
442 442
            "movq  %0, %%mm3            \n\t"
......
461 461
static void DEF(avg, pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)
462 462
{
463 463
    MOVQ_BFE(mm6);
464
    __asm __volatile(
464
    asm volatile(
465 465
        "lea    (%3, %3), %%"REG_a"     \n\t"
466 466
        "movq   (%1), %%mm0             \n\t"
467 467
        ASMALIGN(3)
......
502 502
{
503 503
    MOVQ_ZERO(mm7);
504 504
    SET_RND(mm6); // =2 for rnd  and  =1 for no_rnd version
505
    __asm __volatile(
505
    asm volatile(
506 506
        "movq   (%1), %%mm0             \n\t"
507 507
        "movq   1(%1), %%mm4            \n\t"
508 508
        "movq   %%mm0, %%mm1            \n\t"

Also available in: Unified diff