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