syslinux/com32/lib/libpng/pngvcrd.c

   1 /* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file
   2  *
   3  * For Intel x86 CPU and Microsoft Visual C++ compiler
   4  *
   5  * libpng version 1.2.8 - December 3, 2004
   6  * For conditions of distribution and use, see copyright notice in png.h
   7  * Copyright (c) 1998-2004 Glenn Randers-Pehrson
   8  * Copyright (c) 1998, Intel Corporation
   9  *
  10  * Contributed by Nirav Chhatrapati, Intel Corporation, 1998
  11  * Interface to libpng contributed by Gilles Vollant, 1999
  12  *
  13  *
  14  * In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d,
  15  * a sign error in the post-MMX cleanup code for each pixel_depth resulted
  16  * in bad pixels at the beginning of some rows of some images, and also
  17  * (due to out-of-range memory reads and writes) caused heap corruption
  18  * when compiled with MSVC 6.0.  The error was fixed in version 1.0.4e.
  19  *
  20  * [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916]
  21  *
  22  * [runtime MMX configuration, GRR 20010102]
  23  *
  24  */
  25
  26 #define PNG_INTERNAL
  27 #include "png.h"
  28
  29 #if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)
  30
  31 static int mmx_supported=2;
  32
  33
  34 int PNGAPI
  35 png_mmx_support(void)
  36 {
  37   int mmx_supported_local = 0;
  38   _asm {
  39     push ebx          //CPUID will trash these
  40     push ecx
  41     push edx
  42
  43     pushfd            //Save Eflag to stack
  44     pop eax           //Get Eflag from stack into eax
  45     mov ecx, eax      //Make another copy of Eflag in ecx
  46     xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)]
  47     push eax          //Save modified Eflag back to stack
  48
  49     popfd             //Restored modified value back to Eflag reg
  50     pushfd            //Save Eflag to stack
  51     pop eax           //Get Eflag from stack
  52     push ecx          // save original Eflag to stack
  53     popfd             // restore original Eflag
  54     xor eax, ecx      //Compare the new Eflag with the original Eflag
  55     jz NOT_SUPPORTED  //If the same, CPUID instruction is not supported,
  56                       //skip following instructions and jump to
  57                       //NOT_SUPPORTED label
  58
  59     xor eax, eax      //Set eax to zero
  60
  61     _asm _emit 0x0f   //CPUID instruction  (two bytes opcode)
  62     _asm _emit 0xa2
  63
  64     cmp eax, 1        //make sure eax return non-zero value
  65     jl NOT_SUPPORTED  //If eax is zero, mmx not supported
  66
  67     xor eax, eax      //set eax to zero
  68     inc eax           //Now increment eax to 1.  This instruction is
  69                       //faster than the instruction "mov eax, 1"
  70
  71     _asm _emit 0x0f   //CPUID instruction
  72     _asm _emit 0xa2
  73
  74     and edx, 0x00800000  //mask out all bits but mmx bit(24)
  75     cmp edx, 0        // 0 = mmx not supported
  76     jz  NOT_SUPPORTED // non-zero = Yes, mmx IS supported
  77
  78     mov  mmx_supported_local, 1  //set return value to 1
  79
  80 NOT_SUPPORTED:
  81     mov  eax, mmx_supported_local  //move return value to eax
  82     pop edx          //CPUID trashed these
  83     pop ecx
  84     pop ebx
  85   }
  86
  87   //mmx_supported_local=0; // test code for force don't support MMX
  88   //printf("MMX : %u (1=MMX supported)\n",mmx_supported_local);
  89
  90   mmx_supported = mmx_supported_local;
  91   return mmx_supported_local;
  92 }
  93
  94 /* Combines the row recently read in with the previous row.
  95    This routine takes care of alpha and transparency if requested.
  96    This routine also handles the two methods of progressive display
  97    of interlaced images, depending on the mask value.
  98    The mask value describes which pixels are to be combined with
  99    the row.  The pattern always repeats every 8 pixels, so just 8
 100    bits are needed.  A one indicates the pixel is to be combined; a
 101    zero indicates the pixel is to be skipped.  This is in addition
 102    to any alpha or transparency value associated with the pixel.  If
 103    you want all pixels to be combined, pass 0xff (255) in mask.  */
 104
 105 /* Use this routine for x86 platform - uses faster MMX routine if machine
 106    supports MMX */
 107
 108 void /* PRIVATE */
 109 png_combine_row(png_structp png_ptr, png_bytep row, int mask)
 110 {
 111 #ifdef PNG_USE_LOCAL_ARRAYS
 112    const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 113 #endif
 114
 115    png_debug(1,"in png_combine_row_asm\n");
 116
 117    if (mmx_supported == 2) {
 118 #if !defined(PNG_1_0_X)
 119        /* this should have happened in png_init_mmx_flags() already */
 120        png_warning(png_ptr, "asm_flags may not have been initialized");
 121 #endif
 122        png_mmx_support();
 123    }
 124
 125    if (mask == 0xff)
 126    {
 127       png_memcpy(row, png_ptr->row_buf + 1,
 128        (png_size_t)PNG_ROWBYTES(png_ptr->row_info.pixel_depth,
 129        png_ptr->width));
 130    }
 131    /* GRR:  add "else if (mask == 0)" case?
 132     *       or does png_combine_row() not even get called in that case? */
 133    else
 134    {
 135       switch (png_ptr->row_info.pixel_depth)
 136       {
 137          case 1:
 138          {
 139             png_bytep sp;
 140             png_bytep dp;
 141             int s_inc, s_start, s_end;
 142             int m;
 143             int shift;
 144             png_uint_32 i;
 145
 146             sp = png_ptr->row_buf + 1;
 147             dp = row;
 148             m = 0x80;
 149 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
 150             if (png_ptr->transformations & PNG_PACKSWAP)
 151             {
 152                 s_start = 0;
 153                 s_end = 7;
 154                 s_inc = 1;
 155             }
 156             else
 157 #endif
 158             {
 159                 s_start = 7;
 160                 s_end = 0;
 161                 s_inc = -1;
 162             }
 163
 164             shift = s_start;
 165
 166             for (i = 0; i < png_ptr->width; i++)
 167             {
 168                if (m & mask)
 169                {
 170                   int value;
 171
 172                   value = (*sp >> shift) & 0x1;
 173                   *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
 174                   *dp |= (png_byte)(value << shift);
 175                }
 176
 177                if (shift == s_end)
 178                {
 179                   shift = s_start;
 180                   sp++;
 181                   dp++;
 182                }
 183                else
 184                   shift += s_inc;
 185
 186                if (m == 1)
 187                   m = 0x80;
 188                else
 189                   m >>= 1;
 190             }
 191             break;
 192          }
 193
 194          case 2:
 195          {
 196             png_bytep sp;
 197             png_bytep dp;
 198             int s_start, s_end, s_inc;
 199             int m;
 200             int shift;
 201             png_uint_32 i;
 202             int value;
 203
 204             sp = png_ptr->row_buf + 1;
 205             dp = row;
 206             m = 0x80;
 207 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
 208             if (png_ptr->transformations & PNG_PACKSWAP)
 209             {
 210                s_start = 0;
 211                s_end = 6;
 212                s_inc = 2;
 213             }
 214             else
 215 #endif
 216             {
 217                s_start = 6;
 218                s_end = 0;
 219                s_inc = -2;
 220             }
 221
 222             shift = s_start;
 223
 224             for (i = 0; i < png_ptr->width; i++)
 225             {
 226                if (m & mask)
 227                {
 228                   value = (*sp >> shift) & 0x3;
 229                   *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
 230                   *dp |= (png_byte)(value << shift);
 231                }
 232
 233                if (shift == s_end)
 234                {
 235                   shift = s_start;
 236                   sp++;
 237                   dp++;
 238                }
 239                else
 240                   shift += s_inc;
 241                if (m == 1)
 242                   m = 0x80;
 243                else
 244                   m >>= 1;
 245             }
 246             break;
 247          }
 248
 249          case 4:
 250          {
 251             png_bytep sp;
 252             png_bytep dp;
 253             int s_start, s_end, s_inc;
 254             int m;
 255             int shift;
 256             png_uint_32 i;
 257             int value;
 258
 259             sp = png_ptr->row_buf + 1;
 260             dp = row;
 261             m = 0x80;
 262 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
 263             if (png_ptr->transformations & PNG_PACKSWAP)
 264             {
 265                s_start = 0;
 266                s_end = 4;
 267                s_inc = 4;
 268             }
 269             else
 270 #endif
 271             {
 272                s_start = 4;
 273                s_end = 0;
 274                s_inc = -4;
 275             }
 276             shift = s_start;
 277
 278             for (i = 0; i < png_ptr->width; i++)
 279             {
 280                if (m & mask)
 281                {
 282                   value = (*sp >> shift) & 0xf;
 283                   *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
 284                   *dp |= (png_byte)(value << shift);
 285                }
 286
 287                if (shift == s_end)
 288                {
 289                   shift = s_start;
 290                   sp++;
 291                   dp++;
 292                }
 293                else
 294                   shift += s_inc;
 295                if (m == 1)
 296                   m = 0x80;
 297                else
 298                   m >>= 1;
 299             }
 300             break;
 301          }
 302
 303          case 8:
 304          {
 305             png_bytep srcptr;
 306             png_bytep dstptr;
 307             png_uint_32 len;
 308             int m;
 309             int diff, unmask;
 310
 311             __int64 mask0=0x0102040810204080;
 312
 313 #if !defined(PNG_1_0_X)
 314             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
 315                 /* && mmx_supported */ )
 316 #else
 317             if (mmx_supported)
 318 #endif
 319             {
 320                srcptr = png_ptr->row_buf + 1;
 321                dstptr = row;
 322                m = 0x80;
 323                unmask = ~mask;
 324                len  = png_ptr->width &~7;  //reduce to multiple of 8
 325                diff = png_ptr->width & 7;  //amount lost
 326
 327                _asm
 328                {
 329                   movd       mm7, unmask   //load bit pattern
 330                   psubb      mm6,mm6       //zero mm6
 331                   punpcklbw  mm7,mm7
 332                   punpcklwd  mm7,mm7
 333                   punpckldq  mm7,mm7       //fill register with 8 masks
 334
 335                   movq       mm0,mask0
 336
 337                   pand       mm0,mm7       //nonzero if keep byte
 338                   pcmpeqb    mm0,mm6       //zeros->1s, v versa
 339
 340                   mov        ecx,len       //load length of line (pixels)
 341                   mov        esi,srcptr    //load source
 342                   mov        ebx,dstptr    //load dest
 343                   cmp        ecx,0         //lcr
 344                   je         mainloop8end
 345
 346 mainloop8:
 347                   movq       mm4,[esi]
 348                   pand       mm4,mm0
 349                   movq       mm6,mm0
 350                   pandn      mm6,[ebx]
 351                   por        mm4,mm6
 352                   movq       [ebx],mm4
 353
 354                   add        esi,8         //inc by 8 bytes processed
 355                   add        ebx,8
 356                   sub        ecx,8         //dec by 8 pixels processed
 357
 358                   ja         mainloop8
 359 mainloop8end:
 360
 361                   mov        ecx,diff
 362                   cmp        ecx,0
 363                   jz         end8
 364
 365                   mov        edx,mask
 366                   sal        edx,24        //make low byte the high byte
 367
 368 secondloop8:
 369                   sal        edx,1         //move high bit to CF
 370                   jnc        skip8         //if CF = 0
 371                   mov        al,[esi]
 372                   mov        [ebx],al
 373 skip8:
 374                   inc        esi
 375                   inc        ebx
 376
 377                   dec        ecx
 378                   jnz        secondloop8
 379 end8:
 380                   emms
 381                }
 382             }
 383             else /* mmx not supported - use modified C routine */
 384             {
 385                register unsigned int incr1, initial_val, final_val;
 386                png_size_t pixel_bytes;
 387                png_uint_32 i;
 388                register int disp = png_pass_inc[png_ptr->pass];
 389                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 390
 391                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 392                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
 393                   pixel_bytes;
 394                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
 395                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
 396                final_val = png_ptr->width*pixel_bytes;
 397                incr1 = (disp)*pixel_bytes;
 398                for (i = initial_val; i < final_val; i += incr1)
 399                {
 400                   png_memcpy(dstptr, srcptr, pixel_bytes);
 401                   srcptr += incr1;
 402                   dstptr += incr1;
 403                }
 404             } /* end of else */
 405
 406             break;
 407          }       // end 8 bpp
 408
 409          case 16:
 410          {
 411             png_bytep srcptr;
 412             png_bytep dstptr;
 413             png_uint_32 len;
 414             int unmask, diff;
 415             __int64 mask1=0x0101020204040808,
 416                     mask0=0x1010202040408080;
 417
 418 #if !defined(PNG_1_0_X)
 419             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
 420                 /* && mmx_supported */ )
 421 #else
 422             if (mmx_supported)
 423 #endif
 424             {
 425                srcptr = png_ptr->row_buf + 1;
 426                dstptr = row;
 427
 428                unmask = ~mask;
 429                len     = (png_ptr->width)&~7;
 430                diff = (png_ptr->width)&7;
 431                _asm
 432                {
 433                   movd       mm7, unmask       //load bit pattern
 434                   psubb      mm6,mm6           //zero mm6
 435                   punpcklbw  mm7,mm7
 436                   punpcklwd  mm7,mm7
 437                   punpckldq  mm7,mm7           //fill register with 8 masks
 438
 439                   movq       mm0,mask0
 440                   movq       mm1,mask1
 441
 442                   pand       mm0,mm7
 443                   pand       mm1,mm7
 444
 445                   pcmpeqb    mm0,mm6
 446                   pcmpeqb    mm1,mm6
 447
 448                   mov        ecx,len           //load length of line
 449                   mov        esi,srcptr        //load source
 450                   mov        ebx,dstptr        //load dest
 451                   cmp        ecx,0             //lcr
 452                   jz         mainloop16end
 453
 454 mainloop16:
 455                   movq       mm4,[esi]
 456                   pand       mm4,mm0
 457                   movq       mm6,mm0
 458                   movq       mm7,[ebx]
 459                   pandn      mm6,mm7
 460                   por        mm4,mm6
 461                   movq       [ebx],mm4
 462
 463                   movq       mm5,[esi+8]
 464                   pand       mm5,mm1
 465                   movq       mm7,mm1
 466                   movq       mm6,[ebx+8]
 467                   pandn      mm7,mm6
 468                   por        mm5,mm7
 469                   movq       [ebx+8],mm5
 470
 471                   add        esi,16            //inc by 16 bytes processed
 472                   add        ebx,16
 473                   sub        ecx,8             //dec by 8 pixels processed
 474
 475                   ja         mainloop16
 476
 477 mainloop16end:
 478                   mov        ecx,diff
 479                   cmp        ecx,0
 480                   jz         end16
 481
 482                   mov        edx,mask
 483                   sal        edx,24            //make low byte the high byte
 484 secondloop16:
 485                   sal        edx,1             //move high bit to CF
 486                   jnc        skip16            //if CF = 0
 487                   mov        ax,[esi]
 488                   mov        [ebx],ax
 489 skip16:
 490                   add        esi,2
 491                   add        ebx,2
 492
 493                   dec        ecx
 494                   jnz        secondloop16
 495 end16:
 496                   emms
 497                }
 498             }
 499             else /* mmx not supported - use modified C routine */
 500             {
 501                register unsigned int incr1, initial_val, final_val;
 502                png_size_t pixel_bytes;
 503                png_uint_32 i;
 504                register int disp = png_pass_inc[png_ptr->pass];
 505                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 506
 507                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 508                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
 509                   pixel_bytes;
 510                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
 511                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
 512                final_val = png_ptr->width*pixel_bytes;
 513                incr1 = (disp)*pixel_bytes;
 514                for (i = initial_val; i < final_val; i += incr1)
 515                {
 516                   png_memcpy(dstptr, srcptr, pixel_bytes);
 517                   srcptr += incr1;
 518                   dstptr += incr1;
 519                }
 520             } /* end of else */
 521
 522             break;
 523          }       // end 16 bpp
 524
 525          case 24:
 526          {
 527             png_bytep srcptr;
 528             png_bytep dstptr;
 529             png_uint_32 len;
 530             int unmask, diff;
 531
 532             __int64 mask2=0x0101010202020404,  //24bpp
 533                     mask1=0x0408080810101020,
 534                     mask0=0x2020404040808080;
 535
 536             srcptr = png_ptr->row_buf + 1;
 537             dstptr = row;
 538
 539             unmask = ~mask;
 540             len     = (png_ptr->width)&~7;
 541             diff = (png_ptr->width)&7;
 542
 543 #if !defined(PNG_1_0_X)
 544             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
 545                 /* && mmx_supported */ )
 546 #else
 547             if (mmx_supported)
 548 #endif
 549             {
 550                _asm
 551                {
 552                   movd       mm7, unmask       //load bit pattern
 553                   psubb      mm6,mm6           //zero mm6
 554                   punpcklbw  mm7,mm7
 555                   punpcklwd  mm7,mm7
 556                   punpckldq  mm7,mm7           //fill register with 8 masks
 557
 558                   movq       mm0,mask0
 559                   movq       mm1,mask1
 560                   movq       mm2,mask2
 561
 562                   pand       mm0,mm7
 563                   pand       mm1,mm7
 564                   pand       mm2,mm7
 565
 566                   pcmpeqb    mm0,mm6
 567                   pcmpeqb    mm1,mm6
 568                   pcmpeqb    mm2,mm6
 569
 570                   mov        ecx,len           //load length of line
 571                   mov        esi,srcptr        //load source
 572                   mov        ebx,dstptr        //load dest
 573                   cmp        ecx,0
 574                   jz         mainloop24end
 575
 576 mainloop24:
 577                   movq       mm4,[esi]
 578                   pand       mm4,mm0
 579                   movq       mm6,mm0
 580                   movq       mm7,[ebx]
 581                   pandn      mm6,mm7
 582                   por        mm4,mm6
 583                   movq       [ebx],mm4
 584
 585
 586                   movq       mm5,[esi+8]
 587                   pand       mm5,mm1
 588                   movq       mm7,mm1
 589                   movq       mm6,[ebx+8]
 590                   pandn      mm7,mm6
 591                   por        mm5,mm7
 592                   movq       [ebx+8],mm5
 593
 594                   movq       mm6,[esi+16]
 595                   pand       mm6,mm2
 596                   movq       mm4,mm2
 597                   movq       mm7,[ebx+16]
 598                   pandn      mm4,mm7
 599                   por        mm6,mm4
 600                   movq       [ebx+16],mm6
 601
 602                   add        esi,24            //inc by 24 bytes processed
 603                   add        ebx,24
 604                   sub        ecx,8             //dec by 8 pixels processed
 605
 606                   ja         mainloop24
 607
 608 mainloop24end:
 609                   mov        ecx,diff
 610                   cmp        ecx,0
 611                   jz         end24
 612
 613                   mov        edx,mask
 614                   sal        edx,24            //make low byte the high byte
 615 secondloop24:
 616                   sal        edx,1             //move high bit to CF
 617                   jnc        skip24            //if CF = 0
 618                   mov        ax,[esi]
 619                   mov        [ebx],ax
 620                   xor        eax,eax
 621                   mov        al,[esi+2]
 622                   mov        [ebx+2],al
 623 skip24:
 624                   add        esi,3
 625                   add        ebx,3
 626
 627                   dec        ecx
 628                   jnz        secondloop24
 629
 630 end24:
 631                   emms
 632                }
 633             }
 634             else /* mmx not supported - use modified C routine */
 635             {
 636                register unsigned int incr1, initial_val, final_val;
 637                png_size_t pixel_bytes;
 638                png_uint_32 i;
 639                register int disp = png_pass_inc[png_ptr->pass];
 640                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 641
 642                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 643                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
 644                   pixel_bytes;
 645                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
 646                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
 647                final_val = png_ptr->width*pixel_bytes;
 648                incr1 = (disp)*pixel_bytes;
 649                for (i = initial_val; i < final_val; i += incr1)
 650                {
 651                   png_memcpy(dstptr, srcptr, pixel_bytes);
 652                   srcptr += incr1;
 653                   dstptr += incr1;
 654                }
 655             } /* end of else */
 656
 657             break;
 658          }       // end 24 bpp
 659
 660          case 32:
 661          {
 662             png_bytep srcptr;
 663             png_bytep dstptr;
 664             png_uint_32 len;
 665             int unmask, diff;
 666
 667             __int64 mask3=0x0101010102020202,  //32bpp
 668                     mask2=0x0404040408080808,
 669                     mask1=0x1010101020202020,
 670                     mask0=0x4040404080808080;
 671
 672             srcptr = png_ptr->row_buf + 1;
 673             dstptr = row;
 674
 675             unmask = ~mask;
 676             len     = (png_ptr->width)&~7;
 677             diff = (png_ptr->width)&7;
 678
 679 #if !defined(PNG_1_0_X)
 680             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
 681                 /* && mmx_supported */ )
 682 #else
 683             if (mmx_supported)
 684 #endif
 685             {
 686                _asm
 687                {
 688                   movd       mm7, unmask       //load bit pattern
 689                   psubb      mm6,mm6           //zero mm6
 690                   punpcklbw  mm7,mm7
 691                   punpcklwd  mm7,mm7
 692                   punpckldq  mm7,mm7           //fill register with 8 masks
 693
 694                   movq       mm0,mask0
 695                   movq       mm1,mask1
 696                   movq       mm2,mask2
 697                   movq       mm3,mask3
 698
 699                   pand       mm0,mm7
 700                   pand       mm1,mm7
 701                   pand       mm2,mm7
 702                   pand       mm3,mm7
 703
 704                   pcmpeqb    mm0,mm6
 705                   pcmpeqb    mm1,mm6
 706                   pcmpeqb    mm2,mm6
 707                   pcmpeqb    mm3,mm6
 708
 709                   mov        ecx,len           //load length of line
 710                   mov        esi,srcptr        //load source
 711                   mov        ebx,dstptr        //load dest
 712
 713                   cmp        ecx,0             //lcr
 714                   jz         mainloop32end
 715
 716 mainloop32:
 717                   movq       mm4,[esi]
 718                   pand       mm4,mm0
 719                   movq       mm6,mm0
 720                   movq       mm7,[ebx]
 721                   pandn      mm6,mm7
 722                   por        mm4,mm6
 723                   movq       [ebx],mm4
 724
 725                   movq       mm5,[esi+8]
 726                   pand       mm5,mm1
 727                   movq       mm7,mm1
 728                   movq       mm6,[ebx+8]
 729                   pandn      mm7,mm6
 730                   por        mm5,mm7
 731                   movq       [ebx+8],mm5
 732
 733                   movq       mm6,[esi+16]
 734                   pand       mm6,mm2
 735                   movq       mm4,mm2
 736                   movq       mm7,[ebx+16]
 737                   pandn      mm4,mm7
 738                   por        mm6,mm4
 739                   movq       [ebx+16],mm6
 740
 741                   movq       mm7,[esi+24]
 742                   pand       mm7,mm3
 743                   movq       mm5,mm3
 744                   movq       mm4,[ebx+24]
 745                   pandn      mm5,mm4
 746                   por        mm7,mm5
 747                   movq       [ebx+24],mm7
 748
 749                   add        esi,32            //inc by 32 bytes processed
 750                   add        ebx,32
 751                   sub        ecx,8             //dec by 8 pixels processed
 752
 753                   ja         mainloop32
 754
 755 mainloop32end:
 756                   mov        ecx,diff
 757                   cmp        ecx,0
 758                   jz         end32
 759
 760                   mov        edx,mask
 761                   sal        edx,24            //make low byte the high byte
 762 secondloop32:
 763                   sal        edx,1             //move high bit to CF
 764                   jnc        skip32            //if CF = 0
 765                   mov        eax,[esi]
 766                   mov        [ebx],eax
 767 skip32:
 768                   add        esi,4
 769                   add        ebx,4
 770
 771                   dec        ecx
 772                   jnz        secondloop32
 773
 774 end32:
 775                   emms
 776                }
 777             }
 778             else /* mmx _not supported - Use modified C routine */
 779             {
 780                register unsigned int incr1, initial_val, final_val;
 781                png_size_t pixel_bytes;
 782                png_uint_32 i;
 783                register int disp = png_pass_inc[png_ptr->pass];
 784                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 785
 786                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 787                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
 788                   pixel_bytes;
 789                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
 790                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
 791                final_val = png_ptr->width*pixel_bytes;
 792                incr1 = (disp)*pixel_bytes;
 793                for (i = initial_val; i < final_val; i += incr1)
 794                {
 795                   png_memcpy(dstptr, srcptr, pixel_bytes);
 796                   srcptr += incr1;
 797                   dstptr += incr1;
 798                }
 799             } /* end of else */
 800
 801             break;
 802          }       // end 32 bpp
 803
 804          case 48:
 805          {
 806             png_bytep srcptr;
 807             png_bytep dstptr;
 808             png_uint_32 len;
 809             int unmask, diff;
 810
 811             __int64 mask5=0x0101010101010202,
 812                     mask4=0x0202020204040404,
 813                     mask3=0x0404080808080808,
 814                     mask2=0x1010101010102020,
 815                     mask1=0x2020202040404040,
 816                     mask0=0x4040808080808080;
 817
 818 #if !defined(PNG_1_0_X)
 819             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)
 820                 /* && mmx_supported */ )
 821 #else
 822             if (mmx_supported)
 823 #endif
 824             {
 825                srcptr = png_ptr->row_buf + 1;
 826                dstptr = row;
 827
 828                unmask = ~mask;
 829                len     = (png_ptr->width)&~7;
 830                diff = (png_ptr->width)&7;
 831                _asm
 832                {
 833                   movd       mm7, unmask       //load bit pattern
 834                   psubb      mm6,mm6           //zero mm6
 835                   punpcklbw  mm7,mm7
 836                   punpcklwd  mm7,mm7
 837                   punpckldq  mm7,mm7           //fill register with 8 masks
 838
 839                   movq       mm0,mask0
 840                   movq       mm1,mask1
 841                   movq       mm2,mask2
 842                   movq       mm3,mask3
 843                   movq       mm4,mask4
 844                   movq       mm5,mask5
 845
 846                   pand       mm0,mm7
 847                   pand       mm1,mm7
 848                   pand       mm2,mm7
 849                   pand       mm3,mm7
 850                   pand       mm4,mm7
 851                   pand       mm5,mm7
 852
 853                   pcmpeqb    mm0,mm6
 854                   pcmpeqb    mm1,mm6
 855                   pcmpeqb    mm2,mm6
 856                   pcmpeqb    mm3,mm6
 857                   pcmpeqb    mm4,mm6
 858                   pcmpeqb    mm5,mm6
 859
 860                   mov        ecx,len           //load length of line
 861                   mov        esi,srcptr        //load source
 862                   mov        ebx,dstptr        //load dest
 863
 864                   cmp        ecx,0
 865                   jz         mainloop48end
 866
 867 mainloop48:
 868                   movq       mm7,[esi]
 869                   pand       mm7,mm0
 870                   movq       mm6,mm0
 871                   pandn      mm6,[ebx]
 872                   por        mm7,mm6
 873                   movq       [ebx],mm7
 874
 875                   movq       mm6,[esi+8]
 876                   pand       mm6,mm1
 877                   movq       mm7,mm1
 878                   pandn      mm7,[ebx+8]
 879                   por        mm6,mm7
 880                   movq       [ebx+8],mm6
 881
 882                   movq       mm6,[esi+16]
 883                   pand       mm6,mm2
 884                   movq       mm7,mm2
 885                   pandn      mm7,[ebx+16]
 886                   por        mm6,mm7
 887                   movq       [ebx+16],mm6
 888
 889                   movq       mm7,[esi+24]
 890                   pand       mm7,mm3
 891                   movq       mm6,mm3
 892                   pandn      mm6,[ebx+24]
 893                   por        mm7,mm6
 894                   movq       [ebx+24],mm7
 895
 896                   movq       mm6,[esi+32]
 897                   pand       mm6,mm4
 898                   movq       mm7,mm4
 899                   pandn      mm7,[ebx+32]
 900                   por        mm6,mm7
 901                   movq       [ebx+32],mm6
 902
 903                   movq       mm7,[esi+40]
 904                   pand       mm7,mm5
 905                   movq       mm6,mm5
 906                   pandn      mm6,[ebx+40]
 907                   por        mm7,mm6
 908                   movq       [ebx+40],mm7
 909
 910                   add        esi,48            //inc by 32 bytes processed
 911                   add        ebx,48
 912                   sub        ecx,8             //dec by 8 pixels processed
 913
 914                   ja         mainloop48
 915 mainloop48end:
 916
 917                   mov        ecx,diff
 918                   cmp        ecx,0
 919                   jz         end48
 920
 921                   mov        edx,mask
 922                   sal        edx,24            //make low byte the high byte
 923
 924 secondloop48:
 925                   sal        edx,1             //move high bit to CF
 926                   jnc        skip48            //if CF = 0
 927                   mov        eax,[esi]
 928                   mov        [ebx],eax
 929 skip48:
 930                   add        esi,4
 931                   add        ebx,4
 932
 933                   dec        ecx
 934                   jnz        secondloop48
 935
 936 end48:
 937                   emms
 938                }
 939             }
 940             else /* mmx _not supported - Use modified C routine */
 941             {
 942                register unsigned int incr1, initial_val, final_val;
 943                png_size_t pixel_bytes;
 944                png_uint_32 i;
 945                register int disp = png_pass_inc[png_ptr->pass];
 946                int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 947
 948                pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 949                srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
 950                   pixel_bytes;
 951                dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
 952                initial_val = offset_table[png_ptr->pass]*pixel_bytes;
 953                final_val = png_ptr->width*pixel_bytes;
 954                incr1 = (disp)*pixel_bytes;
 955                for (i = initial_val; i < final_val; i += incr1)
 956                {
 957                   png_memcpy(dstptr, srcptr, pixel_bytes);
 958                   srcptr += incr1;
 959                   dstptr += incr1;
 960                }
 961             } /* end of else */
 962
 963             break;
 964          }       // end 48 bpp
 965
 966          default:
 967          {
 968             png_bytep sptr;
 969             png_bytep dp;
 970             png_size_t pixel_bytes;
 971             int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
 972             unsigned int i;
 973             register int disp = png_pass_inc[png_ptr->pass];  // get the offset
 974             register unsigned int incr1, initial_val, final_val;
 975
 976             pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
 977             sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
 978                pixel_bytes;
 979             dp = row + offset_table[png_ptr->pass]*pixel_bytes;
 980             initial_val = offset_table[png_ptr->pass]*pixel_bytes;
 981             final_val = png_ptr->width*pixel_bytes;
 982             incr1 = (disp)*pixel_bytes;
 983             for (i = initial_val; i < final_val; i += incr1)
 984             {
 985                png_memcpy(dp, sptr, pixel_bytes);
 986                sptr += incr1;
 987                dp += incr1;
 988             }
 989             break;
 990          }
 991       } /* end switch (png_ptr->row_info.pixel_depth) */
 992    } /* end if (non-trivial mask) */
 993
 994 } /* end png_combine_row() */
 995
 996
 997 #if defined(PNG_READ_INTERLACING_SUPPORTED)
 998
 999 void /* PRIVATE */
1000 png_do_read_interlace(png_structp png_ptr)
1001 {
1002    png_row_infop row_info = &(png_ptr->row_info);
1003    png_bytep row = png_ptr->row_buf + 1;
1004    int pass = png_ptr->pass;
1005    png_uint_32 transformations = png_ptr->transformations;
1006 #ifdef PNG_USE_LOCAL_ARRAYS
1007    const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
1008 #endif
1009
1010    png_debug(1,"in png_do_read_interlace\n");
1011
1012    if (mmx_supported == 2) {
1013 #if !defined(PNG_1_0_X)
1014        /* this should have happened in png_init_mmx_flags() already */
1015        png_warning(png_ptr, "asm_flags may not have been initialized");
1016 #endif
1017        png_mmx_support();
1018    }
1019
1020    if (row != NULL && row_info != NULL)
1021    {
1022       png_uint_32 final_width;
1023
1024       final_width = row_info->width * png_pass_inc[pass];
1025
1026       switch (row_info->pixel_depth)
1027       {
1028          case 1:
1029          {
1030             png_bytep sp, dp;
1031             int sshift, dshift;
1032             int s_start, s_end, s_inc;
1033             png_byte v;
1034             png_uint_32 i;
1035             int j;
1036
1037             sp = row + (png_size_t)((row_info->width - 1) >> 3);
1038             dp = row + (png_size_t)((final_width - 1) >> 3);
1039 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
1040             if (transformations & PNG_PACKSWAP)
1041             {
1042                sshift = (int)((row_info->width + 7) & 7);
1043                dshift = (int)((final_width + 7) & 7);
1044                s_start = 7;
1045                s_end = 0;
1046                s_inc = -1;
1047             }
1048             else
1049 #endif
1050             {
1051                sshift = 7 - (int)((row_info->width + 7) & 7);
1052                dshift = 7 - (int)((final_width + 7) & 7);
1053                s_start = 0;
1054                s_end = 7;
1055                s_inc = 1;
1056             }
1057
1058             for (i = row_info->width; i; i--)
1059             {
1060                v = (png_byte)((*sp >> sshift) & 0x1);
1061                for (j = 0; j < png_pass_inc[pass]; j++)
1062                {
1063                   *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
1064                   *dp |= (png_byte)(v << dshift);
1065                   if (dshift == s_end)
1066                   {
1067                      dshift = s_start;
1068                      dp--;
1069                   }
1070                   else
1071                      dshift += s_inc;
1072                }
1073                if (sshift == s_end)
1074                {
1075                   sshift = s_start;
1076                   sp--;
1077                }
1078                else
1079                   sshift += s_inc;
1080             }
1081             break;
1082          }
1083
1084          case 2:
1085          {
1086             png_bytep sp, dp;
1087             int sshift, dshift;
1088             int s_start, s_end, s_inc;
1089             png_uint_32 i;
1090
1091             sp = row + (png_size_t)((row_info->width - 1) >> 2);
1092             dp = row + (png_size_t)((final_width - 1) >> 2);
1093 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
1094             if (transformations & PNG_PACKSWAP)
1095             {
1096                sshift = (png_size_t)(((row_info->width + 3) & 3) << 1);
1097                dshift = (png_size_t)(((final_width + 3) & 3) << 1);
1098                s_start = 6;
1099                s_end = 0;
1100                s_inc = -2;
1101             }
1102             else
1103 #endif
1104             {
1105                sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);
1106                dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);
1107                s_start = 0;
1108                s_end = 6;
1109                s_inc = 2;
1110             }
1111
1112             for (i = row_info->width; i; i--)
1113             {
1114                png_byte v;
1115                int j;
1116
1117                v = (png_byte)((*sp >> sshift) & 0x3);
1118                for (j = 0; j < png_pass_inc[pass]; j++)
1119                {
1120                   *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
1121                   *dp |= (png_byte)(v << dshift);
1122                   if (dshift == s_end)
1123                   {
1124                      dshift = s_start;
1125                      dp--;
1126                   }
1127                   else
1128                      dshift += s_inc;
1129                }
1130                if (sshift == s_end)
1131                {
1132                   sshift = s_start;
1133                   sp--;
1134                }
1135                else
1136                   sshift += s_inc;
1137             }
1138             break;
1139          }
1140
1141          case 4:
1142          {
1143             png_bytep sp, dp;
1144             int sshift, dshift;
1145             int s_start, s_end, s_inc;
1146             png_uint_32 i;
1147
1148             sp = row + (png_size_t)((row_info->width - 1) >> 1);
1149             dp = row + (png_size_t)((final_width - 1) >> 1);
1150 #if defined(PNG_READ_PACKSWAP_SUPPORTED)
1151             if (transformations & PNG_PACKSWAP)
1152             {
1153                sshift = (png_size_t)(((row_info->width + 1) & 1) << 2);
1154                dshift = (png_size_t)(((final_width + 1) & 1) << 2);
1155                s_start = 4;
1156                s_end = 0;
1157                s_inc = -4;
1158             }
1159             else
1160 #endif
1161             {
1162                sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);
1163                dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);
1164                s_start = 0;
1165                s_end = 4;
1166                s_inc = 4;
1167             }
1168
1169             for (i = row_info->width; i; i--)
1170             {
1171                png_byte v;
1172                int j;
1173
1174                v = (png_byte)((*sp >> sshift) & 0xf);
1175                for (j = 0; j < png_pass_inc[pass]; j++)
1176                {
1177                   *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
1178                   *dp |= (png_byte)(v << dshift);
1179                   if (dshift == s_end)
1180                   {
1181                      dshift = s_start;
1182                      dp--;
1183                   }
1184                   else
1185                      dshift += s_inc;
1186                }
1187                if (sshift == s_end)
1188                {
1189                   sshift = s_start;
1190                   sp--;
1191                }
1192                else
1193                   sshift += s_inc;
1194             }
1195             break;
1196          }
1197
1198          default:         // This is the place where the routine is modified
1199          {
1200             __int64 const4 = 0x0000000000FFFFFF;
1201             // __int64 const5 = 0x000000FFFFFF0000;  // unused...
1202             __int64 const6 = 0x00000000000000FF;
1203             png_bytep sptr, dp;
1204             png_uint_32 i;
1205             png_size_t pixel_bytes;
1206             int width = row_info->width;
1207
1208             pixel_bytes = (row_info->pixel_depth >> 3);
1209
1210             sptr = row + (width - 1) * pixel_bytes;
1211             dp = row + (final_width - 1) * pixel_bytes;
1212             // New code by Nirav Chhatrapati - Intel Corporation
1213             // sign fix by GRR
1214             // NOTE:  there is NO MMX code for 48-bit and 64-bit images
1215
1216             // use MMX routine if machine supports it
1217 #if !defined(PNG_1_0_X)
1218             if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)
1219                 /* && mmx_supported */ )
1220 #else
1221             if (mmx_supported)
1222 #endif
1223             {
1224                if (pixel_bytes == 3)
1225                {
1226                   if (((pass == 0) || (pass == 1)) && width)
1227                   {
1228                      _asm
1229                      {
1230                         mov esi, sptr
1231                         mov edi, dp
1232                         mov ecx, width
1233                         sub edi, 21   // (png_pass_inc[pass] - 1)*pixel_bytes
1234 loop_pass0:
1235                         movd mm0, [esi]     ; X X X X X v2 v1 v0
1236                         pand mm0, const4    ; 0 0 0 0 0 v2 v1 v0
1237                         movq mm1, mm0       ; 0 0 0 0 0 v2 v1 v0
1238                         psllq mm0, 16       ; 0 0 0 v2 v1 v0 0 0
1239                         movq mm2, mm0       ; 0 0 0 v2 v1 v0 0 0
1240                         psllq mm0, 24       ; v2 v1 v0 0 0 0 0 0
1241                         psrlq mm1, 8        ; 0 0 0 0 0 0 v2 v1
1242                         por mm0, mm2        ; v2 v1 v0 v2 v1 v0 0 0
1243                         por mm0, mm1        ; v2 v1 v0 v2 v1 v0 v2 v1
1244                         movq mm3, mm0       ; v2 v1 v0 v2 v1 v0 v2 v1
1245                         psllq mm0, 16       ; v0 v2 v1 v0 v2 v1 0 0
1246                         movq mm4, mm3       ; v2 v1 v0 v2 v1 v0 v2 v1
1247                         punpckhdq mm3, mm0  ; v0 v2 v1 v0 v2 v1 v0 v2
1248                         movq [edi+16] , mm4
1249                         psrlq mm0, 32       ; 0 0 0 0 v0 v2 v1 v0
1250                         movq [edi+8] , mm3
1251                         punpckldq mm0, mm4  ; v1 v0 v2 v1 v0 v2 v1 v0
1252                         sub esi, 3
1253                         movq [edi], mm0
1254                         sub edi, 24
1255                         //sub esi, 3
1256                         dec ecx
1257                         jnz loop_pass0
1258                         EMMS
1259                      }
1260                   }
1261                   else if (((pass == 2) || (pass == 3)) && width)
1262                   {
1263                      _asm
1264                      {
1265                         mov esi, sptr
1266                         mov edi, dp
1267                         mov ecx, width
1268                         sub edi, 9   // (png_pass_inc[pass] - 1)*pixel_bytes
1269 loop_pass2:
1270                         movd mm0, [esi]     ; X X X X X v2 v1 v0
1271                         pand mm0, const4    ; 0 0 0 0 0 v2 v1 v0
1272                         movq mm1, mm0       ; 0 0 0 0 0 v2 v1 v0
1273                         psllq mm0, 16       ; 0 0 0 v2 v1 v0 0 0
1274                         movq mm2, mm0       ; 0 0 0 v2 v1 v0 0 0
1275                         psllq mm0, 24       ; v2 v1 v0 0 0 0 0 0
1276                         psrlq mm1, 8        ; 0 0 0 0 0 0 v2 v1
1277                         por mm0, mm2        ; v2 v1 v0 v2 v1 v0 0 0
1278                         por mm0, mm1        ; v2 v1 v0 v2 v1 v0 v2 v1
1279                         movq [edi+4], mm0   ; move to memory
1280                         psrlq mm0, 16       ; 0 0 v2 v1 v0 v2 v1 v0
1281                         movd [edi], mm0     ; move to memory
1282                         sub esi, 3
1283                         sub edi, 12
1284                         dec ecx
1285                         jnz loop_pass2
1286                         EMMS
1287                      }
1288                   }
1289                   else if (width) /* && ((pass == 4) || (pass == 5)) */
1290                   {
1291                      int width_mmx = ((width >> 1) << 1) - 8;
1292                      if (width_mmx < 0)
1293                          width_mmx = 0;
1294                      width -= width_mmx;        // 8 or 9 pix, 24 or 27 bytes
1295                      if (width_mmx)
1296                      {
1297                         _asm
1298                         {
1299                            mov esi, sptr
1300                            mov edi, dp
1301                            mov ecx, width_mmx
1302                            sub esi, 3
1303                            sub edi, 9
1304 loop_pass4:
1305                            movq mm0, [esi]     ; X X v2 v1 v0 v5 v4 v3
1306                            movq mm7, mm0       ; X X v2 v1 v0 v5 v4 v3
1307                            movq mm6, mm0       ; X X v2 v1 v0 v5 v4 v3
1308                            psllq mm0, 24       ; v1 v0 v5 v4 v3 0 0 0
1309                            pand mm7, const4    ; 0 0 0 0 0 v5 v4 v3
1310                            psrlq mm6, 24       ; 0 0 0 X X v2 v1 v0
1311                            por mm0, mm7        ; v1 v0 v5 v4 v3 v5 v4 v3
1312                            movq mm5, mm6       ; 0 0 0 X X v2 v1 v0
1313                            psllq mm6, 8        ; 0 0 X X v2 v1 v0 0
1314                            movq [edi], mm0     ; move quad to memory
1315                            psrlq mm5, 16       ; 0 0 0 0 0 X X v2
1316                            pand mm5, const6    ; 0 0 0 0 0 0 0 v2
1317                            por mm6, mm5        ; 0 0 X X v2 v1 v0 v2
1318                            movd [edi+8], mm6   ; move double to memory
1319                            sub esi, 6
1320                            sub edi, 12
1321                            sub ecx, 2
1322                            jnz loop_pass4
1323                            EMMS
1324                         }
1325                      }
1326
1327                      sptr -= width_mmx*3;
1328                      dp -= width_mmx*6;
1329                      for (i = width; i; i--)
1330                      {
1331                         png_byte v[8];
1332                         int j;
1333
1334                         png_memcpy(v, sptr, 3);
1335                         for (j = 0; j < png_pass_inc[pass]; j++)
1336                         {
1337                            png_memcpy(dp, v, 3);
1338                            dp -= 3;
1339                         }
1340                         sptr -= 3;
1341                      }
1342                   }
1343                } /* end of pixel_bytes == 3 */
1344
1345                else if (pixel_bytes == 1)
1346                {
1347                   if (((pass == 0) || (pass == 1)) && width)
1348                   {
1349                      int width_mmx = ((width >> 2) << 2);
1350                      width -= width_mmx;
1351                      if (width_mmx)
1352                      {
1353                         _asm
1354                         {
1355                            mov esi, sptr
1356                            mov edi, dp
1357                            mov ecx, width_mmx
1358                            sub edi, 31
1359                            sub esi, 3
1360 loop1_pass0:
1361                            movd mm0, [esi]     ; X X X X v0 v1 v2 v3
1362                            movq mm1, mm0       ; X X X X v0 v1 v2 v3
1363                            punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3
1364                            movq mm2, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3
1365                            punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3
1366                            movq mm3, mm0       ; v2 v2 v2 v2 v3 v3 v3 v3
1367                            punpckldq mm0, mm0  ; v3 v3 v3 v3 v3 v3 v3 v3
1368                            punpckhdq mm3, mm3  ; v2 v2 v2 v2 v2 v2 v2 v2
1369                            movq [edi], mm0     ; move to memory v3
1370                            punpckhwd mm2, mm2  ; v0 v0 v0 v0 v1 v1 v1 v1
1371                            movq [edi+8], mm3   ; move to memory v2
1372                            movq mm4, mm2       ; v0 v0 v0 v0 v1 v1 v1 v1
1373                            punpckldq mm2, mm2  ; v1 v1 v1 v1 v1 v1 v1 v1
1374                            punpckhdq mm4, mm4  ; v0 v0 v0 v0 v0 v0 v0 v0
1375                            movq [edi+16], mm2  ; move to memory v1
1376                            movq [edi+24], mm4  ; move to memory v0
1377                            sub esi, 4
1378                            sub edi, 32
1379                            sub ecx, 4
1380                            jnz loop1_pass0
1381                            EMMS
1382                         }
1383                      }
1384
1385                      sptr -= width_mmx;
1386                      dp -= width_mmx*8;
1387                      for (i = width; i; i--)
1388                      {
1389                         int j;
1390
1391                        /* I simplified this part in version 1.0.4e
1392                         * here and in several other instances where
1393                         * pixel_bytes == 1  -- GR-P
1394                         *
1395                         * Original code:
1396                         *
1397                         * png_byte v[8];
1398                         * png_memcpy(v, sptr, pixel_bytes);
1399                         * for (j = 0; j < png_pass_inc[pass]; j++)
1400                         * {
1401                         *    png_memcpy(dp, v, pixel_bytes);
1402                         *    dp -= pixel_bytes;
1403                         * }
1404                         * sptr -= pixel_bytes;
1405                         *
1406                         * Replacement code is in the next three lines:
1407                         */
1408
1409                         for (j = 0; j < png_pass_inc[pass]; j++)
1410                            *dp-- = *sptr;
1411                         sptr--;
1412                      }
1413                   }
1414                   else if (((pass == 2) || (pass == 3)) && width)
1415                   {
1416                      int width_mmx = ((width >> 2) << 2);
1417                      width -= width_mmx;
1418                      if (width_mmx)
1419                      {
1420                         _asm
1421                         {
1422                            mov esi, sptr
1423                            mov edi, dp
1424                            mov ecx, width_mmx
1425                            sub edi, 15
1426                            sub esi, 3
1427 loop1_pass2:
1428                            movd mm0, [esi]     ; X X X X v0 v1 v2 v3
1429                            punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3
1430                            movq mm1, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3
1431                            punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3
1432                            punpckhwd mm1, mm1  ; v0 v0 v0 v0 v1 v1 v1 v1
1433                            movq [edi], mm0     ; move to memory v2 and v3
1434                            sub esi, 4
1435                            movq [edi+8], mm1   ; move to memory v1     and v0
1436                            sub edi, 16
1437                            sub ecx, 4
1438                            jnz loop1_pass2
1439                            EMMS
1440                         }
1441                      }
1442
1443                      sptr -= width_mmx;
1444                      dp -= width_mmx*4;
1445                      for (i = width; i; i--)
1446                      {
1447                         int j;
1448
1449                         for (j = 0; j < png_pass_inc[pass]; j++)
1450                         {
1451                            *dp-- = *sptr;
1452                         }
1453                         sptr --;
1454                      }
1455                   }
1456                   else if (width) /* && ((pass == 4) || (pass == 5))) */
1457                   {
1458                      int width_mmx = ((width >> 3) << 3);
1459                      width -= width_mmx;
1460                      if (width_mmx)
1461                      {
1462                         _asm
1463                         {
1464                            mov esi, sptr
1465                            mov edi, dp
1466                            mov ecx, width_mmx
1467                            sub edi, 15
1468                            sub esi, 7
1469 loop1_pass4:
1470                            movq mm0, [esi]     ; v0 v1 v2 v3 v4 v5 v6 v7
1471                            movq mm1, mm0       ; v0 v1 v2 v3 v4 v5 v6 v7
1472                            punpcklbw mm0, mm0  ; v4 v4 v5 v5 v6 v6 v7 v7
1473                            //movq mm1, mm0     ; v0 v0 v1 v1 v2 v2 v3 v3
1474                            punpckhbw mm1, mm1  ;v0 v0 v1 v1 v2 v2 v3 v3
1475                            movq [edi+8], mm1   ; move to memory v0 v1 v2 and v3
1476                            sub esi, 8
1477                            movq [edi], mm0     ; move to memory v4 v5 v6 and v7
1478                            //sub esi, 4
1479                            sub edi, 16
1480                            sub ecx, 8
1481                            jnz loop1_pass4
1482                            EMMS
1483                         }
1484                      }
1485
1486                      sptr -= width_mmx;
1487                      dp -= width_mmx*2;
1488                      for (i = width; i; i--)
1489                      {
1490                         int j;
1491
1492                         for (j = 0; j < png_pass_inc[pass]; j++)
1493                         {
1494                            *dp-- = *sptr;
1495                         }
1496                         sptr --;
1497                      }
1498                   }
1499                } /* end of pixel_bytes == 1 */
1500
1501                else if (pixel_bytes == 2)
1502                {
1503                   if (((pass == 0) || (pass == 1)) && width)
1504                   {
1505                      int width_mmx = ((width >> 1) << 1);
1506                      width -= width_mmx;
1507                      if (width_mmx)
1508                      {
1509                         _asm
1510                         {
1511                            mov esi, sptr
1512                            mov edi, dp
1513                            mov ecx, width_mmx
1514                            sub esi, 2
1515                            sub edi, 30
1516 loop2_pass0:
1517                            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
1518                            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
1519                            movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2
1520                            punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2
1521                            punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0
1522                            movq [edi], mm0
1523                            movq [edi + 8], mm0
1524                            movq [edi + 16], mm1
1525                            movq [edi + 24], mm1
1526                            sub esi, 4
1527                            sub edi, 32
1528                            sub ecx, 2
1529                            jnz loop2_pass0
1530                            EMMS
1531                         }
1532                      }
1533
1534                      sptr -= (width_mmx*2 - 2);            // sign fixed
1535                      dp -= (width_mmx*16 - 2);            // sign fixed
1536                      for (i = width; i; i--)
1537                      {
1538                         png_byte v[8];
1539                         int j;
1540                         sptr -= 2;
1541                         png_memcpy(v, sptr, 2);
1542                         for (j = 0; j < png_pass_inc[pass]; j++)
1543                         {
1544                            dp -= 2;
1545                            png_memcpy(dp, v, 2);
1546                         }
1547                      }
1548                   }
1549                   else if (((pass == 2) || (pass == 3)) && width)
1550                   {
1551                      int width_mmx = ((width >> 1) << 1) ;
1552                      width -= width_mmx;
1553                      if (width_mmx)
1554                      {
1555                         _asm
1556                         {
1557                            mov esi, sptr
1558                            mov edi, dp
1559                            mov ecx, width_mmx
1560                            sub esi, 2
1561                            sub edi, 14
1562 loop2_pass2:
1563                            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
1564                            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
1565                            movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2
1566                            punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2
1567                            punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0
1568                            movq [edi], mm0
1569                            sub esi, 4
1570                            movq [edi + 8], mm1
1571                            //sub esi, 4
1572                            sub edi, 16
1573                            sub ecx, 2
1574                            jnz loop2_pass2
1575                            EMMS
1576                         }
1577                      }
1578
1579                      sptr -= (width_mmx*2 - 2);            // sign fixed
1580                      dp -= (width_mmx*8 - 2);            // sign fixed
1581                      for (i = width; i; i--)
1582                      {
1583                         png_byte v[8];
1584                         int j;
1585                         sptr -= 2;
1586                         png_memcpy(v, sptr, 2);
1587                         for (j = 0; j < png_pass_inc[pass]; j++)
1588                         {
1589                            dp -= 2;
1590                            png_memcpy(dp, v, 2);
1591                         }
1592                      }
1593                   }
1594                   else if (width)  // pass == 4 or 5
1595                   {
1596                      int width_mmx = ((width >> 1) << 1) ;
1597                      width -= width_mmx;
1598                      if (width_mmx)
1599                      {
1600                         _asm
1601                         {
1602                            mov esi, sptr
1603                            mov edi, dp
1604                            mov ecx, width_mmx
1605                            sub esi, 2
1606                            sub edi, 6
1607 loop2_pass4:
1608                            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
1609                            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
1610                            sub esi, 4
1611                            movq [edi], mm0
1612                            sub edi, 8
1613                            sub ecx, 2
1614                            jnz loop2_pass4
1615                            EMMS
1616                         }
1617                      }
1618
1619                      sptr -= (width_mmx*2 - 2);            // sign fixed
1620                      dp -= (width_mmx*4 - 2);            // sign fixed
1621                      for (i = width; i; i--)
1622                      {
1623                         png_byte v[8];
1624                         int j;
1625                         sptr -= 2;
1626                         png_memcpy(v, sptr, 2);
1627                         for (j = 0; j < png_pass_inc[pass]; j++)
1628                         {
1629                            dp -= 2;
1630                            png_memcpy(dp, v, 2);
1631                         }
1632                      }
1633                   }
1634                } /* end of pixel_bytes == 2 */
1635
1636                else if (pixel_bytes == 4)
1637                {
1638                   if (((pass == 0) || (pass == 1)) && width)
1639                   {
1640                      int width_mmx = ((width >> 1) << 1) ;
1641                      width -= width_mmx;
1642                      if (width_mmx)
1643                      {
1644                         _asm
1645                         {
1646                            mov esi, sptr
1647                            mov edi, dp
1648                            mov ecx, width_mmx
1649                            sub esi, 4
1650                            sub edi, 60
1651 loop4_pass0:
1652                            movq mm0, [esi]        ; v3 v2 v1 v0 v7 v6 v5 v4
1653                            movq mm1, mm0          ; v3 v2 v1 v0 v7 v6 v5 v4
1654                            punpckldq mm0, mm0     ; v7 v6 v5 v4 v7 v6 v5 v4
1655                            punpckhdq mm1, mm1     ; v3 v2 v1 v0 v3 v2 v1 v0
1656                            movq [edi], mm0
1657                            movq [edi + 8], mm0
1658                            movq [edi + 16], mm0
1659                            movq [edi + 24], mm0
1660                            movq [edi+32], mm1
1661                            movq [edi + 40], mm1
1662                            movq [edi+ 48], mm1
1663                            sub esi, 8
1664                            movq [edi + 56], mm1
1665                            sub edi, 64
1666                            sub ecx, 2
1667                            jnz loop4_pass0
1668                            EMMS
1669                         }
1670                      }
1671
1672                      sptr -= (width_mmx*4 - 4);            // sign fixed
1673                      dp -= (width_mmx*32 - 4);            // sign fixed
1674                      for (i = width; i; i--)
1675                      {
1676                         png_byte v[8];
1677                         int j;
1678                         sptr -= 4;
1679                         png_memcpy(v, sptr, 4);
1680                         for (j = 0; j < png_pass_inc[pass]; j++)
1681                         {
1682                            dp -= 4;
1683                            png_memcpy(dp, v, 4);
1684                         }
1685                      }
1686                   }
1687                   else if (((pass == 2) || (pass == 3)) && width)
1688                   {
1689                      int width_mmx = ((width >> 1) << 1) ;
1690                      width -= width_mmx;
1691                      if (width_mmx)
1692                      {
1693                         _asm
1694                         {
1695                            mov esi, sptr
1696                            mov edi, dp
1697                            mov ecx, width_mmx
1698                            sub esi, 4
1699                            sub edi, 28
1700 loop4_pass2:
1701                            movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4
1702                            movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4
1703                            punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4
1704                            punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0
1705                            movq [edi], mm0
1706                            movq [edi + 8], mm0
1707                            movq [edi+16], mm1
1708                            movq [edi + 24], mm1
1709                            sub esi, 8
1710                            sub edi, 32
1711                            sub ecx, 2
1712                            jnz loop4_pass2
1713                            EMMS
1714                         }
1715                      }
1716
1717                      sptr -= (width_mmx*4 - 4);            // sign fixed
1718                      dp -= (width_mmx*16 - 4);            // sign fixed
1719                      for (i = width; i; i--)
1720                      {
1721                         png_byte v[8];
1722                         int j;
1723                         sptr -= 4;
1724                         png_memcpy(v, sptr, 4);
1725                         for (j = 0; j < png_pass_inc[pass]; j++)
1726                         {
1727                            dp -= 4;
1728                            png_memcpy(dp, v, 4);
1729                         }
1730                      }
1731                   }
1732                   else if (width)  // pass == 4 or 5
1733                   {
1734                      int width_mmx = ((width >> 1) << 1) ;
1735                      width -= width_mmx;
1736                      if (width_mmx)
1737                      {
1738                         _asm
1739                         {
1740                            mov esi, sptr
1741                            mov edi, dp
1742                            mov ecx, width_mmx
1743                            sub esi, 4
1744                            sub edi, 12
1745 loop4_pass4:
1746                            movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4
1747                            movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4
1748                            punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4
1749                            punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0
1750                            movq [edi], mm0
1751                            sub esi, 8
1752                            movq [edi + 8], mm1
1753                            sub edi, 16
1754                            sub ecx, 2
1755                            jnz loop4_pass4
1756                            EMMS
1757                         }
1758                      }
1759
1760                      sptr -= (width_mmx*4 - 4);          // sign fixed
1761                      dp -= (width_mmx*8 - 4);            // sign fixed
1762                      for (i = width; i; i--)
1763                      {
1764                         png_byte v[8];
1765                         int j;
1766                         sptr -= 4;
1767                         png_memcpy(v, sptr, 4);
1768                         for (j = 0; j < png_pass_inc[pass]; j++)
1769                         {
1770                            dp -= 4;
1771                            png_memcpy(dp, v, 4);
1772                         }
1773                      }
1774                   }
1775
1776                } /* end of pixel_bytes == 4 */
1777
1778                else if (pixel_bytes == 6)
1779                {
1780                   for (i = width; i; i--)
1781                   {
1782                      png_byte v[8];
1783                      int j;
1784                      png_memcpy(v, sptr, 6);
1785                      for (j = 0; j < png_pass_inc[pass]; j++)
1786                      {
1787                         png_memcpy(dp, v, 6);
1788                         dp -= 6;
1789                      }
1790                      sptr -= 6;
1791                   }
1792                } /* end of pixel_bytes == 6 */
1793
1794                else
1795                {
1796                   for (i = width; i; i--)
1797                   {
1798                      png_byte v[8];
1799                      int j;
1800                      png_memcpy(v, sptr, pixel_bytes);
1801                      for (j = 0; j < png_pass_inc[pass]; j++)
1802                      {
1803                         png_memcpy(dp, v, pixel_bytes);
1804                         dp -= pixel_bytes;
1805                      }
1806                      sptr-= pixel_bytes;
1807                   }
1808                }
1809             } /* end of mmx_supported */
1810
1811             else /* MMX not supported:  use modified C code - takes advantage
1812                   * of inlining of memcpy for a constant */
1813             {
1814                if (pixel_bytes == 1)
1815                {
1816                   for (i = width; i; i--)
1817                   {
1818                      int j;
1819                      for (j = 0; j < png_pass_inc[pass]; j++)
1820                         *dp-- = *sptr;
1821                      sptr--;
1822                   }
1823                }
1824                else if (pixel_bytes == 3)
1825                {
1826                   for (i = width; i; i--)
1827                   {
1828                      png_byte v[8];
1829                      int j;
1830                      png_memcpy(v, sptr, pixel_bytes);
1831                      for (j = 0; j < png_pass_inc[pass]; j++)
1832                      {
1833                         png_memcpy(dp, v, pixel_bytes);
1834                         dp -= pixel_bytes;
1835                      }
1836                      sptr -= pixel_bytes;
1837                   }
1838                }
1839                else if (pixel_bytes == 2)
1840                {
1841                   for (i = width; i; i--)
1842                   {
1843                      png_byte v[8];
1844                      int j;
1845                      png_memcpy(v, sptr, pixel_bytes);
1846                      for (j = 0; j < png_pass_inc[pass]; j++)
1847                      {
1848                         png_memcpy(dp, v, pixel_bytes);
1849                         dp -= pixel_bytes;
1850                      }
1851                      sptr -= pixel_bytes;
1852                   }
1853                }
1854                else if (pixel_bytes == 4)
1855                {
1856                   for (i = width; i; i--)
1857                   {
1858                      png_byte v[8];
1859                      int j;
1860                      png_memcpy(v, sptr, pixel_bytes);
1861                      for (j = 0; j < png_pass_inc[pass]; j++)
1862                      {
1863                         png_memcpy(dp, v, pixel_bytes);
1864                         dp -= pixel_bytes;
1865                      }
1866                      sptr -= pixel_bytes;
1867                   }
1868                }
1869                else if (pixel_bytes == 6)
1870                {
1871                   for (i = width; i; i--)
1872                   {
1873                      png_byte v[8];
1874                      int j;
1875                      png_memcpy(v, sptr, pixel_bytes);
1876                      for (j = 0; j < png_pass_inc[pass]; j++)
1877                      {
1878                         png_memcpy(dp, v, pixel_bytes);
1879                         dp -= pixel_bytes;
1880                      }
1881                      sptr -= pixel_bytes;
1882                   }
1883                }
1884                else
1885                {
1886                   for (i = width; i; i--)
1887                   {
1888                      png_byte v[8];
1889                      int j;
1890                      png_memcpy(v, sptr, pixel_bytes);
1891                      for (j = 0; j < png_pass_inc[pass]; j++)
1892                      {
1893                         png_memcpy(dp, v, pixel_bytes);
1894                         dp -= pixel_bytes;
1895                      }
1896                      sptr -= pixel_bytes;
1897                   }
1898                }
1899
1900             } /* end of MMX not supported */
1901             break;
1902          }
1903       } /* end switch (row_info->pixel_depth) */
1904
1905       row_info->width = final_width;
1906
1907       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,final_width);
1908    }
1909
1910 }
1911
1912 #endif /* PNG_READ_INTERLACING_SUPPORTED */
1913
1914
1915 // These variables are utilized in the functions below.  They are declared
1916 // globally here to ensure alignment on 8-byte boundaries.
1917
1918 union uAll {
1919    __int64 use;
1920    double  align;
1921 } LBCarryMask = {0x0101010101010101},
1922   HBClearMask = {0x7f7f7f7f7f7f7f7f},
1923   ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem;
1924
1925
1926 // Optimized code for PNG Average filter decoder
1927 void /* PRIVATE */
1928 png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row
1929                             , png_bytep prev_row)
1930 {
1931    int bpp;
1932    png_uint_32 FullLength;
1933    png_uint_32 MMXLength;
1934    //png_uint_32 len;
1935    int diff;
1936
1937    bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
1938    FullLength  = row_info->rowbytes; // # of bytes to filter
1939    _asm {
1940          // Init address pointers and offset
1941          mov edi, row          // edi ==> Avg(x)
1942          xor ebx, ebx          // ebx ==> x
1943          mov edx, edi
1944          mov esi, prev_row           // esi ==> Prior(x)
1945          sub edx, bpp          // edx ==> Raw(x-bpp)
1946
1947          xor eax, eax
1948          // Compute the Raw value for the first bpp bytes
1949          //    Raw(x) = Avg(x) + (Prior(x)/2)
1950 davgrlp:
1951          mov al, [esi + ebx]   // Load al with Prior(x)
1952          inc ebx
1953          shr al, 1             // divide by 2
1954          add al, [edi+ebx-1]   // Add Avg(x); -1 to offset inc ebx
1955          cmp ebx, bpp
1956          mov [edi+ebx-1], al    // Write back Raw(x);
1957                             // mov does not affect flags; -1 to offset inc ebx
1958          jb davgrlp
1959          // get # of bytes to alignment
1960          mov diff, edi         // take start of row
1961          add diff, ebx         // add bpp
1962          add diff, 0xf         // add 7 + 8 to incr past alignment boundary
1963          and diff, 0xfffffff8  // mask to alignment boundary
1964          sub diff, edi         // subtract from start ==> value ebx at alignment
1965          jz davggo
1966          // fix alignment
1967          // Compute the Raw value for the bytes upto the alignment boundary
1968          //    Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
1969          xor ecx, ecx
1970 davglp1:
1971          xor eax, eax
1972          mov cl, [esi + ebx]        // load cl with Prior(x)
1973          mov al, [edx + ebx]  // load al with Raw(x-bpp)
1974          add ax, cx
1975          inc ebx
1976          shr ax, 1            // divide by 2
1977          add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx
1978          cmp ebx, diff              // Check if at alignment boundary
1979          mov [edi+ebx-1], al        // Write back Raw(x);
1980                             // mov does not affect flags; -1 to offset inc ebx
1981          jb davglp1               // Repeat until at alignment boundary
1982 davggo:
1983          mov eax, FullLength
1984          mov ecx, eax
1985          sub eax, ebx          // subtract alignment fix
1986          and eax, 0x00000007   // calc bytes over mult of 8
1987          sub ecx, eax          // drop over bytes from original length
1988          mov MMXLength, ecx
1989    } // end _asm block
1990    // Now do the math for the rest of the row
1991    switch ( bpp )
1992    {
1993       case 3:
1994       {
1995          ActiveMask.use  = 0x0000000000ffffff;
1996          ShiftBpp.use = 24;    // == 3 * 8
1997          ShiftRem.use = 40;    // == 64 - 24
1998          _asm {
1999             // Re-init address pointers and offset
2000             movq mm7, ActiveMask
2001             mov ebx, diff      // ebx ==> x = offset to alignment boundary
2002             movq mm5, LBCarryMask
2003             mov edi, row       // edi ==> Avg(x)
2004             movq mm4, HBClearMask
2005             mov esi, prev_row        // esi ==> Prior(x)
2006             // PRIME the pump (load the first Raw(x-bpp) data set
2007             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
2008                                // (we correct position in loop below)
2009 davg3lp:
2010             movq mm0, [edi + ebx]      // Load mm0 with Avg(x)
2011             // Add (Prev_row/2) to Average
2012             movq mm3, mm5
2013             psrlq mm2, ShiftRem      // Correct position Raw(x-bpp) data
2014             movq mm1, [esi + ebx]    // Load mm1 with Prior(x)
2015             movq mm6, mm7
2016             pand mm3, mm1      // get lsb for each prev_row byte
2017             psrlq mm1, 1       // divide prev_row bytes by 2
2018             pand  mm1, mm4     // clear invalid bit 7 of each byte
2019             paddb mm0, mm1     // add (Prev_row/2) to Avg for each byte
2020             // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
2021             movq mm1, mm3      // now use mm1 for getting LBCarrys
2022             pand mm1, mm2      // get LBCarrys for each byte where both
2023                                // lsb's were == 1 (Only valid for active group)
2024             psrlq mm2, 1       // divide raw bytes by 2
2025             pand  mm2, mm4     // clear invalid bit 7 of each byte
2026             paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte
2027             pand mm2, mm6      // Leave only Active Group 1 bytes to add to Avg
2028             paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active
2029                                //  byte
2030             // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
2031             psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 3-5
2032             movq mm2, mm0        // mov updated Raws to mm2
2033             psllq mm2, ShiftBpp  // shift data to position correctly
2034             movq mm1, mm3        // now use mm1 for getting LBCarrys
2035             pand mm1, mm2      // get LBCarrys for each byte where both
2036                                // lsb's were == 1 (Only valid for active group)
2037             psrlq mm2, 1       // divide raw bytes by 2
2038             pand  mm2, mm4     // clear invalid bit 7 of each byte
2039             paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte
2040             pand mm2, mm6      // Leave only Active Group 2 bytes to add to Avg
2041             paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active
2042                                //  byte
2043
2044             // Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry
2045             psllq mm6, ShiftBpp  // shift the mm6 mask to cover the last two
2046                                  // bytes
2047             movq mm2, mm0        // mov updated Raws to mm2
2048             psllq mm2, ShiftBpp  // shift data to position correctly
2049                               // Data only needs to be shifted once here to
2050                               // get the correct x-bpp offset.
2051             movq mm1, mm3     // now use mm1 for getting LBCarrys
2052             pand mm1, mm2     // get LBCarrys for each byte where both
2053                               // lsb's were == 1 (Only valid for active group)
2054             psrlq mm2, 1      // divide raw bytes by 2
2055             pand  mm2, mm4    // clear invalid bit 7 of each byte
2056             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
2057             pand mm2, mm6     // Leave only Active Group 2 bytes to add to Avg
2058             add ebx, 8
2059             paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active
2060                               // byte
2061
2062             // Now ready to write back to memory
2063             movq [edi + ebx - 8], mm0
2064             // Move updated Raw(x) to use as Raw(x-bpp) for next loop
2065             cmp ebx, MMXLength
2066             movq mm2, mm0     // mov updated Raw(x) to mm2
2067             jb davg3lp
2068          } // end _asm block
2069       }
2070       break;
2071
2072       case 6:
2073       case 4:
2074       case 7:
2075       case 5:
2076       {
2077          ActiveMask.use  = 0xffffffffffffffff;  // use shift below to clear
2078                                                 // appropriate inactive bytes
2079          ShiftBpp.use = bpp << 3;
2080          ShiftRem.use = 64 - ShiftBpp.use;
2081          _asm {
2082             movq mm4, HBClearMask
2083             // Re-init address pointers and offset
2084             mov ebx, diff       // ebx ==> x = offset to alignment boundary
2085             // Load ActiveMask and clear all bytes except for 1st active group
2086             movq mm7, ActiveMask
2087             mov edi, row         // edi ==> Avg(x)
2088             psrlq mm7, ShiftRem
2089             mov esi, prev_row    // esi ==> Prior(x)
2090             movq mm6, mm7
2091             movq mm5, LBCarryMask
2092             psllq mm6, ShiftBpp  // Create mask for 2nd active group
2093             // PRIME the pump (load the first Raw(x-bpp) data set
2094             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
2095                                  // (we correct position in loop below)
2096 davg4lp:
2097             movq mm0, [edi + ebx]
2098             psrlq mm2, ShiftRem  // shift data to position correctly
2099             movq mm1, [esi + ebx]
2100             // Add (Prev_row/2) to Average
2101             movq mm3, mm5
2102             pand mm3, mm1     // get lsb for each prev_row byte
2103             psrlq mm1, 1      // divide prev_row bytes by 2
2104             pand  mm1, mm4    // clear invalid bit 7 of each byte
2105             paddb mm0, mm1    // add (Prev_row/2) to Avg for each byte
2106             // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
2107             movq mm1, mm3     // now use mm1 for getting LBCarrys
2108             pand mm1, mm2     // get LBCarrys for each byte where both
2109                               // lsb's were == 1 (Only valid for active group)
2110             psrlq mm2, 1      // divide raw bytes by 2
2111             pand  mm2, mm4    // clear invalid bit 7 of each byte
2112             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
2113             pand mm2, mm7     // Leave only Active Group 1 bytes to add to Avg
2114             paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active
2115                               // byte
2116             // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
2117             movq mm2, mm0     // mov updated Raws to mm2
2118             psllq mm2, ShiftBpp // shift data to position correctly
2119             add ebx, 8
2120             movq mm1, mm3     // now use mm1 for getting LBCarrys
2121             pand mm1, mm2     // get LBCarrys for each byte where both
2122                               // lsb's were == 1 (Only valid for active group)
2123             psrlq mm2, 1      // divide raw bytes by 2
2124             pand  mm2, mm4    // clear invalid bit 7 of each byte
2125             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
2126             pand mm2, mm6     // Leave only Active Group 2 bytes to add to Avg
2127             paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active
2128                               // byte
2129             cmp ebx, MMXLength
2130             // Now ready to write back to memory
2131             movq [edi + ebx - 8], mm0
2132             // Prep Raw(x-bpp) for next loop
2133             movq mm2, mm0     // mov updated Raws to mm2
2134             jb davg4lp
2135          } // end _asm block
2136       }
2137       break;
2138       case 2:
2139       {
2140          ActiveMask.use  = 0x000000000000ffff;
2141          ShiftBpp.use = 16;   // == 2 * 8     [BUGFIX]
2142          ShiftRem.use = 48;   // == 64 - 16   [BUGFIX]
2143          _asm {
2144             // Load ActiveMask
2145             movq mm7, ActiveMask
2146             // Re-init address pointers and offset
2147             mov ebx, diff     // ebx ==> x = offset to alignment boundary
2148             movq mm5, LBCarryMask
2149             mov edi, row      // edi ==> Avg(x)
2150             movq mm4, HBClearMask
2151             mov esi, prev_row  // esi ==> Prior(x)
2152             // PRIME the pump (load the first Raw(x-bpp) data set
2153             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
2154                               // (we correct position in loop below)
2155 davg2lp:
2156             movq mm0, [edi + ebx]
2157             psrlq mm2, ShiftRem  // shift data to position correctly   [BUGFIX]
2158             movq mm1, [esi + ebx]
2159             // Add (Prev_row/2) to Average
2160             movq mm3, mm5
2161             pand mm3, mm1     // get lsb for each prev_row byte
2162             psrlq mm1, 1      // divide prev_row bytes by 2
2163             pand  mm1, mm4    // clear invalid bit 7 of each byte
2164             movq mm6, mm7
2165             paddb mm0, mm1    // add (Prev_row/2) to Avg for each byte
2166             // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
2167             movq mm1, mm3     // now use mm1 for getting LBCarrys
2168             pand mm1, mm2     // get LBCarrys for each byte where both
2169                               // lsb's were == 1 (Only valid for active group)
2170             psrlq mm2, 1      // divide raw bytes by 2
2171             pand  mm2, mm4    // clear invalid bit 7 of each byte
2172             paddb mm2, mm1    // add LBCarrys to (Raw(x-bpp)/2) for each byte
2173             pand mm2, mm6     // Leave only Active Group 1 bytes to add to Avg
2174             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
2175             // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
2176             psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3
2177             movq mm2, mm0       // mov updated Raws to mm2
2178             psllq mm2, ShiftBpp // shift data to position correctly
2179             movq mm1, mm3       // now use mm1 for getting LBCarrys
2180             pand mm1, mm2       // get LBCarrys for each byte where both
2181                                 // lsb's were == 1 (Only valid for active group)
2182             psrlq mm2, 1        // divide raw bytes by 2
2183             pand  mm2, mm4      // clear invalid bit 7 of each byte
2184             paddb mm2, mm1      // add LBCarrys to (Raw(x-bpp)/2) for each byte
2185             pand mm2, mm6       // Leave only Active Group 2 bytes to add to Avg
2186             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
2187
2188             // Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry
2189             psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5
2190             movq mm2, mm0       // mov updated Raws to mm2
2191             psllq mm2, ShiftBpp // shift data to position correctly
2192                                 // Data only needs to be shifted once here to
2193                                 // get the correct x-bpp offset.
2194             movq mm1, mm3       // now use mm1 for getting LBCarrys
2195             pand mm1, mm2       // get LBCarrys for each byte where both
2196                                 // lsb's were == 1 (Only valid for active group)
2197             psrlq mm2, 1        // divide raw bytes by 2
2198             pand  mm2, mm4      // clear invalid bit 7 of each byte
2199             paddb mm2, mm1      // add LBCarrys to (Raw(x-bpp)/2) for each byte
2200             pand mm2, mm6       // Leave only Active Group 2 bytes to add to Avg
2201             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
2202
2203             // Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry
2204             psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 6 & 7
2205             movq mm2, mm0        // mov updated Raws to mm2
2206             psllq mm2, ShiftBpp  // shift data to position correctly
2207                                  // Data only needs to be shifted once here to
2208                                  // get the correct x-bpp offset.
2209             add ebx, 8
2210             movq mm1, mm3    // now use mm1 for getting LBCarrys
2211             pand mm1, mm2    // get LBCarrys for each byte where both
2212                              // lsb's were == 1 (Only valid for active group)
2213             psrlq mm2, 1     // divide raw bytes by 2
2214             pand  mm2, mm4   // clear invalid bit 7 of each byte
2215             paddb mm2, mm1   // add LBCarrys to (Raw(x-bpp)/2) for each byte
2216             pand mm2, mm6    // Leave only Active Group 2 bytes to add to Avg
2217             paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte
2218
2219             cmp ebx, MMXLength
2220             // Now ready to write back to memory
2221             movq [edi + ebx - 8], mm0
2222             // Prep Raw(x-bpp) for next loop
2223             movq mm2, mm0    // mov updated Raws to mm2
2224             jb davg2lp
2225         } // end _asm block
2226       }
2227       break;
2228
2229       case 1:                 // bpp == 1
2230       {
2231          _asm {
2232             // Re-init address pointers and offset
2233             mov ebx, diff     // ebx ==> x = offset to alignment boundary
2234             mov edi, row      // edi ==> Avg(x)
2235             cmp ebx, FullLength  // Test if offset at end of array
2236             jnb davg1end
2237             // Do Paeth decode for remaining bytes
2238             mov esi, prev_row    // esi ==> Prior(x)
2239             mov edx, edi
2240             xor ecx, ecx         // zero ecx before using cl & cx in loop below
2241             sub edx, bpp         // edx ==> Raw(x-bpp)
2242 davg1lp:
2243             // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
2244             xor eax, eax
2245             mov cl, [esi + ebx]  // load cl with Prior(x)
2246             mov al, [edx + ebx]  // load al with Raw(x-bpp)
2247             add ax, cx
2248             inc ebx
2249             shr ax, 1            // divide by 2
2250             add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx
2251             cmp ebx, FullLength  // Check if at end of array
2252             mov [edi+ebx-1], al  // Write back Raw(x);
2253                          // mov does not affect flags; -1 to offset inc ebx
2254             jb davg1lp
2255 davg1end:
2256          } // end _asm block
2257       }
2258       return;
2259
2260       case 8:             // bpp == 8
2261       {
2262          _asm {
2263             // Re-init address pointers and offset
2264             mov ebx, diff           // ebx ==> x = offset to alignment boundary
2265             movq mm5, LBCarryMask
2266             mov edi, row            // edi ==> Avg(x)
2267             movq mm4, HBClearMask
2268             mov esi, prev_row       // esi ==> Prior(x)
2269             // PRIME the pump (load the first Raw(x-bpp) data set
2270             movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
2271                                 // (NO NEED to correct position in loop below)
2272 davg8lp:
2273             movq mm0, [edi + ebx]
2274             movq mm3, mm5
2275             movq mm1, [esi + ebx]
2276             add ebx, 8
2277             pand mm3, mm1       // get lsb for each prev_row byte
2278             psrlq mm1, 1        // divide prev_row bytes by 2
2279             pand mm3, mm2       // get LBCarrys for each byte where both
2280                                 // lsb's were == 1
2281             psrlq mm2, 1        // divide raw bytes by 2
2282             pand  mm1, mm4      // clear invalid bit 7 of each byte
2283             paddb mm0, mm3      // add LBCarrys to Avg for each byte
2284             pand  mm2, mm4      // clear invalid bit 7 of each byte
2285             paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte
2286             paddb mm0, mm2      // add (Raw/2) to Avg for each byte
2287             cmp ebx, MMXLength
2288             movq [edi + ebx - 8], mm0
2289             movq mm2, mm0       // reuse as Raw(x-bpp)
2290             jb davg8lp
2291         } // end _asm block
2292       }
2293       break;
2294       default:                  // bpp greater than 8
2295       {
2296         _asm {
2297             movq mm5, LBCarryMask
2298             // Re-init address pointers and offset
2299             mov ebx, diff       // ebx ==> x = offset to alignment boundary
2300             mov edi, row        // edi ==> Avg(x)
2301             movq mm4, HBClearMask
2302             mov edx, edi
2303             mov esi, prev_row   // esi ==> Prior(x)
2304             sub edx, bpp        // edx ==> Raw(x-bpp)
2305 davgAlp:
2306             movq mm0, [edi + ebx]
2307             movq mm3, mm5
2308             movq mm1, [esi + ebx]
2309             pand mm3, mm1       // get lsb for each prev_row byte
2310             movq mm2, [edx + ebx]
2311             psrlq mm1, 1        // divide prev_row bytes by 2
2312             pand mm3, mm2       // get LBCarrys for each byte where both
2313                                 // lsb's were == 1
2314             psrlq mm2, 1        // divide raw bytes by 2
2315             pand  mm1, mm4      // clear invalid bit 7 of each byte
2316             paddb mm0, mm3      // add LBCarrys to Avg for each byte
2317             pand  mm2, mm4      // clear invalid bit 7 of each byte
2318             paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte
2319             add ebx, 8
2320             paddb mm0, mm2      // add (Raw/2) to Avg for each byte
2321             cmp ebx, MMXLength
2322             movq [edi + ebx - 8], mm0
2323             jb davgAlp
2324         } // end _asm block
2325       }
2326       break;
2327    }                         // end switch ( bpp )
2328
2329    _asm {
2330          // MMX acceleration complete now do clean-up
2331          // Check if any remaining bytes left to decode
2332          mov ebx, MMXLength    // ebx ==> x = offset bytes remaining after MMX
2333          mov edi, row          // edi ==> Avg(x)
2334          cmp ebx, FullLength   // Test if offset at end of array
2335          jnb davgend
2336          // Do Paeth decode for remaining bytes
2337          mov esi, prev_row     // esi ==> Prior(x)
2338          mov edx, edi
2339          xor ecx, ecx          // zero ecx before using cl & cx in loop below
2340          sub edx, bpp          // edx ==> Raw(x-bpp)
2341 davglp2:
2342          // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
2343          xor eax, eax
2344          mov cl, [esi + ebx]   // load cl with Prior(x)
2345          mov al, [edx + ebx]   // load al with Raw(x-bpp)
2346          add ax, cx
2347          inc ebx
2348          shr ax, 1              // divide by 2
2349          add al, [edi+ebx-1]    // Add Avg(x); -1 to offset inc ebx
2350          cmp ebx, FullLength    // Check if at end of array
2351          mov [edi+ebx-1], al    // Write back Raw(x);
2352                           // mov does not affect flags; -1 to offset inc ebx
2353          jb davglp2
2354 davgend:
2355          emms             // End MMX instructions; prep for possible FP instrs.
2356    } // end _asm block
2357 }
2358
2359 // Optimized code for PNG Paeth filter decoder
2360 void /* PRIVATE */
2361 png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row,
2362                               png_bytep prev_row)
2363 {
2364    png_uint_32 FullLength;
2365    png_uint_32 MMXLength;
2366    //png_uint_32 len;
2367    int bpp;
2368    int diff;
2369    //int ptemp;
2370    int patemp, pbtemp, pctemp;
2371
2372    bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
2373    FullLength  = row_info->rowbytes; // # of bytes to filter
2374    _asm
2375    {
2376          xor ebx, ebx        // ebx ==> x offset
2377          mov edi, row
2378          xor edx, edx        // edx ==> x-bpp offset
2379          mov esi, prev_row
2380          xor eax, eax
2381
2382          // Compute the Raw value for the first bpp bytes
2383          // Note: the formula works out to be always
2384          //   Paeth(x) = Raw(x) + Prior(x)      where x < bpp
2385 dpthrlp:
2386          mov al, [edi + ebx]
2387          add al, [esi + ebx]
2388          inc ebx
2389          cmp ebx, bpp
2390          mov [edi + ebx - 1], al
2391          jb dpthrlp
2392          // get # of bytes to alignment
2393          mov diff, edi         // take start of row
2394          add diff, ebx         // add bpp
2395          xor ecx, ecx
2396          add diff, 0xf         // add 7 + 8 to incr past alignment boundary
2397          and diff, 0xfffffff8  // mask to alignment boundary
2398          sub diff, edi         // subtract from start ==> value ebx at alignment
2399          jz dpthgo
2400          // fix alignment
2401 dpthlp1:
2402          xor eax, eax
2403          // pav = p - a = (a + b - c) - a = b - c
2404          mov al, [esi + ebx]   // load Prior(x) into al
2405          mov cl, [esi + edx]   // load Prior(x-bpp) into cl
2406          sub eax, ecx          // subtract Prior(x-bpp)
2407          mov patemp, eax       // Save pav for later use
2408          xor eax, eax
2409          // pbv = p - b = (a + b - c) - b = a - c
2410          mov al, [edi + edx]   // load Raw(x-bpp) into al
2411          sub eax, ecx          // subtract Prior(x-bpp)
2412          mov ecx, eax
2413          // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2414          add eax, patemp       // pcv = pav + pbv
2415          // pc = abs(pcv)
2416          test eax, 0x80000000
2417          jz dpthpca
2418          neg eax               // reverse sign of neg values
2419 dpthpca:
2420          mov pctemp, eax       // save pc for later use
2421          // pb = abs(pbv)
2422          test ecx, 0x80000000
2423          jz dpthpba
2424          neg ecx               // reverse sign of neg values
2425 dpthpba:
2426          mov pbtemp, ecx       // save pb for later use
2427          // pa = abs(pav)
2428          mov eax, patemp
2429          test eax, 0x80000000
2430          jz dpthpaa
2431          neg eax               // reverse sign of neg values
2432 dpthpaa:
2433          mov patemp, eax       // save pa for later use
2434          // test if pa <= pb
2435          cmp eax, ecx
2436          jna dpthabb
2437          // pa > pb; now test if pb <= pc
2438          cmp ecx, pctemp
2439          jna dpthbbc
2440          // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
2441          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
2442          jmp dpthpaeth
2443 dpthbbc:
2444          // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
2445          mov cl, [esi + ebx]   // load Prior(x) into cl
2446          jmp dpthpaeth
2447 dpthabb:
2448          // pa <= pb; now test if pa <= pc
2449          cmp eax, pctemp
2450          jna dpthabc
2451          // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
2452          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
2453          jmp dpthpaeth
2454 dpthabc:
2455          // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
2456          mov cl, [edi + edx]  // load Raw(x-bpp) into cl
2457 dpthpaeth:
2458          inc ebx
2459          inc edx
2460          // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
2461          add [edi + ebx - 1], cl
2462          cmp ebx, diff
2463          jb dpthlp1
2464 dpthgo:
2465          mov ecx, FullLength
2466          mov eax, ecx
2467          sub eax, ebx          // subtract alignment fix
2468          and eax, 0x00000007   // calc bytes over mult of 8
2469          sub ecx, eax          // drop over bytes from original length
2470          mov MMXLength, ecx
2471    } // end _asm block
2472    // Now do the math for the rest of the row
2473    switch ( bpp )
2474    {
2475       case 3:
2476       {
2477          ActiveMask.use = 0x0000000000ffffff;
2478          ActiveMaskEnd.use = 0xffff000000000000;
2479          ShiftBpp.use = 24;    // == bpp(3) * 8
2480          ShiftRem.use = 40;    // == 64 - 24
2481          _asm
2482          {
2483             mov ebx, diff
2484             mov edi, row
2485             mov esi, prev_row
2486             pxor mm0, mm0
2487             // PRIME the pump (load the first Raw(x-bpp) data set
2488             movq mm1, [edi+ebx-8]
2489 dpth3lp:
2490             psrlq mm1, ShiftRem     // shift last 3 bytes to 1st 3 bytes
2491             movq mm2, [esi + ebx]   // load b=Prior(x)
2492             punpcklbw mm1, mm0      // Unpack High bytes of a
2493             movq mm3, [esi+ebx-8]   // Prep c=Prior(x-bpp) bytes
2494             punpcklbw mm2, mm0      // Unpack High bytes of b
2495             psrlq mm3, ShiftRem     // shift last 3 bytes to 1st 3 bytes
2496             // pav = p - a = (a + b - c) - a = b - c
2497             movq mm4, mm2
2498             punpcklbw mm3, mm0      // Unpack High bytes of c
2499             // pbv = p - b = (a + b - c) - b = a - c
2500             movq mm5, mm1
2501             psubw mm4, mm3
2502             pxor mm7, mm7
2503             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2504             movq mm6, mm4
2505             psubw mm5, mm3
2506
2507             // pa = abs(p-a) = abs(pav)
2508             // pb = abs(p-b) = abs(pbv)
2509             // pc = abs(p-c) = abs(pcv)
2510             pcmpgtw mm0, mm4    // Create mask pav bytes < 0
2511             paddw mm6, mm5
2512             pand mm0, mm4       // Only pav bytes < 0 in mm7
2513             pcmpgtw mm7, mm5    // Create mask pbv bytes < 0
2514             psubw mm4, mm0
2515             pand mm7, mm5       // Only pbv bytes < 0 in mm0
2516             psubw mm4, mm0
2517             psubw mm5, mm7
2518             pxor mm0, mm0
2519             pcmpgtw mm0, mm6    // Create mask pcv bytes < 0
2520             pand mm0, mm6       // Only pav bytes < 0 in mm7
2521             psubw mm5, mm7
2522             psubw mm6, mm0
2523             //  test pa <= pb
2524             movq mm7, mm4
2525             psubw mm6, mm0
2526             pcmpgtw mm7, mm5    // pa > pb?
2527             movq mm0, mm7
2528             // use mm7 mask to merge pa & pb
2529             pand mm5, mm7
2530             // use mm0 mask copy to merge a & b
2531             pand mm2, mm0
2532             pandn mm7, mm4
2533             pandn mm0, mm1
2534             paddw mm7, mm5
2535             paddw mm0, mm2
2536             //  test  ((pa <= pb)? pa:pb) <= pc
2537             pcmpgtw mm7, mm6       // pab > pc?
2538             pxor mm1, mm1
2539             pand mm3, mm7
2540             pandn mm7, mm0
2541             paddw mm7, mm3
2542             pxor mm0, mm0
2543             packuswb mm7, mm1
2544             movq mm3, [esi + ebx]   // load c=Prior(x-bpp)
2545             pand mm7, ActiveMask
2546             movq mm2, mm3           // load b=Prior(x) step 1
2547             paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)
2548             punpcklbw mm3, mm0      // Unpack High bytes of c
2549             movq [edi + ebx], mm7   // write back updated value
2550             movq mm1, mm7           // Now mm1 will be used as Raw(x-bpp)
2551             // Now do Paeth for 2nd set of bytes (3-5)
2552             psrlq mm2, ShiftBpp     // load b=Prior(x) step 2
2553             punpcklbw mm1, mm0      // Unpack High bytes of a
2554             pxor mm7, mm7
2555             punpcklbw mm2, mm0      // Unpack High bytes of b
2556             // pbv = p - b = (a + b - c) - b = a - c
2557             movq mm5, mm1
2558             // pav = p - a = (a + b - c) - a = b - c
2559             movq mm4, mm2
2560             psubw mm5, mm3
2561             psubw mm4, mm3
2562             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) =
2563             //       pav + pbv = pbv + pav
2564             movq mm6, mm5
2565             paddw mm6, mm4
2566
2567             // pa = abs(p-a) = abs(pav)
2568             // pb = abs(p-b) = abs(pbv)
2569             // pc = abs(p-c) = abs(pcv)
2570             pcmpgtw mm0, mm5       // Create mask pbv bytes < 0
2571             pcmpgtw mm7, mm4       // Create mask pav bytes < 0
2572             pand mm0, mm5          // Only pbv bytes < 0 in mm0
2573             pand mm7, mm4          // Only pav bytes < 0 in mm7
2574             psubw mm5, mm0
2575             psubw mm4, mm7
2576             psubw mm5, mm0
2577             psubw mm4, mm7
2578             pxor mm0, mm0
2579             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
2580             pand mm0, mm6          // Only pav bytes < 0 in mm7
2581             psubw mm6, mm0
2582             //  test pa <= pb
2583             movq mm7, mm4
2584             psubw mm6, mm0
2585             pcmpgtw mm7, mm5       // pa > pb?
2586             movq mm0, mm7
2587             // use mm7 mask to merge pa & pb
2588             pand mm5, mm7
2589             // use mm0 mask copy to merge a & b
2590             pand mm2, mm0
2591             pandn mm7, mm4
2592             pandn mm0, mm1
2593             paddw mm7, mm5
2594             paddw mm0, mm2
2595             //  test  ((pa <= pb)? pa:pb) <= pc
2596             pcmpgtw mm7, mm6       // pab > pc?
2597             movq mm2, [esi + ebx]  // load b=Prior(x)
2598             pand mm3, mm7
2599             pandn mm7, mm0
2600             pxor mm1, mm1
2601             paddw mm7, mm3
2602             pxor mm0, mm0
2603             packuswb mm7, mm1
2604             movq mm3, mm2           // load c=Prior(x-bpp) step 1
2605             pand mm7, ActiveMask
2606             punpckhbw mm2, mm0      // Unpack High bytes of b
2607             psllq mm7, ShiftBpp     // Shift bytes to 2nd group of 3 bytes
2608              // pav = p - a = (a + b - c) - a = b - c
2609             movq mm4, mm2
2610             paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)
2611             psllq mm3, ShiftBpp     // load c=Prior(x-bpp) step 2
2612             movq [edi + ebx], mm7   // write back updated value
2613             movq mm1, mm7
2614             punpckhbw mm3, mm0      // Unpack High bytes of c
2615             psllq mm1, ShiftBpp     // Shift bytes
2616                                     // Now mm1 will be used as Raw(x-bpp)
2617             // Now do Paeth for 3rd, and final, set of bytes (6-7)
2618             pxor mm7, mm7
2619             punpckhbw mm1, mm0      // Unpack High bytes of a
2620             psubw mm4, mm3
2621             // pbv = p - b = (a + b - c) - b = a - c
2622             movq mm5, mm1
2623             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2624             movq mm6, mm4
2625             psubw mm5, mm3
2626             pxor mm0, mm0
2627             paddw mm6, mm5
2628
2629             // pa = abs(p-a) = abs(pav)
2630             // pb = abs(p-b) = abs(pbv)
2631             // pc = abs(p-c) = abs(pcv)
2632             pcmpgtw mm0, mm4    // Create mask pav bytes < 0
2633             pcmpgtw mm7, mm5    // Create mask pbv bytes < 0
2634             pand mm0, mm4       // Only pav bytes < 0 in mm7
2635             pand mm7, mm5       // Only pbv bytes < 0 in mm0
2636             psubw mm4, mm0
2637             psubw mm5, mm7
2638             psubw mm4, mm0
2639             psubw mm5, mm7
2640             pxor mm0, mm0
2641             pcmpgtw mm0, mm6    // Create mask pcv bytes < 0
2642             pand mm0, mm6       // Only pav bytes < 0 in mm7
2643             psubw mm6, mm0
2644             //  test pa <= pb
2645             movq mm7, mm4
2646             psubw mm6, mm0
2647             pcmpgtw mm7, mm5    // pa > pb?
2648             movq mm0, mm7
2649             // use mm0 mask copy to merge a & b
2650             pand mm2, mm0
2651             // use mm7 mask to merge pa & pb
2652             pand mm5, mm7
2653             pandn mm0, mm1
2654             pandn mm7, mm4
2655             paddw mm0, mm2
2656             paddw mm7, mm5
2657             //  test  ((pa <= pb)? pa:pb) <= pc
2658             pcmpgtw mm7, mm6    // pab > pc?
2659             pand mm3, mm7
2660             pandn mm7, mm0
2661             paddw mm7, mm3
2662             pxor mm1, mm1
2663             packuswb mm1, mm7
2664             // Step ebx to next set of 8 bytes and repeat loop til done
2665             add ebx, 8
2666             pand mm1, ActiveMaskEnd
2667             paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x)
2668
2669             cmp ebx, MMXLength
2670             pxor mm0, mm0              // pxor does not affect flags
2671             movq [edi + ebx - 8], mm1  // write back updated value
2672                                  // mm1 will be used as Raw(x-bpp) next loop
2673                            // mm3 ready to be used as Prior(x-bpp) next loop
2674             jb dpth3lp
2675          } // end _asm block
2676       }
2677       break;
2678
2679       case 6:
2680       case 7:
2681       case 5:
2682       {
2683          ActiveMask.use  = 0x00000000ffffffff;
2684          ActiveMask2.use = 0xffffffff00000000;
2685          ShiftBpp.use = bpp << 3;    // == bpp * 8
2686          ShiftRem.use = 64 - ShiftBpp.use;
2687          _asm
2688          {
2689             mov ebx, diff
2690             mov edi, row
2691             mov esi, prev_row
2692             // PRIME the pump (load the first Raw(x-bpp) data set
2693             movq mm1, [edi+ebx-8]
2694             pxor mm0, mm0
2695 dpth6lp:
2696             // Must shift to position Raw(x-bpp) data
2697             psrlq mm1, ShiftRem
2698             // Do first set of 4 bytes
2699             movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
2700             punpcklbw mm1, mm0      // Unpack Low bytes of a
2701             movq mm2, [esi + ebx]   // load b=Prior(x)
2702             punpcklbw mm2, mm0      // Unpack Low bytes of b
2703             // Must shift to position Prior(x-bpp) data
2704             psrlq mm3, ShiftRem
2705             // pav = p - a = (a + b - c) - a = b - c
2706             movq mm4, mm2
2707             punpcklbw mm3, mm0      // Unpack Low bytes of c
2708             // pbv = p - b = (a + b - c) - b = a - c
2709             movq mm5, mm1
2710             psubw mm4, mm3
2711             pxor mm7, mm7
2712             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2713             movq mm6, mm4
2714             psubw mm5, mm3
2715             // pa = abs(p-a) = abs(pav)
2716             // pb = abs(p-b) = abs(pbv)
2717             // pc = abs(p-c) = abs(pcv)
2718             pcmpgtw mm0, mm4    // Create mask pav bytes < 0
2719             paddw mm6, mm5
2720             pand mm0, mm4       // Only pav bytes < 0 in mm7
2721             pcmpgtw mm7, mm5    // Create mask pbv bytes < 0
2722             psubw mm4, mm0
2723             pand mm7, mm5       // Only pbv bytes < 0 in mm0
2724             psubw mm4, mm0
2725             psubw mm5, mm7
2726             pxor mm0, mm0
2727             pcmpgtw mm0, mm6    // Create mask pcv bytes < 0
2728             pand mm0, mm6       // Only pav bytes < 0 in mm7
2729             psubw mm5, mm7
2730             psubw mm6, mm0
2731             //  test pa <= pb
2732             movq mm7, mm4
2733             psubw mm6, mm0
2734             pcmpgtw mm7, mm5    // pa > pb?
2735             movq mm0, mm7
2736             // use mm7 mask to merge pa & pb
2737             pand mm5, mm7
2738             // use mm0 mask copy to merge a & b
2739             pand mm2, mm0
2740             pandn mm7, mm4
2741             pandn mm0, mm1
2742             paddw mm7, mm5
2743             paddw mm0, mm2
2744             //  test  ((pa <= pb)? pa:pb) <= pc
2745             pcmpgtw mm7, mm6    // pab > pc?
2746             pxor mm1, mm1
2747             pand mm3, mm7
2748             pandn mm7, mm0
2749             paddw mm7, mm3
2750             pxor mm0, mm0
2751             packuswb mm7, mm1
2752             movq mm3, [esi + ebx - 8]  // load c=Prior(x-bpp)
2753             pand mm7, ActiveMask
2754             psrlq mm3, ShiftRem
2755             movq mm2, [esi + ebx]      // load b=Prior(x) step 1
2756             paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
2757             movq mm6, mm2
2758             movq [edi + ebx], mm7      // write back updated value
2759             movq mm1, [edi+ebx-8]
2760             psllq mm6, ShiftBpp
2761             movq mm5, mm7
2762             psrlq mm1, ShiftRem
2763             por mm3, mm6
2764             psllq mm5, ShiftBpp
2765             punpckhbw mm3, mm0         // Unpack High bytes of c
2766             por mm1, mm5
2767             // Do second set of 4 bytes
2768             punpckhbw mm2, mm0         // Unpack High bytes of b
2769             punpckhbw mm1, mm0         // Unpack High bytes of a
2770             // pav = p - a = (a + b - c) - a = b - c
2771             movq mm4, mm2
2772             // pbv = p - b = (a + b - c) - b = a - c
2773             movq mm5, mm1
2774             psubw mm4, mm3
2775             pxor mm7, mm7
2776             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2777             movq mm6, mm4
2778             psubw mm5, mm3
2779             // pa = abs(p-a) = abs(pav)
2780             // pb = abs(p-b) = abs(pbv)
2781             // pc = abs(p-c) = abs(pcv)
2782             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
2783             paddw mm6, mm5
2784             pand mm0, mm4          // Only pav bytes < 0 in mm7
2785             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
2786             psubw mm4, mm0
2787             pand mm7, mm5          // Only pbv bytes < 0 in mm0
2788             psubw mm4, mm0
2789             psubw mm5, mm7
2790             pxor mm0, mm0
2791             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
2792             pand mm0, mm6          // Only pav bytes < 0 in mm7
2793             psubw mm5, mm7
2794             psubw mm6, mm0
2795             //  test pa <= pb
2796             movq mm7, mm4
2797             psubw mm6, mm0
2798             pcmpgtw mm7, mm5       // pa > pb?
2799             movq mm0, mm7
2800             // use mm7 mask to merge pa & pb
2801             pand mm5, mm7
2802             // use mm0 mask copy to merge a & b
2803             pand mm2, mm0
2804             pandn mm7, mm4
2805             pandn mm0, mm1
2806             paddw mm7, mm5
2807             paddw mm0, mm2
2808             //  test  ((pa <= pb)? pa:pb) <= pc
2809             pcmpgtw mm7, mm6           // pab > pc?
2810             pxor mm1, mm1
2811             pand mm3, mm7
2812             pandn mm7, mm0
2813             pxor mm1, mm1
2814             paddw mm7, mm3
2815             pxor mm0, mm0
2816             // Step ex to next set of 8 bytes and repeat loop til done
2817             add ebx, 8
2818             packuswb mm1, mm7
2819             paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
2820             cmp ebx, MMXLength
2821             movq [edi + ebx - 8], mm1      // write back updated value
2822                                 // mm1 will be used as Raw(x-bpp) next loop
2823             jb dpth6lp
2824          } // end _asm block
2825       }
2826       break;
2827
2828       case 4:
2829       {
2830          ActiveMask.use  = 0x00000000ffffffff;
2831          _asm {
2832             mov ebx, diff
2833             mov edi, row
2834             mov esi, prev_row
2835             pxor mm0, mm0
2836             // PRIME the pump (load the first Raw(x-bpp) data set
2837             movq mm1, [edi+ebx-8]    // Only time should need to read
2838                                      //  a=Raw(x-bpp) bytes
2839 dpth4lp:
2840             // Do first set of 4 bytes
2841             movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes
2842             punpckhbw mm1, mm0       // Unpack Low bytes of a
2843             movq mm2, [esi + ebx]    // load b=Prior(x)
2844             punpcklbw mm2, mm0       // Unpack High bytes of b
2845             // pav = p - a = (a + b - c) - a = b - c
2846             movq mm4, mm2
2847             punpckhbw mm3, mm0       // Unpack High bytes of c
2848             // pbv = p - b = (a + b - c) - b = a - c
2849             movq mm5, mm1
2850             psubw mm4, mm3
2851             pxor mm7, mm7
2852             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2853             movq mm6, mm4
2854             psubw mm5, mm3
2855             // pa = abs(p-a) = abs(pav)
2856             // pb = abs(p-b) = abs(pbv)
2857             // pc = abs(p-c) = abs(pcv)
2858             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
2859             paddw mm6, mm5
2860             pand mm0, mm4          // Only pav bytes < 0 in mm7
2861             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
2862             psubw mm4, mm0
2863             pand mm7, mm5          // Only pbv bytes < 0 in mm0
2864             psubw mm4, mm0
2865             psubw mm5, mm7
2866             pxor mm0, mm0
2867             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
2868             pand mm0, mm6          // Only pav bytes < 0 in mm7
2869             psubw mm5, mm7
2870             psubw mm6, mm0
2871             //  test pa <= pb
2872             movq mm7, mm4
2873             psubw mm6, mm0
2874             pcmpgtw mm7, mm5       // pa > pb?
2875             movq mm0, mm7
2876             // use mm7 mask to merge pa & pb
2877             pand mm5, mm7
2878             // use mm0 mask copy to merge a & b
2879             pand mm2, mm0
2880             pandn mm7, mm4
2881             pandn mm0, mm1
2882             paddw mm7, mm5
2883             paddw mm0, mm2
2884             //  test  ((pa <= pb)? pa:pb) <= pc
2885             pcmpgtw mm7, mm6       // pab > pc?
2886             pxor mm1, mm1
2887             pand mm3, mm7
2888             pandn mm7, mm0
2889             paddw mm7, mm3
2890             pxor mm0, mm0
2891             packuswb mm7, mm1
2892             movq mm3, [esi + ebx]      // load c=Prior(x-bpp)
2893             pand mm7, ActiveMask
2894             movq mm2, mm3              // load b=Prior(x) step 1
2895             paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
2896             punpcklbw mm3, mm0         // Unpack High bytes of c
2897             movq [edi + ebx], mm7      // write back updated value
2898             movq mm1, mm7              // Now mm1 will be used as Raw(x-bpp)
2899             // Do second set of 4 bytes
2900             punpckhbw mm2, mm0         // Unpack Low bytes of b
2901             punpcklbw mm1, mm0         // Unpack Low bytes of a
2902             // pav = p - a = (a + b - c) - a = b - c
2903             movq mm4, mm2
2904             // pbv = p - b = (a + b - c) - b = a - c
2905             movq mm5, mm1
2906             psubw mm4, mm3
2907             pxor mm7, mm7
2908             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2909             movq mm6, mm4
2910             psubw mm5, mm3
2911             // pa = abs(p-a) = abs(pav)
2912             // pb = abs(p-b) = abs(pbv)
2913             // pc = abs(p-c) = abs(pcv)
2914             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
2915             paddw mm6, mm5
2916             pand mm0, mm4          // Only pav bytes < 0 in mm7
2917             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
2918             psubw mm4, mm0
2919             pand mm7, mm5          // Only pbv bytes < 0 in mm0
2920             psubw mm4, mm0
2921             psubw mm5, mm7
2922             pxor mm0, mm0
2923             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
2924             pand mm0, mm6          // Only pav bytes < 0 in mm7
2925             psubw mm5, mm7
2926             psubw mm6, mm0
2927             //  test pa <= pb
2928             movq mm7, mm4
2929             psubw mm6, mm0
2930             pcmpgtw mm7, mm5       // pa > pb?
2931             movq mm0, mm7
2932             // use mm7 mask to merge pa & pb
2933             pand mm5, mm7
2934             // use mm0 mask copy to merge a & b
2935             pand mm2, mm0
2936             pandn mm7, mm4
2937             pandn mm0, mm1
2938             paddw mm7, mm5
2939             paddw mm0, mm2
2940             //  test  ((pa <= pb)? pa:pb) <= pc
2941             pcmpgtw mm7, mm6       // pab > pc?
2942             pxor mm1, mm1
2943             pand mm3, mm7
2944             pandn mm7, mm0
2945             pxor mm1, mm1
2946             paddw mm7, mm3
2947             pxor mm0, mm0
2948             // Step ex to next set of 8 bytes and repeat loop til done
2949             add ebx, 8
2950             packuswb mm1, mm7
2951             paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
2952             cmp ebx, MMXLength
2953             movq [edi + ebx - 8], mm1      // write back updated value
2954                                 // mm1 will be used as Raw(x-bpp) next loop
2955             jb dpth4lp
2956          } // end _asm block
2957       }
2958       break;
2959       case 8:                          // bpp == 8
2960       {
2961          ActiveMask.use  = 0x00000000ffffffff;
2962          _asm {
2963             mov ebx, diff
2964             mov edi, row
2965             mov esi, prev_row
2966             pxor mm0, mm0
2967             // PRIME the pump (load the first Raw(x-bpp) data set
2968             movq mm1, [edi+ebx-8]      // Only time should need to read
2969                                        //  a=Raw(x-bpp) bytes
2970 dpth8lp:
2971             // Do first set of 4 bytes
2972             movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
2973             punpcklbw mm1, mm0         // Unpack Low bytes of a
2974             movq mm2, [esi + ebx]      // load b=Prior(x)
2975             punpcklbw mm2, mm0         // Unpack Low bytes of b
2976             // pav = p - a = (a + b - c) - a = b - c
2977             movq mm4, mm2
2978             punpcklbw mm3, mm0         // Unpack Low bytes of c
2979             // pbv = p - b = (a + b - c) - b = a - c
2980             movq mm5, mm1
2981             psubw mm4, mm3
2982             pxor mm7, mm7
2983             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
2984             movq mm6, mm4
2985             psubw mm5, mm3
2986             // pa = abs(p-a) = abs(pav)
2987             // pb = abs(p-b) = abs(pbv)
2988             // pc = abs(p-c) = abs(pcv)
2989             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
2990             paddw mm6, mm5
2991             pand mm0, mm4          // Only pav bytes < 0 in mm7
2992             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
2993             psubw mm4, mm0
2994             pand mm7, mm5          // Only pbv bytes < 0 in mm0
2995             psubw mm4, mm0
2996             psubw mm5, mm7
2997             pxor mm0, mm0
2998             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
2999             pand mm0, mm6          // Only pav bytes < 0 in mm7
3000             psubw mm5, mm7
3001             psubw mm6, mm0
3002             //  test pa <= pb
3003             movq mm7, mm4
3004             psubw mm6, mm0
3005             pcmpgtw mm7, mm5       // pa > pb?
3006             movq mm0, mm7
3007             // use mm7 mask to merge pa & pb
3008             pand mm5, mm7
3009             // use mm0 mask copy to merge a & b
3010             pand mm2, mm0
3011             pandn mm7, mm4
3012             pandn mm0, mm1
3013             paddw mm7, mm5
3014             paddw mm0, mm2
3015             //  test  ((pa <= pb)? pa:pb) <= pc
3016             pcmpgtw mm7, mm6       // pab > pc?
3017             pxor mm1, mm1
3018             pand mm3, mm7
3019             pandn mm7, mm0
3020             paddw mm7, mm3
3021             pxor mm0, mm0
3022             packuswb mm7, mm1
3023             movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes
3024             pand mm7, ActiveMask
3025             movq mm2, [esi + ebx]    // load b=Prior(x)
3026             paddb mm7, [edi + ebx]   // add Paeth predictor with Raw(x)
3027             punpckhbw mm3, mm0       // Unpack High bytes of c
3028             movq [edi + ebx], mm7    // write back updated value
3029             movq mm1, [edi+ebx-8]    // read a=Raw(x-bpp) bytes
3030
3031             // Do second set of 4 bytes
3032             punpckhbw mm2, mm0       // Unpack High bytes of b
3033             punpckhbw mm1, mm0       // Unpack High bytes of a
3034             // pav = p - a = (a + b - c) - a = b - c
3035             movq mm4, mm2
3036             // pbv = p - b = (a + b - c) - b = a - c
3037             movq mm5, mm1
3038             psubw mm4, mm3
3039             pxor mm7, mm7
3040             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
3041             movq mm6, mm4
3042             psubw mm5, mm3
3043             // pa = abs(p-a) = abs(pav)
3044             // pb = abs(p-b) = abs(pbv)
3045             // pc = abs(p-c) = abs(pcv)
3046             pcmpgtw mm0, mm4       // Create mask pav bytes < 0
3047             paddw mm6, mm5
3048             pand mm0, mm4          // Only pav bytes < 0 in mm7
3049             pcmpgtw mm7, mm5       // Create mask pbv bytes < 0
3050             psubw mm4, mm0
3051             pand mm7, mm5          // Only pbv bytes < 0 in mm0
3052             psubw mm4, mm0
3053             psubw mm5, mm7
3054             pxor mm0, mm0
3055             pcmpgtw mm0, mm6       // Create mask pcv bytes < 0
3056             pand mm0, mm6          // Only pav bytes < 0 in mm7
3057             psubw mm5, mm7
3058             psubw mm6, mm0
3059             //  test pa <= pb
3060             movq mm7, mm4
3061             psubw mm6, mm0
3062             pcmpgtw mm7, mm5       // pa > pb?
3063             movq mm0, mm7
3064             // use mm7 mask to merge pa & pb
3065             pand mm5, mm7
3066             // use mm0 mask copy to merge a & b
3067             pand mm2, mm0
3068             pandn mm7, mm4
3069             pandn mm0, mm1
3070             paddw mm7, mm5
3071             paddw mm0, mm2
3072             //  test  ((pa <= pb)? pa:pb) <= pc
3073             pcmpgtw mm7, mm6       // pab > pc?
3074             pxor mm1, mm1
3075             pand mm3, mm7
3076             pandn mm7, mm0
3077             pxor mm1, mm1
3078             paddw mm7, mm3
3079             pxor mm0, mm0
3080             // Step ex to next set of 8 bytes and repeat loop til done
3081             add ebx, 8
3082             packuswb mm1, mm7
3083             paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
3084             cmp ebx, MMXLength
3085             movq [edi + ebx - 8], mm1      // write back updated value
3086                             // mm1 will be used as Raw(x-bpp) next loop
3087             jb dpth8lp
3088          } // end _asm block
3089       }
3090       break;
3091
3092       case 1:                // bpp = 1
3093       case 2:                // bpp = 2
3094       default:               // bpp > 8
3095       {
3096          _asm {
3097             mov ebx, diff
3098             cmp ebx, FullLength
3099             jnb dpthdend
3100             mov edi, row
3101             mov esi, prev_row
3102             // Do Paeth decode for remaining bytes
3103             mov edx, ebx
3104             xor ecx, ecx        // zero ecx before using cl & cx in loop below
3105             sub edx, bpp        // Set edx = ebx - bpp
3106 dpthdlp:
3107             xor eax, eax
3108             // pav = p - a = (a + b - c) - a = b - c
3109             mov al, [esi + ebx]        // load Prior(x) into al
3110             mov cl, [esi + edx]        // load Prior(x-bpp) into cl
3111             sub eax, ecx                 // subtract Prior(x-bpp)
3112             mov patemp, eax                 // Save pav for later use
3113             xor eax, eax
3114             // pbv = p - b = (a + b - c) - b = a - c
3115             mov al, [edi + edx]        // load Raw(x-bpp) into al
3116             sub eax, ecx                 // subtract Prior(x-bpp)
3117             mov ecx, eax
3118             // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
3119             add eax, patemp                 // pcv = pav + pbv
3120             // pc = abs(pcv)
3121             test eax, 0x80000000
3122             jz dpthdpca
3123             neg eax                     // reverse sign of neg values
3124 dpthdpca:
3125             mov pctemp, eax             // save pc for later use
3126             // pb = abs(pbv)
3127             test ecx, 0x80000000
3128             jz dpthdpba
3129             neg ecx                     // reverse sign of neg values
3130 dpthdpba:
3131             mov pbtemp, ecx             // save pb for later use
3132             // pa = abs(pav)
3133             mov eax, patemp
3134             test eax, 0x80000000
3135             jz dpthdpaa
3136             neg eax                     // reverse sign of neg values
3137 dpthdpaa:
3138             mov patemp, eax             // save pa for later use
3139             // test if pa <= pb
3140             cmp eax, ecx
3141             jna dpthdabb
3142             // pa > pb; now test if pb <= pc
3143             cmp ecx, pctemp
3144             jna dpthdbbc
3145             // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
3146             mov cl, [esi + edx]  // load Prior(x-bpp) into cl
3147             jmp dpthdpaeth
3148 dpthdbbc:
3149             // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
3150             mov cl, [esi + ebx]        // load Prior(x) into cl
3151             jmp dpthdpaeth
3152 dpthdabb:
3153             // pa <= pb; now test if pa <= pc
3154             cmp eax, pctemp
3155             jna dpthdabc
3156             // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
3157             mov cl, [esi + edx]  // load Prior(x-bpp) into cl
3158             jmp dpthdpaeth
3159 dpthdabc:
3160             // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
3161             mov cl, [edi + edx]  // load Raw(x-bpp) into cl
3162 dpthdpaeth:
3163             inc ebx
3164             inc edx
3165             // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
3166             add [edi + ebx - 1], cl
3167             cmp ebx, FullLength
3168             jb dpthdlp
3169 dpthdend:
3170          } // end _asm block
3171       }
3172       return;                   // No need to go further with this one
3173    }                         // end switch ( bpp )
3174    _asm
3175    {
3176          // MMX acceleration complete now do clean-up
3177          // Check if any remaining bytes left to decode
3178          mov ebx, MMXLength
3179          cmp ebx, FullLength
3180          jnb dpthend
3181          mov edi, row
3182          mov esi, prev_row
3183          // Do Paeth decode for remaining bytes
3184          mov edx, ebx
3185          xor ecx, ecx         // zero ecx before using cl & cx in loop below
3186          sub edx, bpp         // Set edx = ebx - bpp
3187 dpthlp2:
3188          xor eax, eax
3189          // pav = p - a = (a + b - c) - a = b - c
3190          mov al, [esi + ebx]  // load Prior(x) into al
3191          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
3192          sub eax, ecx         // subtract Prior(x-bpp)
3193          mov patemp, eax      // Save pav for later use
3194          xor eax, eax
3195          // pbv = p - b = (a + b - c) - b = a - c
3196          mov al, [edi + edx]  // load Raw(x-bpp) into al
3197          sub eax, ecx         // subtract Prior(x-bpp)
3198          mov ecx, eax
3199          // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
3200          add eax, patemp      // pcv = pav + pbv
3201          // pc = abs(pcv)
3202          test eax, 0x80000000
3203          jz dpthpca2
3204          neg eax              // reverse sign of neg values
3205 dpthpca2:
3206          mov pctemp, eax      // save pc for later use
3207          // pb = abs(pbv)
3208          test ecx, 0x80000000
3209          jz dpthpba2
3210          neg ecx              // reverse sign of neg values
3211 dpthpba2:
3212          mov pbtemp, ecx      // save pb for later use
3213          // pa = abs(pav)
3214          mov eax, patemp
3215          test eax, 0x80000000
3216          jz dpthpaa2
3217          neg eax              // reverse sign of neg values
3218 dpthpaa2:
3219          mov patemp, eax      // save pa for later use
3220          // test if pa <= pb
3221          cmp eax, ecx
3222          jna dpthabb2
3223          // pa > pb; now test if pb <= pc
3224          cmp ecx, pctemp
3225          jna dpthbbc2
3226          // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
3227          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
3228          jmp dpthpaeth2
3229 dpthbbc2:
3230          // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
3231          mov cl, [esi + ebx]        // load Prior(x) into cl
3232          jmp dpthpaeth2
3233 dpthabb2:
3234          // pa <= pb; now test if pa <= pc
3235          cmp eax, pctemp
3236          jna dpthabc2
3237          // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
3238          mov cl, [esi + edx]  // load Prior(x-bpp) into cl
3239          jmp dpthpaeth2
3240 dpthabc2:
3241          // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
3242          mov cl, [edi + edx]  // load Raw(x-bpp) into cl
3243 dpthpaeth2:
3244          inc ebx
3245          inc edx
3246          // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
3247          add [edi + ebx - 1], cl
3248          cmp ebx, FullLength
3249          jb dpthlp2
3250 dpthend:
3251          emms             // End MMX instructions; prep for possible FP instrs.
3252    } // end _asm block
3253 }
3254
3255 // Optimized code for PNG Sub filter decoder
3256 void /* PRIVATE */
3257 png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)
3258 {
3259    //int test;
3260    int bpp;
3261    png_uint_32 FullLength;
3262    png_uint_32 MMXLength;
3263    int diff;
3264
3265    bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
3266    FullLength  = row_info->rowbytes - bpp; // # of bytes to filter
3267    _asm {
3268         mov edi, row
3269         mov esi, edi               // lp = row
3270         add edi, bpp               // rp = row + bpp
3271         xor eax, eax
3272         // get # of bytes to alignment
3273         mov diff, edi               // take start of row
3274         add diff, 0xf               // add 7 + 8 to incr past
3275                                         // alignment boundary
3276         xor ebx, ebx
3277         and diff, 0xfffffff8        // mask to alignment boundary
3278         sub diff, edi               // subtract from start ==> value
3279                                         //  ebx at alignment
3280         jz dsubgo
3281         // fix alignment
3282 dsublp1:
3283         mov al, [esi+ebx]
3284         add [edi+ebx], al
3285         inc ebx
3286         cmp ebx, diff
3287         jb dsublp1
3288 dsubgo:
3289         mov ecx, FullLength
3290         mov edx, ecx
3291         sub edx, ebx                  // subtract alignment fix
3292         and edx, 0x00000007           // calc bytes over mult of 8
3293         sub ecx, edx                  // drop over bytes from length
3294         mov MMXLength, ecx
3295    } // end _asm block
3296
3297    // Now do the math for the rest of the row
3298    switch ( bpp )
3299    {
3300         case 3:
3301         {
3302          ActiveMask.use  = 0x0000ffffff000000;
3303          ShiftBpp.use = 24;       // == 3 * 8
3304          ShiftRem.use  = 40;      // == 64 - 24
3305          _asm {
3306             mov edi, row
3307             movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group
3308             mov esi, edi              // lp = row
3309             add edi, bpp          // rp = row + bpp
3310             movq mm6, mm7
3311             mov ebx, diff
3312             psllq mm6, ShiftBpp   // Move mask in mm6 to cover 3rd active
3313                                   // byte group
3314             // PRIME the pump (load the first Raw(x-bpp) data set
3315             movq mm1, [edi+ebx-8]
3316 dsub3lp:
3317             psrlq mm1, ShiftRem   // Shift data for adding 1st bpp bytes
3318                           // no need for mask; shift clears inactive bytes
3319             // Add 1st active group
3320             movq mm0, [edi+ebx]
3321             paddb mm0, mm1
3322             // Add 2nd active group
3323             movq mm1, mm0         // mov updated Raws to mm1
3324             psllq mm1, ShiftBpp   // shift data to position correctly
3325             pand mm1, mm7         // mask to use only 2nd active group
3326             paddb mm0, mm1
3327             // Add 3rd active group
3328             movq mm1, mm0         // mov updated Raws to mm1
3329             psllq mm1, ShiftBpp   // shift data to position correctly
3330             pand mm1, mm6         // mask to use only 3rd active group
3331             add ebx, 8
3332             paddb mm0, mm1
3333             cmp ebx, MMXLength
3334             movq [edi+ebx-8], mm0     // Write updated Raws back to array
3335             // Prep for doing 1st add at top of loop
3336             movq mm1, mm0
3337             jb dsub3lp
3338          } // end _asm block
3339       }
3340       break;
3341
3342       case 1:
3343       {
3344          // Placed here just in case this is a duplicate of the
3345          // non-MMX code for the SUB filter in png_read_filter_row below
3346          //
3347          //         png_bytep rp;
3348          //         png_bytep lp;
3349          //         png_uint_32 i;
3350          //         bpp = (row_info->pixel_depth + 7) >> 3;
3351          //         for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
3352          //            i < row_info->rowbytes; i++, rp++, lp++)
3353          //      {
3354          //            *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);
3355          //      }
3356          _asm {
3357             mov ebx, diff
3358             mov edi, row
3359             cmp ebx, FullLength
3360             jnb dsub1end
3361             mov esi, edi          // lp = row
3362             xor eax, eax
3363             add edi, bpp      // rp = row + bpp
3364 dsub1lp:
3365             mov al, [esi+ebx]
3366             add [edi+ebx], al
3367             inc ebx
3368             cmp ebx, FullLength
3369             jb dsub1lp
3370 dsub1end:
3371          } // end _asm block
3372       }
3373       return;
3374
3375       case 6:
3376       case 7:
3377       case 4:
3378       case 5:
3379       {
3380          ShiftBpp.use = bpp << 3;
3381          ShiftRem.use = 64 - ShiftBpp.use;
3382          _asm {
3383             mov edi, row
3384             mov ebx, diff
3385             mov esi, edi               // lp = row
3386             add edi, bpp           // rp = row + bpp
3387             // PRIME the pump (load the first Raw(x-bpp) data set
3388             movq mm1, [edi+ebx-8]
3389 dsub4lp:
3390             psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes
3391                           // no need for mask; shift clears inactive bytes
3392             movq mm0, [edi+ebx]
3393             paddb mm0, mm1
3394             // Add 2nd active group
3395             movq mm1, mm0          // mov updated Raws to mm1
3396             psllq mm1, ShiftBpp    // shift data to position correctly
3397                                    // there is no need for any mask
3398                                    // since shift clears inactive bits/bytes
3399             add ebx, 8
3400             paddb mm0, mm1
3401             cmp ebx, MMXLength
3402             movq [edi+ebx-8], mm0
3403             movq mm1, mm0          // Prep for doing 1st add at top of loop
3404             jb dsub4lp
3405          } // end _asm block
3406       }
3407       break;
3408
3409       case 2:
3410       {
3411          ActiveMask.use  = 0x00000000ffff0000;
3412          ShiftBpp.use = 16;       // == 2 * 8
3413          ShiftRem.use = 48;       // == 64 - 16
3414          _asm {
3415             movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group
3416             mov ebx, diff
3417             movq mm6, mm7
3418             mov edi, row
3419             psllq mm6, ShiftBpp     // Move mask in mm6 to cover 3rd active
3420                                     //  byte group
3421             mov esi, edi            // lp = row
3422             movq mm5, mm6
3423             add edi, bpp            // rp = row + bpp
3424             psllq mm5, ShiftBpp     // Move mask in mm5 to cover 4th active
3425                                     //  byte group
3426             // PRIME the pump (load the first Raw(x-bpp) data set
3427             movq mm1, [edi+ebx-8]
3428 dsub2lp:
3429             // Add 1st active group
3430             psrlq mm1, ShiftRem     // Shift data for adding 1st bpp bytes
3431                                     // no need for mask; shift clears inactive
3432                                     //  bytes
3433             movq mm0, [edi+ebx]
3434             paddb mm0, mm1
3435             // Add 2nd active group
3436             movq mm1, mm0           // mov updated Raws to mm1
3437             psllq mm1, ShiftBpp     // shift data to position correctly
3438             pand mm1, mm7           // mask to use only 2nd active group
3439             paddb mm0, mm1
3440             // Add 3rd active group
3441             movq mm1, mm0           // mov updated Raws to mm1
3442             psllq mm1, ShiftBpp     // shift data to position correctly
3443             pand mm1, mm6           // mask to use only 3rd active group
3444             paddb mm0, mm1
3445             // Add 4th active group
3446             movq mm1, mm0           // mov updated Raws to mm1
3447             psllq mm1, ShiftBpp     // shift data to position correctly
3448             pand mm1, mm5           // mask to use only 4th active group
3449             add ebx, 8
3450             paddb mm0, mm1
3451             cmp ebx, MMXLength
3452             movq [edi+ebx-8], mm0   // Write updated Raws back to array
3453             movq mm1, mm0           // Prep for doing 1st add at top of loop
3454             jb dsub2lp
3455          } // end _asm block
3456       }
3457       break;
3458       case 8:
3459       {
3460          _asm {
3461             mov edi, row
3462             mov ebx, diff
3463             mov esi, edi            // lp = row
3464             add edi, bpp            // rp = row + bpp
3465             mov ecx, MMXLength
3466             movq mm7, [edi+ebx-8]   // PRIME the pump (load the first
3467                                     // Raw(x-bpp) data set
3468             and ecx, 0x0000003f     // calc bytes over mult of 64
3469 dsub8lp:
3470             movq mm0, [edi+ebx]     // Load Sub(x) for 1st 8 bytes
3471             paddb mm0, mm7
3472             movq mm1, [edi+ebx+8]   // Load Sub(x) for 2nd 8 bytes
3473             movq [edi+ebx], mm0    // Write Raw(x) for 1st 8 bytes
3474                                    // Now mm0 will be used as Raw(x-bpp) for
3475                                    // the 2nd group of 8 bytes.  This will be
3476                                    // repeated for each group of 8 bytes with
3477                                    // the 8th group being used as the Raw(x-bpp)
3478                                    // for the 1st group of the next loop.
3479             paddb mm1, mm0
3480             movq mm2, [edi+ebx+16]  // Load Sub(x) for 3rd 8 bytes
3481             movq [edi+ebx+8], mm1   // Write Raw(x) for 2nd 8 bytes
3482             paddb mm2, mm1
3483             movq mm3, [edi+ebx+24]  // Load Sub(x) for 4th 8 bytes
3484             movq [edi+ebx+16], mm2  // Write Raw(x) for 3rd 8 bytes
3485             paddb mm3, mm2
3486             movq mm4, [edi+ebx+32]  // Load Sub(x) for 5th 8 bytes
3487             movq [edi+ebx+24], mm3  // Write Raw(x) for 4th 8 bytes
3488             paddb mm4, mm3
3489             movq mm5, [edi+ebx+40]  // Load Sub(x) for 6th 8 bytes
3490             movq [edi+ebx+32], mm4  // Write Raw(x) for 5th 8 bytes
3491             paddb mm5, mm4
3492             movq mm6, [edi+ebx+48]  // Load Sub(x) for 7th 8 bytes
3493             movq [edi+ebx+40], mm5  // Write Raw(x) for 6th 8 bytes
3494             paddb mm6, mm5
3495             movq mm7, [edi+ebx+56]  // Load Sub(x) for 8th 8 bytes
3496             movq [edi+ebx+48], mm6  // Write Raw(x) for 7th 8 bytes
3497             add ebx, 64
3498             paddb mm7, mm6
3499             cmp ebx, ecx
3500             movq [edi+ebx-8], mm7   // Write Raw(x) for 8th 8 bytes
3501             jb dsub8lp
3502             cmp ebx, MMXLength
3503             jnb dsub8lt8
3504 dsub8lpA:
3505             movq mm0, [edi+ebx]
3506             add ebx, 8
3507             paddb mm0, mm7
3508             cmp ebx, MMXLength
3509             movq [edi+ebx-8], mm0   // use -8 to offset early add to ebx
3510             movq mm7, mm0           // Move calculated Raw(x) data to mm1 to
3511                                     // be the new Raw(x-bpp) for the next loop
3512             jb dsub8lpA
3513 dsub8lt8:
3514          } // end _asm block
3515       }
3516       break;
3517
3518       default:                // bpp greater than 8 bytes
3519       {
3520          _asm {
3521             mov ebx, diff
3522             mov edi, row
3523             mov esi, edi           // lp = row
3524             add edi, bpp           // rp = row + bpp
3525 dsubAlp:
3526             movq mm0, [edi+ebx]
3527             movq mm1, [esi+ebx]
3528             add ebx, 8
3529             paddb mm0, mm1
3530             cmp ebx, MMXLength
3531             movq [edi+ebx-8], mm0  // mov does not affect flags; -8 to offset
3532                                    //  add ebx
3533             jb dsubAlp
3534          } // end _asm block
3535       }
3536       break;
3537
3538    } // end switch ( bpp )
3539
3540    _asm {
3541         mov ebx, MMXLength
3542         mov edi, row
3543         cmp ebx, FullLength
3544         jnb dsubend
3545         mov esi, edi               // lp = row
3546         xor eax, eax
3547         add edi, bpp               // rp = row + bpp
3548 dsublp2:
3549         mov al, [esi+ebx]
3550         add [edi+ebx], al
3551         inc ebx
3552         cmp ebx, FullLength
3553         jb dsublp2
3554 dsubend:
3555         emms             // End MMX instructions; prep for possible FP instrs.
3556    } // end _asm block
3557 }
3558
3559 // Optimized code for PNG Up filter decoder
3560 void /* PRIVATE */
3561 png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
3562    png_bytep prev_row)
3563 {
3564    png_uint_32 len;
3565    len  = row_info->rowbytes;       // # of bytes to filter
3566    _asm {
3567       mov edi, row
3568       // get # of bytes to alignment
3569       mov ecx, edi
3570       xor ebx, ebx
3571       add ecx, 0x7
3572       xor eax, eax
3573       and ecx, 0xfffffff8
3574       mov esi, prev_row
3575       sub ecx, edi
3576       jz dupgo
3577       // fix alignment
3578 duplp1:
3579       mov al, [edi+ebx]
3580       add al, [esi+ebx]
3581       inc ebx
3582       cmp ebx, ecx
3583       mov [edi + ebx-1], al  // mov does not affect flags; -1 to offset inc ebx
3584       jb duplp1
3585 dupgo:
3586       mov ecx, len
3587       mov edx, ecx
3588       sub edx, ebx                  // subtract alignment fix
3589       and edx, 0x0000003f           // calc bytes over mult of 64
3590       sub ecx, edx                  // drop over bytes from length
3591       // Unrolled loop - use all MMX registers and interleave to reduce
3592       // number of branch instructions (loops) and reduce partial stalls
3593 duploop:
3594       movq mm1, [esi+ebx]
3595       movq mm0, [edi+ebx]
3596       movq mm3, [esi+ebx+8]
3597       paddb mm0, mm1
3598       movq mm2, [edi+ebx+8]
3599       movq [edi+ebx], mm0
3600       paddb mm2, mm3
3601       movq mm5, [esi+ebx+16]
3602       movq [edi+ebx+8], mm2
3603       movq mm4, [edi+ebx+16]
3604       movq mm7, [esi+ebx+24]
3605       paddb mm4, mm5
3606       movq mm6, [edi+ebx+24]
3607       movq [edi+ebx+16], mm4
3608       paddb mm6, mm7
3609       movq mm1, [esi+ebx+32]
3610       movq [edi+ebx+24], mm6
3611       movq mm0, [edi+ebx+32]
3612       movq mm3, [esi+ebx+40]
3613       paddb mm0, mm1
3614       movq mm2, [edi+ebx+40]
3615       movq [edi+ebx+32], mm0
3616       paddb mm2, mm3
3617       movq mm5, [esi+ebx+48]
3618       movq [edi+ebx+40], mm2
3619       movq mm4, [edi+ebx+48]
3620       movq mm7, [esi+ebx+56]
3621       paddb mm4, mm5
3622       movq mm6, [edi+ebx+56]
3623       movq [edi+ebx+48], mm4
3624       add ebx, 64
3625       paddb mm6, mm7
3626       cmp ebx, ecx
3627       movq [edi+ebx-8], mm6 // (+56)movq does not affect flags;
3628                                      // -8 to offset add ebx
3629       jb duploop
3630
3631       cmp edx, 0                     // Test for bytes over mult of 64
3632       jz dupend
3633
3634
3635       // 2 lines added by lcreeve at netins.net
3636       // (mail 11 Jul 98 in png-implement list)
3637       cmp edx, 8 //test for less than 8 bytes
3638       jb duplt8
3639
3640
3641       add ecx, edx
3642       and edx, 0x00000007           // calc bytes over mult of 8
3643       sub ecx, edx                  // drop over bytes from length
3644       jz duplt8
3645       // Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously
3646 duplpA:
3647       movq mm1, [esi+ebx]
3648       movq mm0, [edi+ebx]
3649       add ebx, 8
3650       paddb mm0, mm1
3651       cmp ebx, ecx
3652       movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx
3653       jb duplpA
3654       cmp edx, 0            // Test for bytes over mult of 8
3655       jz dupend
3656 duplt8:
3657       xor eax, eax
3658       add ecx, edx          // move over byte count into counter
3659       // Loop using x86 registers to update remaining bytes
3660 duplp2:
3661       mov al, [edi + ebx]
3662       add al, [esi + ebx]
3663       inc ebx
3664       cmp ebx, ecx
3665       mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx
3666       jb duplp2
3667 dupend:
3668       // Conversion of filtered row completed
3669       emms          // End MMX instructions; prep for possible FP instrs.
3670    } // end _asm block
3671 }
3672
3673
3674 // Optimized png_read_filter_row routines
3675 void /* PRIVATE */
3676 png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
3677    row, png_bytep prev_row, int filter)
3678 {
3679 #ifdef PNG_DEBUG
3680    char filnm[10];
3681 #endif
3682
3683    if (mmx_supported == 2) {
3684 #if !defined(PNG_1_0_X)
3685        /* this should have happened in png_init_mmx_flags() already */
3686        png_warning(png_ptr, "asm_flags may not have been initialized");
3687 #endif
3688        png_mmx_support();
3689    }
3690
3691 #ifdef PNG_DEBUG
3692    png_debug(1, "in png_read_filter_row\n");
3693    switch (filter)
3694    {
3695       case 0: sprintf(filnm, "none");
3696          break;
3697 #if !defined(PNG_1_0_X)
3698       case 1: sprintf(filnm, "sub-%s",
3699         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86");
3700          break;
3701       case 2: sprintf(filnm, "up-%s",
3702         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86");
3703          break;
3704       case 3: sprintf(filnm, "avg-%s",
3705         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86");
3706          break;
3707       case 4: sprintf(filnm, "Paeth-%s",
3708         (png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86");
3709          break;
3710 #else
3711       case 1: sprintf(filnm, "sub");
3712          break;
3713       case 2: sprintf(filnm, "up");
3714          break;
3715       case 3: sprintf(filnm, "avg");
3716          break;
3717       case 4: sprintf(filnm, "Paeth");
3718          break;
3719 #endif
3720       default: sprintf(filnm, "unknw");
3721          break;
3722    }
3723    png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm);
3724    png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth,
3725       (int)((row_info->pixel_depth + 7) >> 3));
3726    png_debug1(0,"len=%8d, ", row_info->rowbytes);
3727 #endif /* PNG_DEBUG */
3728
3729    switch (filter)
3730    {
3731       case PNG_FILTER_VALUE_NONE:
3732          break;
3733
3734       case PNG_FILTER_VALUE_SUB:
3735       {
3736 #if !defined(PNG_1_0_X)
3737          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) &&
3738              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
3739              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
3740 #else
3741          if (mmx_supported)
3742 #endif
3743          {
3744             png_read_filter_row_mmx_sub(row_info, row);
3745          }
3746          else
3747          {
3748             png_uint_32 i;
3749             png_uint_32 istop = row_info->rowbytes;
3750             png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
3751             png_bytep rp = row + bpp;
3752             png_bytep lp = row;
3753
3754             for (i = bpp; i < istop; i++)
3755             {
3756                *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);
3757                rp++;
3758             }
3759          }
3760          break;
3761       }
3762
3763       case PNG_FILTER_VALUE_UP:
3764       {
3765 #if !defined(PNG_1_0_X)
3766          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) &&
3767              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
3768              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
3769 #else
3770          if (mmx_supported)
3771 #endif
3772          {
3773             png_read_filter_row_mmx_up(row_info, row, prev_row);
3774          }
3775          else
3776          {
3777             png_uint_32 i;
3778             png_uint_32 istop = row_info->rowbytes;
3779             png_bytep rp = row;
3780             png_bytep pp = prev_row;
3781
3782             for (i = 0; i < istop; ++i)
3783             {
3784                *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
3785                rp++;
3786             }
3787          }
3788          break;
3789       }
3790
3791       case PNG_FILTER_VALUE_AVG:
3792       {
3793 #if !defined(PNG_1_0_X)
3794          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) &&
3795              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
3796              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
3797 #else
3798          if (mmx_supported)
3799 #endif
3800          {
3801             png_read_filter_row_mmx_avg(row_info, row, prev_row);
3802          }
3803          else
3804          {
3805             png_uint_32 i;
3806             png_bytep rp = row;
3807             png_bytep pp = prev_row;
3808             png_bytep lp = row;
3809             png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
3810             png_uint_32 istop = row_info->rowbytes - bpp;
3811
3812             for (i = 0; i < bpp; i++)
3813             {
3814                *rp = (png_byte)(((int)(*rp) +
3815                   ((int)(*pp++) >> 1)) & 0xff);
3816                rp++;
3817             }
3818
3819             for (i = 0; i < istop; i++)
3820             {
3821                *rp = (png_byte)(((int)(*rp) +
3822                   ((int)(*pp++ + *lp++) >> 1)) & 0xff);
3823                rp++;
3824             }
3825          }
3826          break;
3827       }
3828
3829       case PNG_FILTER_VALUE_PAETH:
3830       {
3831 #if !defined(PNG_1_0_X)
3832          if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) &&
3833              (row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) &&
3834              (row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold))
3835 #else
3836          if (mmx_supported)
3837 #endif
3838          {
3839             png_read_filter_row_mmx_paeth(row_info, row, prev_row);
3840          }
3841          else
3842          {
3843             png_uint_32 i;
3844             png_bytep rp = row;
3845             png_bytep pp = prev_row;
3846             png_bytep lp = row;
3847             png_bytep cp = prev_row;
3848             png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;
3849             png_uint_32 istop=row_info->rowbytes - bpp;
3850
3851             for (i = 0; i < bpp; i++)
3852             {
3853                *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
3854                rp++;
3855             }
3856
3857             for (i = 0; i < istop; i++)   // use leftover rp,pp
3858             {
3859                int a, b, c, pa, pb, pc, p;
3860
3861                a = *lp++;
3862                b = *pp++;
3863                c = *cp++;
3864
3865                p = b - c;
3866                pc = a - c;
3867
3868 #ifdef PNG_USE_ABS
3869                pa = abs(p);
3870                pb = abs(pc);
3871                pc = abs(p + pc);
3872 #else
3873                pa = p < 0 ? -p : p;
3874                pb = pc < 0 ? -pc : pc;
3875                pc = (p + pc) < 0 ? -(p + pc) : p + pc;
3876 #endif
3877
3878                /*
3879                   if (pa <= pb && pa <= pc)
3880                      p = a;
3881                   else if (pb <= pc)
3882                      p = b;
3883                   else
3884                      p = c;
3885                 */
3886
3887                p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
3888
3889                *rp = (png_byte)(((int)(*rp) + p) & 0xff);
3890                rp++;
3891             }
3892          }
3893          break;
3894       }
3895
3896       default:
3897          png_warning(png_ptr, "Ignoring bad row filter type");
3898          *row=0;
3899          break;
3900    }
3901 }
3902
3903 #endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */