/* pngvcrd.c - assembler version of utilities to read a PNG file
 *
 * For Intel CPU and Microsoft Visual C++ compiler
 *
 * libpng 1.0.4 - September 17, 1999
 * For conditions of distribution and use, see copyright notice in png.h
 * Copyright (c) 1998, Intel Corporation
 * Copyright (c) 1998, 1999 Glenn Randers-Pehrson
 *
 * Contributed by Nirav Chhatrapati, INTEL Corporation, 1998
 * Interface to libpng contributed by Gilles Vollant, 1999
 *
 */

#define PNG_INTERNAL
#include "png.h"

#ifdef PNG_ASSEMBLER_CODE_SUPPORTED

static int mmx_supported=2;

void
png_read_filter_row_c(png_structp png_ptr, png_row_infop row_info,
   png_bytep row, png_bytep prev_row, int filter);

static int mmxsupport()
{
  int mmx_supported_local = 0;

  _asm {
    pushfd            //Save Eflag to stack
    pop eax           //Get Eflag from stack into eax
    mov ecx, eax      //Make another copy of Eflag in ecx
    xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)]
    push eax          //Save modified Eflag back to stack

    popfd             //Restored modified value back to Eflag reg
    pushfd            //Save Eflag to stack
    pop eax           //Get Eflag from stack
    xor eax, ecx      //Compare the new Eflag with the original Eflag
    jz NOT_SUPPORTED  //If the same, CPUID instruction is not supported,
                      //skip following instructions and jump to
                      //NOT_SUPPORTED label

    xor eax, eax      //Set eax to zero

    _asm _emit 0x0f   //CPUID instruction  (two bytes opcode)
    _asm _emit 0xa2

    cmp eax, 1        //make sure eax return non-zero value
    jl NOT_SUPPORTED  //If eax is zero, mmx not supported

    xor eax, eax      //set eax to zero
    inc eax           //Now increment eax to 1.  This instruction is
                      //faster than the instruction "mov eax, 1"

    _asm _emit 0x0f   //CPUID instruction
    _asm _emit 0xa2

    and edx, 0x00800000  //mask out all bits but mmx bit(24)
    cmp edx, 0        // 0 = mmx not supported
    jz  NOT_SUPPORTED // non-zero = Yes, mmx IS supported

    mov  mmx_supported_local, 1  //set return value to 1

NOT_SUPPORTED:
    mov  eax, mmx_supported_local  //move return value to eax

  }

//mmx_supported_local=0; // test code for force don't support MMX
    //printf("MMX : %u (1=MMX supported)\n",mmx_supported_local);

  return mmx_supported_local;
}

/* Combines the row recently read in with the previous row.
   This routine takes care of alpha and transparency if requested.
   This routine also handles the two methods of progressive display
   of interlaced images, depending on the mask value.
   The mask value describes which pixels are to be combined with
   the row.  The pattern always repeats every 8 pixels, so just 8
   bits are needed.  A one indicates the pixels is to be combined,
   a zero indicates the pixel is to be skipped.  This is in addition
   to any alpha or transparency value associated with the pixel.  If
   you want all pixels to be combined, pass 0xff (255) in mask.  */

/* Use this routine for X86 platform - uses faster MMX routine if machine
supports MMX */

void
png_combine_row(png_structp png_ptr, png_bytep row,
   int mask)
{
   //int mmx_supported=0; // another test code for remove MMX in this routine
   png_debug(1,"in png_combine_row_asm\n");
   //if (mmx_supported==2)
   //    mmx_supported=mmxsupport();

   if (mask == 0xff)
   {
      png_memcpy(row, png_ptr->row_buf + 1,
   (png_size_t)((png_ptr->width *
   png_ptr->row_info.pixel_depth + 7) >> 3));
   }
   else
   {
    switch (png_ptr->row_info.pixel_depth)
      {
   case 1:
   {
      png_bytep sp;
      png_bytep dp;
      int s_inc, s_start, s_end;
      int m;
      int shift;
      png_uint_32 i;

      sp = png_ptr->row_buf + 1;
      dp = row;
      m = 0x80;
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
      if (png_ptr->transformations & PNG_PACKSWAP)
      {
    s_start = 0;
    s_end = 7;
    s_inc = 1;
      }
      else
#endif
      {
    s_start = 7;
    s_end = 0;
    s_inc = -1;
      }

      shift = s_start;

      for (i = 0; i < png_ptr->width; i++)
      {
         if (m & mask)
         {
      int value;

      value = (*sp >> shift) & 0x1;
      *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);
      *dp |= (png_byte)(value << shift);
         }

         if (shift == s_end)
         {
      shift = s_start;
      sp++;
      dp++;
         }
         else
      shift += s_inc;

         if (m == 1)
      m = 0x80;
         else
      m >>= 1;
      }
      break;
   }
   case 2:
   {
      png_bytep sp;
      png_bytep dp;
      int s_start, s_end, s_inc;
      int m;
      int shift;
      png_uint_32 i;
      int value;

      sp = png_ptr->row_buf + 1;
      dp = row;
      m = 0x80;
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
      if (png_ptr->transformations & PNG_PACKSWAP)
      {
         s_start = 0;
         s_end = 6;
         s_inc = 2;
      }
      else
#endif
      {
         s_start = 6;
         s_end = 0;
         s_inc = -2;
      }

      shift = s_start;

      for (i = 0; i < png_ptr->width; i++)
      {
         if (m & mask)
         {
      value = (*sp >> shift) & 0x3;
      *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);
      *dp |= (png_byte)(value << shift);
         }

         if (shift == s_end)
         {
      shift = s_start;
      sp++;
      dp++;
         }
         else
      shift += s_inc;
         if (m == 1)
      m = 0x80;
         else
      m >>= 1;
      }
      break;
   }
   case 4:
   {
      png_bytep sp;
      png_bytep dp;
      int s_start, s_end, s_inc;
      int m;
      int shift;
      png_uint_32 i;
      int value;

      sp = png_ptr->row_buf + 1;
      dp = row;
      m = 0x80;
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
      if (png_ptr->transformations & PNG_PACKSWAP)
      {
         s_start = 0;
         s_end = 4;
         s_inc = 4;
      }
      else
#endif
      {
         s_start = 4;
         s_end = 0;
         s_inc = -4;
      }
      shift = s_start;

      for (i = 0; i < png_ptr->width; i++)
      {
         if (m & mask)
         {
      value = (*sp >> shift) & 0xf;
      *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);
      *dp |= (png_byte)(value << shift);
         }

         if (shift == s_end)
         {
      shift = s_start;
      sp++;
      dp++;
         }
         else
      shift += s_inc;
         if (m == 1)
      m = 0x80;
         else
      m >>= 1;
      }
      break;
   }
     case 8:
        {
        png_bytep srcptr;
        png_bytep dstptr;
        png_uint_32 len;
        int m;
        int diff, unmask;

        __int64 mask0=0x0102040810204080;

        if (mmx_supported)
        {
        srcptr = png_ptr->row_buf + 1;
        dstptr = row;
        m = 0x80;
        unmask = ~mask;
        len  = png_ptr->width &~7;  //reduce to multiple of 8
        diff = png_ptr->width & 7;  //amount lost
        _asm {
          movd    mm7, unmask        //load bit pattern
          psubb   mm6,mm6            //zero mm6
          punpcklbw mm7,mm7
          punpcklwd mm7,mm7
          punpckldq mm7,mm7          //fill register with 8 masks

          movq    mm0,mask0

          pand    mm0,mm7            //nonzero if keep byte
          pcmpeqb mm0,mm6            //zeros->1s, v versa

          mov             ecx,len    //load length of line
          mov             esi,srcptr //load source
          mov             ebx,dstptr //load dest
               cmp   ecx,0 //lcr
               je    mainloop8end

mainloop8:
          movq    mm4,[esi]
          pand    mm4,mm0
          movq    mm6,mm0
          pandn   mm6,[ebx]
          por             mm4,mm6
          movq    [ebx],mm4

          add             esi,8       //inc by 8 bytes processed
          add             ebx,8
          sub             ecx,8       //dec by 8 pixels processed

          ja              mainloop8
mainloop8end:

          mov             ecx,diff
          cmp             ecx,0
          jz              end8

          mov             edx,mask
          sal             edx,24      //make low byte the high byte

secondloop8:
          sal             edx,1       //move high bit to CF
          jnc             skip8       //if CF = 0
          mov             al,[esi]
          mov             [ebx],al
skip8:
          inc             esi
          inc             ebx

          dec             ecx
          jnz secondloop8
end8:
          emms
          }
        }
        else /* mmx _not supported - Use modified C routine*/
        {
          register unsigned int incr1, initial_val, final_val;
          png_size_t pixel_bytes;
          png_uint_32 i;
          //if ((mask != 0x0f) && (mask != 0x33))
          register int disp = png_pass_inc[png_ptr->pass];
          int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
          pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
          srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
             pixel_bytes;
          dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
          initial_val = offset_table[png_ptr->pass]*pixel_bytes;
          final_val = png_ptr->width*pixel_bytes;
          incr1 = (disp)*pixel_bytes;
          for (i = initial_val; i < final_val; i += incr1)
          {
          png_memcpy(dstptr, srcptr, pixel_bytes);
          srcptr += incr1;
          dstptr += incr1;
          }
        } /* end of else */

        break;
        }       //end 8bpp

        case 16:
        {
        png_bytep srcptr;
          png_bytep dstptr;
          png_uint_32 len;
        int unmask, diff;

        __int64 mask1=0x0101020204040808,
            mask0=0x1010202040408080;

        if (mmx_supported)
        {
          srcptr = png_ptr->row_buf + 1;
          dstptr = row;

        unmask = ~mask;
        len     = (png_ptr->width)&~7;
        diff = (png_ptr->width)&7;
        _asm {
          movd    mm7, unmask       //load bit pattern
          psubb   mm6,mm6           //zero mm6
          punpcklbw mm7,mm7
          punpcklwd mm7,mm7
          punpckldq mm7,mm7         //fill register with 8 masks

          movq    mm0,mask0
          movq    mm1,mask1

          pand    mm0,mm7
          pand    mm1,mm7

          pcmpeqb mm0,mm6
          pcmpeqb mm1,mm6

          mov             ecx,len    //load length of line
          mov             esi,srcptr //load source
          mov             ebx,dstptr //load dest
               cmp   ecx,0 //lcr
               jz    mainloop16end

mainloop16:
          movq    mm4,[esi]
          pand    mm4,mm0
          movq    mm6,mm0
          movq    mm7,[ebx]
          pandn   mm6,mm7
          por             mm4,mm6
          movq    [ebx],mm4

          movq    mm5,[esi+8]
          pand    mm5,mm1
          movq    mm7,mm1
          movq    mm6,[ebx+8]
          pandn   mm7,mm6
          por             mm5,mm7
          movq    [ebx+8],mm5

          add             esi,16      //inc by 16 bytes processed
          add             ebx,16
          sub             ecx,8       //dec by 8 pixels processed

          ja              mainloop16
mainloop16end:

          mov             ecx,diff
          cmp             ecx,0
          jz              end16

          mov             edx,mask
          sal             edx,24      //make low byte the high byte

secondloop16:
          sal             edx,1       //move high bit to CF
          jnc             skip16      //if CF = 0
          mov             ax,[esi]
          mov             [ebx],ax
skip16:
          add             esi,2
          add             ebx,2

          dec             ecx
          jnz secondloop16

end16:
          emms
          }
        }
        else /* mmx _not supported - Use modified C routine */
        {
          register unsigned int incr1, initial_val, final_val;
          png_size_t pixel_bytes;
          png_uint_32 i;
          register int disp = png_pass_inc[png_ptr->pass];
          int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
          pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
          srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
             pixel_bytes;
          dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
          initial_val = offset_table[png_ptr->pass]*pixel_bytes;
          final_val = png_ptr->width*pixel_bytes;
          incr1 = (disp)*pixel_bytes;
          for (i = initial_val; i < final_val; i += incr1)
          {
          png_memcpy(dstptr, srcptr, pixel_bytes);
          srcptr += incr1;
          dstptr += incr1;
          }
        } /* end of else */

        break;
        }
      case 24:
        {
        png_bytep srcptr;
          png_bytep dstptr;
          png_uint_32 len;
        int unmask, diff;

        __int64 mask2=0x0101010202020404, //24bpp
            mask1=0x0408080810101020,
            mask0=0x2020404040808080;

          srcptr = png_ptr->row_buf + 1;
          dstptr = row;

        unmask = ~mask;
        len     = (png_ptr->width)&~7;
        diff = (png_ptr->width)&7;

        if (mmx_supported)
        {
        _asm {
          movd    mm7, unmask         //load bit pattern
          psubb   mm6,mm6             //zero mm6
          punpcklbw mm7,mm7
          punpcklwd mm7,mm7
          punpckldq mm7,mm7           //fill register with 8 masks

          movq    mm0,mask0
          movq    mm1,mask1
          movq    mm2,mask2


          pand    mm0,mm7
          pand    mm1,mm7
          pand    mm2,mm7

          pcmpeqb mm0,mm6
          pcmpeqb mm1,mm6
          pcmpeqb mm2,mm6

          mov             ecx,len     //load length of line
          mov             esi,srcptr  //load source
          mov             ebx,dstptr  //load dest
               cmp   ecx,0
               jz    mainloop24end

mainloop24:
          movq    mm4,[esi]
          pand    mm4,mm0
          movq    mm6,mm0
          movq    mm7,[ebx]
          pandn   mm6,mm7
          por             mm4,mm6
          movq    [ebx],mm4


          movq    mm5,[esi+8]
          pand    mm5,mm1
          movq    mm7,mm1
          movq    mm6,[ebx+8]
          pandn   mm7,mm6
          por             mm5,mm7
          movq    [ebx+8],mm5

          movq    mm6,[esi+16]
          pand    mm6,mm2
          movq    mm4,mm2
          movq    mm7,[ebx+16]
          pandn   mm4,mm7
          por             mm6,mm4
          movq    [ebx+16],mm6

          add             esi,24      //inc by 24 bytes processed
          add             ebx,24
          sub             ecx,8       //dec by 8 pixels processed

          ja              mainloop24
mainloop24end:

          mov             ecx,diff
          cmp             ecx,0
          jz              end24

          mov             edx,mask
          sal             edx,24      //make low byte the high byte

secondloop24:
          sal             edx,1       //move high bit to CF
          jnc             skip24      //if CF = 0
          mov             ax,[esi]
          mov             [ebx],ax
          xor             eax,eax
          mov             al,[esi+2]
          mov             [ebx+2],al
skip24:
          add             esi,3
          add             ebx,3

          dec             ecx
          jnz secondloop24

end24:
          emms

          }
        }
        else /* mmx _not supported - Use modified C routine */
        {
          register unsigned int incr1, initial_val, final_val;
          png_size_t pixel_bytes;
          png_uint_32 i;
          register int disp = png_pass_inc[png_ptr->pass];
          int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
          pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
          srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]
             *pixel_bytes;
          dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
          initial_val = offset_table[png_ptr->pass]*pixel_bytes;
          final_val = png_ptr->width*pixel_bytes;
          incr1 = (disp)*pixel_bytes;
          for (i = initial_val; i < final_val; i += incr1)
          {
          png_memcpy(dstptr, srcptr, pixel_bytes);
          srcptr += incr1;
          dstptr += incr1;
          }
        } /* end of else */

        break;
      }       //end 24bpp
    case 32:
      {
      png_bytep srcptr;
      png_bytep dstptr;
      png_uint_32 len;
      int unmask, diff;


      __int64 mask3=0x0101010102020202,       //32bpp
          mask2=0x0404040408080808,
          mask1=0x1010101020202020,
          mask0=0x4040404080808080;

      srcptr = png_ptr->row_buf + 1;
      dstptr = row;

      unmask = ~mask;
      len     = (png_ptr->width)&~7;
      diff = (png_ptr->width)&7;

      if (mmx_supported)
      {
      _asm {
        movd    mm7, unmask           //load bit pattern
        psubb   mm6,mm6               //zero mm6
        punpcklbw mm7,mm7
        punpcklwd mm7,mm7
        punpckldq mm7,mm7             //fill register with 8 masks

        movq    mm0,mask0
        movq    mm1,mask1
        movq    mm2,mask2
        movq    mm3,mask3


        pand    mm0,mm7
        pand    mm1,mm7
        pand    mm2,mm7
        pand    mm3,mm7

        pcmpeqb mm0,mm6
        pcmpeqb mm1,mm6
        pcmpeqb mm2,mm6
        pcmpeqb mm3,mm6

        mov             ecx,len       //load length of line
        mov             esi,srcptr    //load source
        mov             ebx,dstptr    //load dest

            cmp   ecx,0 //lcr
            jz    mainloop32end

mainloop32:
        movq    mm4,[esi]
        pand    mm4,mm0
        movq    mm6,mm0
        movq    mm7,[ebx]
        pandn   mm6,mm7
        por             mm4,mm6
        movq    [ebx],mm4


        movq    mm5,[esi+8]
        pand    mm5,mm1
        movq    mm7,mm1
        movq    mm6,[ebx+8]
        pandn   mm7,mm6
        por             mm5,mm7
        movq    [ebx+8],mm5

        movq    mm6,[esi+16]
        pand    mm6,mm2
        movq    mm4,mm2
        movq    mm7,[ebx+16]
        pandn   mm4,mm7
        por             mm6,mm4
        movq    [ebx+16],mm6

        movq    mm7,[esi+24]
        pand    mm7,mm3
        movq    mm5,mm3
        movq    mm4,[ebx+24]
        pandn   mm5,mm4
        por             mm7,mm5
        movq    [ebx+24],mm7


        add             esi,32        //inc by 32 bytes processed
        add             ebx,32
        sub             ecx,8         //dec by 8 pixels processed

        ja              mainloop32
mainloop32end:

        mov             ecx,diff
        cmp             ecx,0
        jz              end32

        mov             edx,mask
        sal             edx,24        //make low byte the high byte

secondloop32:
        sal             edx,1         //move high bit to CF
        jnc             skip32        //if CF = 0
        mov             eax,[esi]
        mov             [ebx],eax
skip32:
        add             esi,4
        add             ebx,4

        dec             ecx
        jnz secondloop32

end32:
        emms

         }
      }
      else /* mmx _not supported - Use modified C routine */
        {
          register unsigned int incr1, initial_val, final_val;
          png_size_t pixel_bytes;
          png_uint_32 i;
          register int disp = png_pass_inc[png_ptr->pass];
          int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
          pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
          srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
             pixel_bytes;
          dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
          initial_val = offset_table[png_ptr->pass]*pixel_bytes;
          final_val = png_ptr->width*pixel_bytes;
          incr1 = (disp)*pixel_bytes;
          for (i = initial_val; i < final_val; i += incr1)
          {
          png_memcpy(dstptr, srcptr, pixel_bytes);
          srcptr += incr1;
          dstptr += incr1;
          }
        } /* end of else */

      break;
      }       //end 32bpp


      case 48:
      {
      png_bytep srcptr;
      png_bytep dstptr;
      png_uint_32 len;
      int unmask, diff;

      __int64 mask5=0x0101010101010202,
          mask4=0x0202020204040404,
          mask3=0x0404080808080808,
          mask2=0x1010101010102020,
          mask1=0x2020202040404040,
          mask0=0x4040808080808080;

      if (mmx_supported)
      {

      srcptr = png_ptr->row_buf + 1;
      dstptr = row;

      unmask = ~mask;
      len     = (png_ptr->width)&~7;
      diff = (png_ptr->width)&7;
      _asm {
        movd    mm7, unmask   //load bit pattern
        psubb   mm6,mm6       //zero mm6
        punpcklbw mm7,mm7
        punpcklwd mm7,mm7
        punpckldq mm7,mm7     //fill register with 8 masks

        movq    mm0,mask0
        movq    mm1,mask1
        movq    mm2,mask2
        movq    mm3,mask3
        movq    mm4,mask4
        movq    mm5,mask5

        pand    mm0,mm7
        pand    mm1,mm7
        pand    mm2,mm7
        pand    mm3,mm7
        pand    mm4,mm7
        pand    mm5,mm7

        pcmpeqb mm0,mm6
        pcmpeqb mm1,mm6
        pcmpeqb mm2,mm6
        pcmpeqb mm3,mm6
        pcmpeqb mm4,mm6
        pcmpeqb mm5,mm6

        mov             ecx,len       //load length of line
        mov             esi,srcptr    //load source
        mov             ebx,dstptr    //load dest

            cmp   ecx,0
            jz    mainloop48end

mainloop48:
        movq    mm7,[esi]
        pand    mm7,mm0
        movq    mm6,mm0
        pandn   mm6,[ebx]
        por             mm7,mm6
        movq    [ebx],mm7


        movq    mm6,[esi+8]
        pand    mm6,mm1
        movq    mm7,mm1
        pandn   mm7,[ebx+8]
        por             mm6,mm7
        movq    [ebx+8],mm6

        movq    mm6,[esi+16]
        pand    mm6,mm2
        movq    mm7,mm2
        pandn   mm7,[ebx+16]
        por             mm6,mm7
        movq    [ebx+16],mm6

        movq    mm7,[esi+24]
        pand    mm7,mm3
        movq    mm6,mm3
        pandn   mm6,[ebx+24]
        por             mm7,mm6
        movq    [ebx+24],mm7

        movq    mm6,[esi+32]
        pand    mm6,mm4
        movq    mm7,mm4
        pandn   mm7,[ebx+32]
        por             mm6,mm7
        movq    [ebx+32],mm6

        movq    mm7,[esi+40]
        pand    mm7,mm5
        movq    mm6,mm5
        pandn   mm6,[ebx+40]
        por             mm7,mm6
        movq    [ebx+40],mm7

        add             esi,48   //inc by 32 bytes processed
        add             ebx,48
        sub             ecx,8    //dec by 8 pixels processed

        ja              mainloop48
mainloop48end:

        mov             ecx,diff
        cmp             ecx,0
        jz              end48

        mov             edx,mask
        sal             edx,24   //make low byte the high byte

secondloop48:
        sal             edx,1    //move high bit to CF
        jnc             skip48   //if CF = 0
        mov             eax,[esi]
        mov             [ebx],eax
skip48:
        add             esi,4
        add             ebx,4

        dec             ecx
        jnz secondloop48

end48:
        emms
        }
        }
        else /* mmx _not supported - Use modified C routine */
        {
          register unsigned int incr1, initial_val, final_val;
          png_size_t pixel_bytes;
          png_uint_32 i;
          register int disp = png_pass_inc[png_ptr->pass];
          int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
          pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
          srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*
             pixel_bytes;
          dstptr = row + offset_table[png_ptr->pass]*pixel_bytes;
          initial_val = offset_table[png_ptr->pass]*pixel_bytes;
          final_val = png_ptr->width*pixel_bytes;
          incr1 = (disp)*pixel_bytes;
          for (i = initial_val; i < final_val; i += incr1)
          {
          png_memcpy(dstptr, srcptr, pixel_bytes);
          srcptr += incr1;
          dstptr += incr1;
          }
        } /* end of else */
      break;  // end 48 bpp
      }
  default:
      {
      png_bytep sptr;
      png_bytep dp;
      png_size_t pixel_bytes;
      int offset_table[7] = {0, 4, 0, 2, 0, 1, 0};
      unsigned int i;
      register int disp = png_pass_inc[png_ptr->pass];   // get the offset
      register unsigned int incr1, initial_val, final_val;
      pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);
      sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]*pixel_bytes;
      dp = row + offset_table[png_ptr->pass]*pixel_bytes;
      initial_val = offset_table[png_ptr->pass]*pixel_bytes;
      final_val = png_ptr->width*pixel_bytes;
      incr1 = (disp)*pixel_bytes;
      for (i = initial_val; i < final_val; i += incr1)
      {
        png_memcpy(dp, sptr, pixel_bytes);
        sptr += incr1;
        dp += incr1;
      }

      break;
      }
    }
  }
}


#if defined(PNG_READ_INTERLACING_SUPPORTED)

void
png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
   png_uint_32 transformations)
{

   png_debug(1,"in png_do_read_interlace\n");
   if (mmx_supported==2)
       mmx_supported=mmxsupport();

   if (row != NULL && row_info != NULL)
   {
      png_uint_32 final_width;

      final_width = row_info->width * png_pass_inc[pass];

      switch (row_info->pixel_depth)
      {
   case 1:
   {
      png_bytep sp, dp;
      int sshift, dshift;
      int s_start, s_end, s_inc;
      png_byte v;
      png_uint_32 i;
      int j;

      sp = row + (png_size_t)((row_info->width - 1) >> 3);
      dp = row + (png_size_t)((final_width - 1) >> 3);
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
      if (transformations & PNG_PACKSWAP)
      {
    sshift = (int)((row_info->width + 7) & 7);
    dshift = (int)((final_width + 7) & 7);
    s_start = 7;
    s_end = 0;
    s_inc = -1;
      }
      else
#endif
      {
    sshift = 7 - (int)((row_info->width + 7) & 7);
    dshift = 7 - (int)((final_width + 7) & 7);
    s_start = 0;
    s_end = 7;
    s_inc = 1;
      }

      for (i = row_info->width; i; i--)
      {
         v = (png_byte)((*sp >> sshift) & 0x1);
         for (j = 0; j < png_pass_inc[pass]; j++)
         {
      *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);
      *dp |= (png_byte)(v << dshift);
      if (dshift == s_end)
      {
         dshift = s_start;
         dp--;
      }
      else
         dshift += s_inc;
         }
         if (sshift == s_end)
         {
      sshift = s_start;
      sp--;
         }
         else
      sshift += s_inc;
      }
      break;
   }
   case 2:
   {
      png_bytep sp, dp;
      int sshift, dshift;
      int s_start, s_end, s_inc;
      png_uint_32 i;

      sp = row + (png_size_t)((row_info->width - 1) >> 2);
      dp = row + (png_size_t)((final_width - 1) >> 2);
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
      if (transformations & PNG_PACKSWAP)
      {
         sshift = (png_size_t)(((row_info->width + 3) & 3) << 1);
         dshift = (png_size_t)(((final_width + 3) & 3) << 1);
         s_start = 6;
         s_end = 0;
         s_inc = -2;
      }
      else
#endif
      {
         sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1);
         dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1);
         s_start = 0;
         s_end = 6;
         s_inc = 2;
      }

      for (i = row_info->width; i; i--)
      {
         png_byte v;
         int j;

         v = (png_byte)((*sp >> sshift) & 0x3);
         for (j = 0; j < png_pass_inc[pass]; j++)
         {
      *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);
      *dp |= (png_byte)(v << dshift);
      if (dshift == s_end)
      {
         dshift = s_start;
         dp--;
      }
      else
         dshift += s_inc;
         }
         if (sshift == s_end)
         {
      sshift = s_start;
      sp--;
         }
         else
      sshift += s_inc;
      }
      break;
   }
   case 4:
   {
      png_bytep sp, dp;
      int sshift, dshift;
      int s_start, s_end, s_inc;
      png_uint_32 i;

      sp = row + (png_size_t)((row_info->width - 1) >> 1);
      dp = row + (png_size_t)((final_width - 1) >> 1);
#if defined(PNG_READ_PACKSWAP_SUPPORTED)
      if (transformations & PNG_PACKSWAP)
      {
         sshift = (png_size_t)(((row_info->width + 1) & 1) << 2);
         dshift = (png_size_t)(((final_width + 1) & 1) << 2);
         s_start = 4;
         s_end = 0;
         s_inc = -4;
      }
      else
#endif
      {
         sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2);
         dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2);
         s_start = 0;
         s_end = 4;
         s_inc = 4;
      }

      for (i = row_info->width; i; i--)
      {
         png_byte v;
         int j;

         v = (png_byte)((*sp >> sshift) & 0xf);
         for (j = 0; j < png_pass_inc[pass]; j++)
         {
      *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);
      *dp |= (png_byte)(v << dshift);
      if (dshift == s_end)
      {
         dshift = s_start;
         dp--;
      }
      else
         dshift += s_inc;
         }
         if (sshift == s_end)
         {
      sshift = s_start;
      sp--;
         }
         else
      sshift += s_inc;
      }
      break;
   }
   default:         // This is the place where the routine is modified
   {
      __int64 const4 = 0x0000000000FFFFFF;
      __int64 const5 = 0x000000FFFFFF0000;
      __int64 const6 = 0x00000000000000FF;
      //int mmx_supported = 1;

      png_bytep sptr, dp;
      png_uint_32 i;
      png_size_t pixel_bytes;

      int width = row_info->width;

      pixel_bytes = (row_info->pixel_depth >> 3);

      sptr = row + (row_info->width - 1) * pixel_bytes;
      dp = row + (final_width - 1) * pixel_bytes;
      // New code by Nirav Chhatrapati - Intel Corporation

      if (mmx_supported) // If machine supports MMX technology use MMX routine
      {
      if (pixel_bytes == 3)
      {
        if ((pass == 0) || (pass == 1))
        {
          _asm
          {
            mov esi, sptr

            mov edi, dp

            mov ecx, width

            sub edi, 21   // (png_pass_inc[pass] - 1)*pixel_bytes

loop_pass0:

            movd mm0, [esi]     ; X X X X X val2 val1 val0

            pand mm0, const4    ; 0 0 0 0 0 val2 val1 val0

            movq mm1, mm0       ; 0 0 0 0 0 val2 val1 val0

            psllq mm0, 16       ; 0 0 0 val2 val1 val0 0 0

            movq mm2, mm0       ; 0 0 0 val2 val1 val0 0 0

            psllq mm0, 24       ; val2 val1 val0 0 0 0 0 0

            psrlq mm1, 8        ; 0 0 0 0 0 0 val2 val1

            por mm0, mm2        ; val2 val1 val0 val2 val1 val0 0 0

            por mm0, mm1        ; val2 val1 val0 val2 val1 val0 val2 val1

            movq mm3, mm0       ; val2 val1 val0 val2 val1 val0 val2 val1

            psllq mm0, 16       ; val0 val2 val1 val0 val2 val1 0 0

            movq mm4, mm3       ; val2 val1 val0 val2 val1 val0 val2 val1

            punpckhdq mm3, mm0  ; val0 val2 val1 val0 val2 val1 val0 val2

            movq [edi+16] , mm4

            psrlq mm0, 32       ; 0 0 0 0 val0 val2 val1 val0

            movq [edi+8] , mm3

            punpckldq mm0, mm4  ; val1 val0 val2 val1 val0 val2 val1 val0

            sub esi, 3

            movq [edi], mm0

            sub edi, 24

            //sub esi, 3

            dec ecx

            jnz loop_pass0

            EMMS
          }

        }

        else if ((pass == 2) || (pass == 3))
        {
          _asm
          {
            mov esi, sptr

            mov edi, dp

            mov ecx, width

            sub edi, 9   // (png_pass_inc[pass] - 1)*pixel_bytes

loop_pass2:

            movd mm0, [esi]     ; X X X X X val2 val1 val0

            pand mm0, const4    ; 0 0 0 0 0 val2 val1 val0

            movq mm1, mm0       ; 0 0 0 0 0 val2 val1 val0

            psllq mm0, 16       ; 0 0 0 val2 val1 val0 0 0

            movq mm2, mm0       ; 0 0 0 val2 val1 val0 0 0

            psllq mm0, 24       ; val2 val1 val0 0 0 0 0 0

            psrlq mm1, 8        ; 0 0 0 0 0 0 val2 val1

            por mm0, mm2        ; val2 val1 val0 val2 val1 val0 0 0

            por mm0, mm1        ; val2 val1 val0 val2 val1 val0 val2 val1

            movq [edi+4], mm0   ; move to memory

            psrlq mm0, 16       ; 0 0 val2 val1 val0 val2 val1 val0

            movd [edi], mm0     ; move to memory

            sub esi, 3

            sub edi, 12

            dec ecx

            jnz loop_pass2

            EMMS
          }
        }

        else /*if ((pass == 4) || (pass == 5)) */
        {

          int width_mmx = ((width >> 1) << 1) - 8;
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr

            mov edi, dp

            mov ecx, width_mmx

            sub esi, 3

            sub edi, 9

loop_pass4:

            movq mm0, [esi]     ; X X v2 v1 v0 v5 v4 v3

            movq mm7, mm0       ; X X v2 v1 v0 v5 v4 v3

            movq mm6, mm0       ; X X v2 v1 v0 v5 v4 v3

            psllq mm0, 24       ; v1 v0 v5 v4 v3 0 0 0

            pand mm7, const4    ; 0 0 0 0 0 v5 v4 v3

            psrlq mm6, 24       ; 0 0 0 X X v2 v1 v0

            por mm0, mm7        ; v1 v0 v5 v4 v3 v5 v4 v3

            movq mm5, mm6       ; 0 0 0 X X v2 v1 v0

            psllq mm6, 8        ; 0 0 X X v2 v1 v0 0

            movq [edi], mm0     ; move quad to memory

            psrlq mm5, 16       ; 0 0 0 0 0 X X v2

            pand mm5, const6    ; 0 0 0 0 0 0 0 v2

            por mm6, mm5        ; 0 0 X X v2 v1 v0 v2

            movd [edi+8], mm6   ; move double to memory

            sub esi, 6

            sub edi, 12

            sub ecx, 2

            jnz loop_pass4

            EMMS
          }

          sptr -= width_mmx*3;
          dp -= width_mmx*6;
          for (i = width; i; i--)
          {
            png_byte v[8];
            int j;

            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              png_memcpy(dp, v, pixel_bytes);
              dp -= pixel_bytes;
            }
           sptr -= pixel_bytes;
           }

        }

      }  /* end of pixel_bytes == 3 */

      else if (pixel_bytes == 1)
      {

        if ((pass == 0) || (pass == 1))
        {
          int width_mmx = ((width >> 2) << 2);
          width -= width_mmx;
               if(width_mmx)
          _asm
          {

            mov esi, sptr

            mov edi, dp

            mov ecx, width_mmx

            sub edi, 31

            sub esi, 3

loop1_pass0:

            movd mm0, [esi]     ; X X X X v0 v1 v2 v3

            movq mm1, mm0       ; X X X X v0 v1 v2 v3

            punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3

            movq mm2, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3

            punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3

            movq mm3, mm0       ; v2 v2 v2 v2 v3 v3 v3 v3

            punpckldq mm0, mm0  ; v3 v3 v3 v3 v3 v3 v3 v3

            punpckhdq mm3, mm3  ; v2 v2 v2 v2 v2 v2 v2 v2

            movq [edi], mm0     ; move to memory v3

            punpckhwd mm2, mm2  ; v0 v0 v0 v0 v1 v1 v1 v1

            movq [edi+8], mm3   ; move to memory v2

            movq mm4, mm2       ; v0 v0 v0 v0 v1 v1 v1 v1

            punpckldq mm2, mm2  ; v1 v1 v1 v1 v1 v1 v1 v1

            punpckhdq mm4, mm4  ; v0 v0 v0 v0 v0 v0 v0 v0

            movq [edi+16], mm2  ; move to memory v1

            movq [edi+24], mm4  ; move to memory v0

            sub esi, 4

            sub edi, 32

            sub ecx, 4

            jnz loop1_pass0

            EMMS
          }

          sptr -= width_mmx;
          dp -= width_mmx*8;
          for (i = width; i; i--)
          {
            png_byte v[8];
            int j;

            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              png_memcpy(dp, v, pixel_bytes);
              dp -= pixel_bytes;
            }
           sptr -= pixel_bytes;
          }

        }


        else if ((pass == 2) || (pass == 3))
        {
          int width_mmx = ((width >> 2) << 2);
          width -= width_mmx;
               if(width_mmx)
          _asm
          {

            mov esi, sptr

            mov edi, dp

            mov ecx, width_mmx

            sub edi, 15

            sub esi, 3

loop1_pass2:

            movd mm0, [esi]     ; X X X X v0 v1 v2 v3

            punpcklbw mm0, mm0  ; v0 v0 v1 v1 v2 v2 v3 v3

            movq mm1, mm0       ; v0 v0 v1 v1 v2 v2 v3 v3

            punpcklwd mm0, mm0  ; v2 v2 v2 v2 v3 v3 v3 v3

            punpckhwd mm1, mm1  ; v0 v0 v0 v0 v1 v1 v1 v1

            movq [edi], mm0     ; move to memory v2 and v3

            sub esi, 4

            movq [edi+8], mm1   ; move to memory v1     and v0

            sub edi, 16

            sub ecx, 4

            jnz loop1_pass2

            EMMS
          }

          sptr -= width_mmx;
          dp -= width_mmx*4;
          for (i = width; i; i--)
          {
            png_byte v[8];
            int j;

            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              png_memcpy(dp, v, pixel_bytes);
              dp -= pixel_bytes;
            }
           sptr -= pixel_bytes;
          }

        }

        else //if ((pass == 4) || (pass == 5))
        {
          int width_mmx = ((width >> 3) << 3);
          width -= width_mmx;
               if(width_mmx)
          _asm
          {

            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub edi, 15
            sub esi, 7

loop1_pass4:

            movq mm0, [esi]     ; v0 v1 v2 v3 v4 v5 v6 v7
            movq mm1, mm0       ; v0 v1 v2 v3 v4 v5 v6 v7
            punpcklbw mm0, mm0  ; v4 v4 v5 v5 v6 v6 v7 v7
            //movq mm1, mm0     ; v0 v0 v1 v1 v2 v2 v3 v3
            punpckhbw mm1, mm1  ;v0 v0 v1 v1 v2 v2 v3 v3
            movq [edi+8], mm1   ; move to memory v0 v1 v2 and v3
            sub esi, 8
            movq [edi], mm0     ; move to memory v4 v5 v6 and v7
            //sub esi, 4
            sub edi, 16
            sub ecx, 8
            jnz loop1_pass4

            EMMS
          }

          sptr -= width_mmx;
          dp -= width_mmx*2;
          for (i = width; i; i--)
          {
            png_byte v[8];
            int j;

            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              png_memcpy(dp, v, pixel_bytes);
              dp -= pixel_bytes;
            }
           sptr -= pixel_bytes;
          }

        }

      }       /* end of pixel_bytes == 1 */

      else if (pixel_bytes == 2)
      {

        if ((pass == 0) || (pass == 1))
        {
          int width_mmx = ((width >> 1) << 1);
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub esi, 2
            sub edi, 30

loop2_pass0:
            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
            movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2
            punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2
            punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0
            movq [edi], mm0
            movq [edi + 8], mm0
            movq [edi + 16], mm1
            movq [edi + 24], mm1
            sub esi, 4
            sub edi, 32
            sub ecx, 2
            jnz loop2_pass0

            EMMS
          }

          sptr -= (width_mmx*2 + 2);
          dp -= (width_mmx*16 + 2);

          for (i = width; i; i--)
          {

            png_byte v[8];
            int j;
            sptr -= pixel_bytes;
            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              dp -= pixel_bytes;
              png_memcpy(dp, v, pixel_bytes);
              //dp -= pixel_bytes;
            }
            //sptr -= pixel_bytes;
          }
        }

        else if ((pass == 2) || (pass == 3))
        {
          int width_mmx = ((width >> 1) << 1) ;
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub esi, 2
            sub edi, 14

loop2_pass2:
            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
            movq mm1, mm0          ; v1 v0 v1 v0 v3 v2 v3 v2
            punpckldq mm0, mm0     ; v3 v2 v3 v2 v3 v2 v3 v2
            punpckhdq mm1, mm1     ; v1 v0 v1 v0 v1 v0 v1 v0
            movq [edi], mm0
            sub esi, 4
            movq [edi + 8], mm1
            //sub esi, 4
            sub edi, 16
            sub ecx, 2
            jnz loop2_pass2

            EMMS
          }

          sptr -= (width_mmx*2 + 2);
          dp -= (width_mmx*8 + 2);

          for (i = width; i; i--)
          {

            png_byte v[8];
            int j;
            sptr -= pixel_bytes;
            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              dp -= pixel_bytes;
              png_memcpy(dp, v, pixel_bytes);
              //dp -= pixel_bytes;
            }
            //sptr -= pixel_bytes;
          }
        }

        else // pass == 4 or 5
        {
          int width_mmx = ((width >> 1) << 1) ;
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub esi, 2
            sub edi, 6

loop2_pass4:
            movd mm0, [esi]        ; X X X X v1 v0 v3 v2
            punpcklwd mm0, mm0     ; v1 v0 v1 v0 v3 v2 v3 v2
            sub esi, 4
            movq [edi], mm0
            sub edi, 8
            sub ecx, 2
            jnz loop2_pass4

            EMMS
          }

          sptr -= (width_mmx*2 + 2);
          dp -= (width_mmx*4 + 2);

          for (i = width; i; i--)
          {

            png_byte v[8];
            int j;
            sptr -= pixel_bytes;
            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              dp -= pixel_bytes;
              png_memcpy(dp, v, pixel_bytes);
              //dp -= pixel_bytes;
            }
            //sptr -= pixel_bytes;
          }
        }

      } /* end of pixel_bytes == 2 */

      else if (pixel_bytes == 4)
      {
        if ((pass == 0) || (pass == 1))
        {
          int width_mmx = ((width >> 1) << 1) ;
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub esi, 4
            sub edi, 60

loop4_pass0:
            movq mm0, [esi]        ; v3 v2 v1 v0 v7 v6 v5 v4
            movq mm1, mm0          ; v3 v2 v1 v0 v7 v6 v5 v4
            punpckldq mm0, mm0     ; v7 v6 v5 v4 v7 v6 v5 v4
            punpckhdq mm1, mm1     ; v3 v2 v1 v0 v3 v2 v1 v0
            movq [edi], mm0
            movq [edi + 8], mm0
            movq [edi + 16], mm0
            movq [edi + 24], mm0
            movq [edi+32], mm1
            movq [edi + 40], mm1
            movq [edi+ 48], mm1
            sub esi, 8
            movq [edi + 56], mm1
            sub edi, 64
            sub ecx, 2
            jnz loop4_pass0

            EMMS
          }

          sptr -= (width_mmx*4 + 4);
          dp -= (width_mmx*32 + 4);

          for (i = width; i; i--)
          {

            png_byte v[8];
            int j;
            sptr -= pixel_bytes;
            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              dp -= pixel_bytes;
              png_memcpy(dp, v, pixel_bytes);
              //dp -= pixel_bytes;
            }
            //sptr -= pixel_bytes;
          }
        }

        else if ((pass == 2) || (pass == 3))
        {
          int width_mmx = ((width >> 1) << 1) ;
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub esi, 4
            sub edi, 28

loop4_pass2:
            movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4
            movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4
            punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4
            punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0
            movq [edi], mm0
            movq [edi + 8], mm0
            movq [edi+16], mm1
            movq [edi + 24], mm1
            sub esi, 8
            sub edi, 32
            sub ecx, 2
            jnz loop4_pass2

            EMMS
          }

          sptr -= (width_mmx*4 + 4);
          dp -= (width_mmx*16 + 4);

          for (i = width; i; i--)
          {

            png_byte v[8];
            int j;
            sptr -= pixel_bytes;
            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              dp -= pixel_bytes;
              png_memcpy(dp, v, pixel_bytes);
              //dp -= pixel_bytes;
            }
            //sptr -= pixel_bytes;
          }
        }

        else // pass == 4 or 5
        {
          int width_mmx = ((width >> 1) << 1) ;
          width -= width_mmx;
               if(width_mmx)
          _asm
          {
            mov esi, sptr
            mov edi, dp
            mov ecx, width_mmx
            sub esi, 4
            sub edi, 12

loop4_pass4:
            movq mm0, [esi]      ; v3 v2 v1 v0 v7 v6 v5 v4
            movq mm1, mm0        ; v3 v2 v1 v0 v7 v6 v5 v4
            punpckldq mm0, mm0   ; v7 v6 v5 v4 v7 v6 v5 v4
            punpckhdq mm1, mm1   ; v3 v2 v1 v0 v3 v2 v1 v0
            movq [edi], mm0
            sub esi, 8
            movq [edi + 8], mm1
            sub edi, 16
            sub ecx, 2
            jnz loop4_pass4

            EMMS
          }

          sptr -= (width_mmx*4 + 4);
          dp -= (width_mmx*8 + 4);

          for (i = width; i; i--)
          {

            png_byte v[8];
            int j;
            sptr -= pixel_bytes;
            png_memcpy(v, sptr, pixel_bytes);
            for (j = 0; j < png_pass_inc[pass]; j++)
            {
              dp -= pixel_bytes;
              png_memcpy(dp, v, pixel_bytes);
              //dp -= pixel_bytes;
            }
            //sptr -= pixel_bytes;
          }
        }

      } /* end of pixel_bytes == 4 */

      else if (pixel_bytes == 6)
      {
        for (i = row_info->width; i; i--)
        {

          png_byte v[8];
          int j;
          png_memcpy(v, sptr, pixel_bytes);
          for (j = 0; j < png_pass_inc[pass]; j++)
          {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
          }
          sptr -= pixel_bytes;
        }
      } /* end of pixel_bytes == 6 */

      else
      {
      for (i = row_info->width; i; i--)
        {

          png_byte v[8];
          int j;
          png_memcpy(v, sptr, pixel_bytes);
          for (j = 0; j < png_pass_inc[pass]; j++)
          {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
          }
          sptr-= pixel_bytes;
        }
      }
      }       /* end of mmx_supported */

      else   /* MMX not supported */
      /* use modified C code - takes advantage of inlining of memcpy for
         a constant */
      {
        if (pixel_bytes == 1)
        {
        for (i = row_info->width; i; i--)
          {
          png_byte v[8];
          int j;

          png_memcpy(v, sptr, pixel_bytes);
          for (j = 0; j < png_pass_inc[pass]; j++)
            {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
            }
          sptr -= pixel_bytes;
          }
        }
        else if (pixel_bytes == 3)
        {
        for (i = row_info->width; i; i--)
        {
          png_byte v[8];
          int j;
      png_memcpy(v, sptr, pixel_bytes);
         for (j = 0; j < png_pass_inc[pass]; j++)
            {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
            }
          sptr -= pixel_bytes;
          }
        }
        else if (pixel_bytes == 2)
        {
        for (i = row_info->width; i; i--)
          {
          png_byte v[8];
          int j;
      png_memcpy(v, sptr, pixel_bytes);
        for (j = 0; j < png_pass_inc[pass]; j++)
             {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
            }
          sptr -= pixel_bytes;
          }
        }
        else if (pixel_bytes == 4)
        {
        for (i = row_info->width; i; i--)
          {
          png_byte v[8];
          int j;
      png_memcpy(v, sptr, pixel_bytes);
        for (j = 0; j < png_pass_inc[pass]; j++)
             {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
            }
          sptr -= pixel_bytes;
          }
        }
        else if (pixel_bytes == 6)
        {
        for (i = row_info->width; i; i--)
          {
          png_byte v[8];
          int j;
      png_memcpy(v, sptr, pixel_bytes);
        for (j = 0; j < png_pass_inc[pass]; j++)
             {
            png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
            }
          sptr -= pixel_bytes;
          }
        }
        else
        {
        for (i = row_info->width; i; i--)
          {
          png_byte v[8];
          int j;
           png_memcpy(v, sptr, pixel_bytes);
         for (j = 0; j < png_pass_inc[pass]; j++)
               {
              png_memcpy(dp, v, pixel_bytes);
            dp -= pixel_bytes;
            }
          sptr -= pixel_bytes;
          }
        }

      } /* end of MMX not supported */
      break;
   }
      }
    row_info->width = final_width;
      row_info->rowbytes = ((final_width *
   (png_uint_32)row_info->pixel_depth + 7) >> 3);
   }
}

#endif


// These variables are utilized in the functions below.  They are declared
// globally here to ensure alignment on 8-byte boundaries.
union uAll {
   __int64 use;
   double  align;
}  LBCarryMask = {0x0101010101010101}, HBClearMask = {0x7f7f7f7f7f7f7f7f},
   ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem;

// Optimized code for PNG Average filter decoder
void
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row
                            , png_bytep prev_row)
{
      int bpp;
      png_uint_32 FullLength;
      png_uint_32 MMXLength;
      //png_uint_32 len;
      int diff;
      bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
    FullLength  = row_info->rowbytes; // # of bytes to filter
      _asm {
         // Init address pointers and offset
         mov edi, row          // edi ==> Avg(x)
         xor ebx, ebx          // ebx ==> x
         mov edx, edi
   mov esi, prev_row           // esi ==> Prior(x)
         sub edx, bpp          // edx ==> Raw(x-bpp)

         xor eax, eax
         // Compute the Raw value for the first bpp bytes
         //    Raw(x) = Avg(x) + (Prior(x)/2)
davgrlp:
         mov al, [esi + ebx]   // Load al with Prior(x)
   inc ebx
         shr al, 1             // divide by 2
         add al, [edi+ebx-1]   // Add Avg(x); -1 to offset inc ebx
         cmp ebx, bpp
   mov [edi+ebx-1], al    // Write back Raw(x);
                          // mov does not affect flags; -1 to offset inc ebx
         jb davgrlp
         // get # of bytes to alignment
         mov diff, edi         // take start of row
         add diff, ebx         // add bpp
         add diff, 0xf         // add 7 + 8 to incr past alignment boundary
         and diff, 0xfffffff8  // mask to alignment boundary
         sub diff, edi         // subtract from start ==> value ebx at alignment
         jz davggo
         // fix alignment
         // Compute the Raw value for the bytes upto the alignment boundary
         //    Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
         xor ecx, ecx
davglp1:
         xor eax, eax
   mov cl, [esi + ebx]        // load cl with Prior(x)
         mov al, [edx + ebx]  // load al with Raw(x-bpp)
         add ax, cx
   inc ebx
         shr ax, 1            // divide by 2
         add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx
   cmp ebx, diff              // Check if at alignment boundary
   mov [edi+ebx-1], al        // Write back Raw(x);
                            // mov does not affect flags; -1 to offset inc ebx
   jb davglp1               // Repeat until at alignment boundary
davggo:
   mov eax, FullLength
         mov ecx, eax
         sub eax, ebx          // subtract alignment fix
         and eax, 0x00000007   // calc bytes over mult of 8
         sub ecx, eax          // drop over bytes from original length
         mov MMXLength, ecx
      } // end _asm block
      // Now do the math for the rest of the row
      switch ( bpp )
      {
      case 3:
      {
         ActiveMask.use  = 0x0000000000ffffff;
         ShiftBpp.use = 24;    // == 3 * 8
         ShiftRem.use = 40;    // == 64 - 24
         _asm {
            // Re-init address pointers and offset
            movq mm7, ActiveMask
            mov ebx, diff      // ebx ==> x = offset to alignment boundary
            movq mm5, LBCarryMask
            mov edi, row       // edi ==> Avg(x)
            movq mm4, HBClearMask
      mov esi, prev_row        // esi ==> Prior(x)
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
                               // (we correct position in loop below)
davg3lp:
      movq mm0, [edi + ebx]      // Load mm0 with Avg(x)
            // Add (Prev_row/2) to Average
            movq mm3, mm5
            psrlq mm2, ShiftRem      // Correct position Raw(x-bpp) data
      movq mm1, [esi + ebx]    // Load mm1 with Prior(x)
            movq mm6, mm7
            pand mm3, mm1      // get lsb for each prev_row byte
            psrlq mm1, 1       // divide prev_row bytes by 2
            pand  mm1, mm4     // clear invalid bit 7 of each byte
      paddb mm0, mm1           // add (Prev_row/2) to Avg for each byte
            // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
            movq mm1, mm3      // now use mm1 for getting LBCarrys
            pand mm1, mm2      // get LBCarrys for each byte where both
                               // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1       // divide raw bytes by 2
            pand  mm2, mm4     // clear invalid bit 7 of each byte
            paddb mm2, mm1     // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6      // Leave only Active Group 1 bytes to add to Avg
      paddb mm0, mm2      // add (Raw/2) + LBCarrys to Avg for each Active byte
            // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
            psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 3-5
            movq mm2, mm0        // mov updated Raws to mm2
            psllq mm2, ShiftBpp  // shift data to position correctly
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 2 bytes to add to Avg
      paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active byte

            // Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry
            psllq mm6, ShiftBpp  // shift the mm6 mask to cover the last two bytes
            movq mm2, mm0        // mov updated Raws to mm2
            psllq mm2, ShiftBpp  // shift data to position correctly
                                 // Data only needs to be shifted once here to
                                 // get the correct x-bpp offset.
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 2 bytes to add to Avg
      add ebx, 8
      paddb mm0, mm2     // add (Raw/2) + LBCarrys to Avg for each Active byte

            // Now ready to write back to memory
      movq [edi + ebx - 8], mm0
            // Move updated Raw(x) to use as Raw(x-bpp) for next loop
      cmp ebx, MMXLength
            movq mm2, mm0     // mov updated Raw(x) to mm2
      jb davg3lp
   } // end _asm block
      }
      break;
      case 6:
      case 4:
      case 7:
      case 5:
      {
         ActiveMask.use  = 0xffffffffffffffff;  // use shift below to clear
                                               // appropriate inactive bytes
         ShiftBpp.use = bpp << 3;
         ShiftRem.use = 64 - ShiftBpp.use;
   _asm {
            movq mm4, HBClearMask
            // Re-init address pointers and offset
            mov ebx, diff       // ebx ==> x = offset to alignment boundary
            // Load ActiveMask and clear all bytes except for 1st active group
            movq mm7, ActiveMask
            mov edi, row                  // edi ==> Avg(x)
            psrlq mm7, ShiftRem
      mov esi, prev_row             // esi ==> Prior(x)
            movq mm6, mm7
            movq mm5, LBCarryMask
            psllq mm6, ShiftBpp    // Create mask for 2nd active group
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
                                 // (we correct position in loop below)
davg4lp:
      movq mm0, [edi + ebx]
            psrlq mm2, ShiftRem  // shift data to position correctly
      movq mm1, [esi + ebx]
            // Add (Prev_row/2) to Average
            movq mm3, mm5
            pand mm3, mm1        // get lsb for each prev_row byte
            psrlq mm1, 1         // divide prev_row bytes by 2
            pand  mm1, mm4       // clear invalid bit 7 of each byte
      paddb mm0, mm1             // add (Prev_row/2) to Avg for each byte
            // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm7        // Leave only Active Group 1 bytes to add to Avg
      paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active byte
            // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
            movq mm2, mm0        // mov updated Raws to mm2
            psllq mm2, ShiftBpp  // shift data to position correctly
      add ebx, 8
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 2 bytes to add to Avg
      paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active byte
      cmp ebx, MMXLength
            // Now ready to write back to memory
      movq [edi + ebx - 8], mm0
            // Prep Raw(x-bpp) for next loop
            movq mm2, mm0        // mov updated Raws to mm2
      jb davg4lp
   } // end _asm block
      }
      break;
      case 2:
      {
         ActiveMask.use  = 0x000000000000ffff;
         ShiftBpp.use = 24;      // == 3 * 8
         ShiftRem.use = 40;      // == 64 - 24
   _asm {
            // Load ActiveMask
            movq mm7, ActiveMask
            // Re-init address pointers and offset
            mov ebx, diff        // ebx ==> x = offset to alignment boundary
            movq mm5, LBCarryMask
            mov edi, row         // edi ==> Avg(x)
            movq mm4, HBClearMask
      mov esi, prev_row          // esi ==> Prior(x)
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
                                 // (we correct position in loop below)
davg2lp:
      movq mm0, [edi + ebx]
            psllq mm2, ShiftRem  // shift data to position correctly
      movq mm1, [esi + ebx]
            // Add (Prev_row/2) to Average
            movq mm3, mm5
            pand mm3, mm1        // get lsb for each prev_row byte
            psrlq mm1, 1         // divide prev_row bytes by 2
            pand  mm1, mm4       // clear invalid bit 7 of each byte
            movq mm6, mm7
      paddb mm0, mm1             // add (Prev_row/2) to Avg for each byte
            // Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 1 bytes to add to Avg
      paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active byte
            // Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry
            psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 2 & 3
            movq mm2, mm0        // mov updated Raws to mm2
            psllq mm2, ShiftBpp  // shift data to position correctly
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 2 bytes to add to Avg
      paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active byte

            // Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry
            psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 4 & 5
            movq mm2, mm0        // mov updated Raws to mm2
            psllq mm2, ShiftBpp  // shift data to position correctly
                                 // Data only needs to be shifted once here to
                                 // get the correct x-bpp offset.
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 2 bytes to add to Avg
      paddb mm0, mm2    // add (Raw/2) + LBCarrys to Avg for each Active byte

            // Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry
            psllq mm6, ShiftBpp  // shift the mm6 mask to cover bytes 6 & 7
            movq mm2, mm0        // mov updated Raws to mm2
            psllq mm2, ShiftBpp  // shift data to position correctly
                                 // Data only needs to be shifted once here to
                                 // get the correct x-bpp offset.
            add ebx, 8
            movq mm1, mm3        // now use mm1 for getting LBCarrys
            pand mm1, mm2        // get LBCarrys for each byte where both
                                 // lsb's were == 1 (Only valid for active group)
            psrlq mm2, 1         // divide raw bytes by 2
            pand  mm2, mm4       // clear invalid bit 7 of each byte
            paddb mm2, mm1       // add LBCarrys to (Raw(x-bpp)/2) for each byte
            pand mm2, mm6        // Leave only Active Group 2 bytes to add to Avg
      paddb mm0, mm2      // add (Raw/2) + LBCarrys to Avg for each Active byte

      cmp ebx, MMXLength
            // Now ready to write back to memory
      movq [edi + ebx - 8], mm0
            // Prep Raw(x-bpp) for next loop
            movq mm2, mm0        // mov updated Raws to mm2
      jb davg2lp
  } // end _asm block
      }
      break;
      case 1:                    // bpp == 1
      {
         _asm {
            // Re-init address pointers and offset
            mov ebx, diff        // ebx ==> x = offset to alignment boundary
            mov edi, row         // edi ==> Avg(x)
            cmp ebx, FullLength  // Test if offset at end of array
      jnb davg1end
            // Do Paeth decode for remaining bytes
        mov esi, prev_row        // esi ==> Prior(x)
            mov edx, edi
            xor ecx, ecx         // zero ecx before using cl & cx in loop below
            sub edx, bpp         // edx ==> Raw(x-bpp)
davg1lp:
            // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
            xor eax, eax
      mov cl, [esi + ebx]        // load cl with Prior(x)
            mov al, [edx + ebx]  // load al with Raw(x-bpp)
            add ax, cx
      inc ebx
            shr ax, 1            // divide by 2
            add al, [edi+ebx-1]  // Add Avg(x); -1 to offset inc ebx
      cmp ebx, FullLength        // Check if at end of array
      mov [edi+ebx-1], al        // Write back Raw(x);
                         // mov does not affect flags; -1 to offset inc ebx
      jb davg1lp
davg1end:
   } // end _asm block
      }
      return;

      case 8:             // bpp == 8
      {
   _asm {
            // Re-init address pointers and offset
            mov ebx, diff           // ebx ==> x = offset to alignment boundary
            movq mm5, LBCarryMask
            mov edi, row            // edi ==> Avg(x)
            movq mm4, HBClearMask
      mov esi, prev_row             // esi ==> Prior(x)
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm2, [edi + ebx - 8]  // Load previous aligned 8 bytes
                                // (NO NEED to correct position in loop below)
davg8lp:
      movq mm0, [edi + ebx]
            movq mm3, mm5
      movq mm1, [esi + ebx]
      add ebx, 8
            pand mm3, mm1       // get lsb for each prev_row byte
            psrlq mm1, 1        // divide prev_row bytes by 2
            pand mm3, mm2       // get LBCarrys for each byte where both
                                // lsb's were == 1
            psrlq mm2, 1        // divide raw bytes by 2
            pand  mm1, mm4      // clear invalid bit 7 of each byte
            paddb mm0, mm3      // add LBCarrys to Avg for each byte
            pand  mm2, mm4      // clear invalid bit 7 of each byte
            paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte
      paddb mm0, mm2            // add (Raw/2) to Avg for each byte
      cmp ebx, MMXLength
      movq [edi + ebx - 8], mm0
            movq mm2, mm0       // reuse as Raw(x-bpp)
      jb davg8lp
  } // end _asm block
      }
      break;
      default:                  // bpp greater than 8
      {
  _asm {
            movq mm5, LBCarryMask
            // Re-init address pointers and offset
            mov ebx, diff       // ebx ==> x = offset to alignment boundary
            mov edi, row        // edi ==> Avg(x)
            movq mm4, HBClearMask
            mov edx, edi
      mov esi, prev_row         // esi ==> Prior(x)
            sub edx, bpp        // edx ==> Raw(x-bpp)
davgAlp:
      movq mm0, [edi + ebx]
            movq mm3, mm5
      movq mm1, [esi + ebx]
            pand mm3, mm1       // get lsb for each prev_row byte
      movq mm2, [edx + ebx]
            psrlq mm1, 1        // divide prev_row bytes by 2
            pand mm3, mm2       // get LBCarrys for each byte where both
                                // lsb's were == 1
            psrlq mm2, 1        // divide raw bytes by 2
            pand  mm1, mm4      // clear invalid bit 7 of each byte
            paddb mm0, mm3      // add LBCarrys to Avg for each byte
            pand  mm2, mm4      // clear invalid bit 7 of each byte
            paddb mm0, mm1      // add (Prev_row/2) to Avg for each byte
      add ebx, 8
      paddb mm0, mm2             // add (Raw/2) to Avg for each byte
      cmp ebx, MMXLength
      movq [edi + ebx - 8], mm0
      jb davgAlp
  } // end _asm block
      }
      break;
      }                         // end switch ( bpp )

      _asm {
         // MMX acceleration complete now do clean-up
         // Check if any remaining bytes left to decode
   mov ebx, MMXLength           // ebx ==> x = offset bytes remaining after MMX
     mov edi, row               // edi ==> Avg(x)
   cmp ebx, FullLength          // Test if offset at end of array
   jnb davgend
         // Do Paeth decode for remaining bytes
     mov esi, prev_row          // esi ==> Prior(x)
         mov edx, edi
         xor ecx, ecx           // zero ecx before using cl & cx in loop below
         sub edx, bpp           // edx ==> Raw(x-bpp)
davglp2:
         // Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2)
         xor eax, eax
   mov cl, [esi + ebx]        // load cl with Prior(x)
         mov al, [edx + ebx]    // load al with Raw(x-bpp)
         add ax, cx
   inc ebx
         shr ax, 1              // divide by 2
         add al, [edi+ebx-1]    // Add Avg(x); -1 to offset inc ebx
   cmp ebx, FullLength        // Check if at end of array
   mov [edi+ebx-1], al        // Write back Raw(x);
                          // mov does not affect flags; -1 to offset inc ebx
   jb davglp2
davgend:
   emms                   // End MMX instructions; prep for possible FP instrs.
   } // end _asm block
}

// Optimized code for PNG Paeth filter decoder
void
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row
                            , png_bytep prev_row)
{
      png_uint_32 FullLength;
      png_uint_32 MMXLength;
      //png_uint_32 len;
      int bpp;
      int diff;
      //int ptemp;
      int patemp, pbtemp, pctemp;
      bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
      FullLength  = row_info->rowbytes; // # of bytes to filter
      _asm {
         xor ebx, ebx                  // ebx ==> x offset
   mov edi, row
         xor edx, edx                  // edx ==> x-bpp offset
   mov esi, prev_row
         xor eax, eax

     // Compute the Raw value for the first bpp bytes
     // Note: the formula works out to always be Paeth(x) = Raw(x) + Prior(x)
     //        where x < bpp
dpthrlp:
         mov al, [edi + ebx]
         add al, [esi + ebx]
         inc ebx
         cmp ebx, bpp
         mov [edi + ebx - 1], al
         jb dpthrlp
         // get # of bytes to alignment
         mov diff, edi         // take start of row
         add diff, ebx         // add bpp
   xor ecx, ecx
         add diff, 0xf         // add 7 + 8 to incr past alignment boundary
         and diff, 0xfffffff8  // mask to alignment boundary
         sub diff, edi         // subtract from start ==> value ebx at alignment
         jz dpthgo
         // fix alignment
dpthlp1:
         xor eax, eax
         // pav = p - a = (a + b - c) - a = b - c
         mov al, [esi + ebx]   // load Prior(x) into al
         mov cl, [esi + edx]   // load Prior(x-bpp) into cl
         sub eax, ecx          // subtract Prior(x-bpp)
         mov patemp, eax       // Save pav for later use
         xor eax, eax
         // pbv = p - b = (a + b - c) - b = a - c
         mov al, [edi + edx]   // load Raw(x-bpp) into al
         sub eax, ecx          // subtract Prior(x-bpp)
         mov ecx, eax
         // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
         add eax, patemp       // pcv = pav + pbv
         // pc = abs(pcv)
         test eax, 0x80000000
         jz dpthpca
         neg eax               // reverse sign of neg values
dpthpca:
         mov pctemp, eax       // save pc for later use
         // pb = abs(pbv)
         test ecx, 0x80000000
         jz dpthpba
         neg ecx               // reverse sign of neg values
dpthpba:
         mov pbtemp, ecx       // save pb for later use
         // pa = abs(pav)
         mov eax, patemp
         test eax, 0x80000000
         jz dpthpaa
         neg eax               // reverse sign of neg values
dpthpaa:
         mov patemp, eax       // save pa for later use
         // test if pa <= pb
         cmp eax, ecx
         jna dpthabb
         // pa > pb; now test if pb <= pc
         cmp ecx, pctemp
         jna dpthbbc
         // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
         mov cl, [esi + edx]  // load Prior(x-bpp) into cl
         jmp dpthpaeth
dpthbbc:
         // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
         mov cl, [esi + ebx]   // load Prior(x) into cl
         jmp dpthpaeth
dpthabb:
         // pa <= pb; now test if pa <= pc
         cmp eax, pctemp
         jna dpthabc
         // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
         mov cl, [esi + edx]  // load Prior(x-bpp) into cl
         jmp dpthpaeth
dpthabc:
         // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
         mov cl, [edi + edx]  // load Raw(x-bpp) into cl
dpthpaeth:
   inc ebx
   inc edx
         // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
         add [edi + ebx - 1], cl
   cmp ebx, diff
   jb dpthlp1
dpthgo:
    mov ecx, FullLength
         mov eax, ecx
         sub eax, ebx          // subtract alignment fix
         and eax, 0x00000007   // calc bytes over mult of 8
         sub ecx, eax          // drop over bytes from original length
         mov MMXLength, ecx
     } // end _asm block
      // Now do the math for the rest of the row
      switch ( bpp )
      {
      case 3:
      {
         ActiveMask.use = 0x0000000000ffffff;
         ActiveMaskEnd.use = 0xffff000000000000;
         ShiftBpp.use = 24;    // == bpp(3) * 8
         ShiftRem.use = 40;    // == 64 - 24
      _asm {
            mov ebx, diff
         mov edi, row
         mov esi, prev_row
            pxor mm0, mm0
            // PRIME the pump (load the first Raw(x-bpp) data set
            movq mm1, [edi+ebx-8]
dpth3lp:
            psrlq mm1, ShiftRem     // shift last 3 bytes to 1st 3 bytes
            movq mm2, [esi + ebx]   // load b=Prior(x)
            punpcklbw mm1, mm0      // Unpack High bytes of a
            movq mm3, [esi+ebx-8]   // Prep c=Prior(x-bpp) bytes
            punpcklbw mm2, mm0      // Unpack High bytes of b
            psrlq mm3, ShiftRem     // shift last 3 bytes to 1st 3 bytes
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            punpcklbw mm3, mm0      // Unpack High bytes of c
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3

            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4        // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4           // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5        // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5           // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6        // Create mask pcv bytes < 0
            pand mm0, mm6           // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5        // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            paddw mm7, mm3
            pxor mm0, mm0
            packuswb mm7, mm1
            movq mm3, [esi + ebx]   // load c=Prior(x-bpp)
            pand mm7, ActiveMask
            movq mm2, mm3           // load b=Prior(x) step 1
            paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)
            punpcklbw mm3, mm0      // Unpack High bytes of c
            movq [edi + ebx], mm7   // write back updated value
            movq mm1, mm7           // Now mm1 will be used as Raw(x-bpp)
            // Now do Paeth for 2nd set of bytes (3-5)
            psrlq mm2, ShiftBpp     // load b=Prior(x) step 2
            punpcklbw mm1, mm0      // Unpack High bytes of a
            pxor mm7, mm7
            punpcklbw mm2, mm0      // Unpack High bytes of b
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            psubw mm5, mm3
            psubw mm4, mm3
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) =
            //       pav + pbv = pbv + pav
            movq mm6, mm5
            paddw mm6, mm4

            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm5           // Create mask pbv bytes < 0
            pcmpgtw mm7, mm4           // Create mask pav bytes < 0
            pand mm0, mm5              // Only pbv bytes < 0 in mm0
            pand mm7, mm4              // Only pav bytes < 0 in mm7
            psubw mm5, mm0
            psubw mm4, mm7
            psubw mm5, mm0
            psubw mm4, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6           // Create mask pcv bytes < 0
            pand mm0, mm6              // Only pav bytes < 0 in mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5           // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            movq mm2, [esi + ebx]      // load b=Prior(x)
            pand mm3, mm7
            pandn mm7, mm0
            pxor mm1, mm1
            paddw mm7, mm3
            pxor mm0, mm0
            packuswb mm7, mm1
            movq mm3, mm2           // load c=Prior(x-bpp) step 1
            pand mm7, ActiveMask
            punpckhbw mm2, mm0      // Unpack High bytes of b
            psllq mm7, ShiftBpp     // Shift bytes to 2nd group of 3 bytes
             // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            paddb mm7, [edi + ebx]  // add Paeth predictor with Raw(x)
            psllq mm3, ShiftBpp     // load c=Prior(x-bpp) step 2
            movq [edi + ebx], mm7   // write back updated value
            movq mm1, mm7
            punpckhbw mm3, mm0      // Unpack High bytes of c
            psllq mm1, ShiftBpp     // Shift bytes
                                    // Now mm1 will be used as Raw(x-bpp)
            // Now do Paeth for 3rd, and final, set of bytes (6-7)
            pxor mm7, mm7
            punpckhbw mm1, mm0      // Unpack High bytes of a
            psubw mm4, mm3
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            pxor mm0, mm0
            paddw mm6, mm5

            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4        // Create mask pav bytes < 0
            pcmpgtw mm7, mm5        // Create mask pbv bytes < 0
            pand mm0, mm4           // Only pav bytes < 0 in mm7
            pand mm7, mm5           // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6        // Create mask pcv bytes < 0
            pand mm0, mm6           // Only pav bytes < 0 in mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5        // pa > pb?
            movq mm0, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            pandn mm0, mm1
            pandn mm7, mm4
            paddw mm0, mm2
            paddw mm7, mm5
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6        // pab > pc?
            pand mm3, mm7
            pandn mm7, mm0
            paddw mm7, mm3
            pxor mm1, mm1
            packuswb mm1, mm7
            // Step ebx to next set of 8 bytes and repeat loop til done
      add ebx, 8
            pand mm1, ActiveMaskEnd
            paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x)

      cmp ebx, MMXLength
            pxor mm0, mm0              // pxor does not affect flags
            movq [edi + ebx - 8], mm1  // write back updated value
                                 // mm1 will be used as Raw(x-bpp) next loop
                           // mm3 ready to be used as Prior(x-bpp) next loop
      jb dpth3lp
  } // end _asm block
      }
      break;
      case 6:
      case 7:
      case 5:
      {
         ActiveMask.use  = 0x00000000ffffffff;
         ActiveMask2.use = 0xffffffff00000000;
         ShiftBpp.use = bpp << 3;    // == bpp * 8
         ShiftRem.use = 64 - ShiftBpp.use;
    _asm {
            mov ebx, diff
         mov edi, row               //
         mov esi, prev_row
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm1, [edi+ebx-8]
            pxor mm0, mm0
dpth6lp:
            // Must shift to position Raw(x-bpp) data
            psrlq mm1, ShiftRem
            // Do first set of 4 bytes
      movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
            punpcklbw mm1, mm0      // Unpack Low bytes of a
            movq mm2, [esi + ebx]   // load b=Prior(x)
            punpcklbw mm2, mm0      // Unpack Low bytes of b
            // Must shift to position Prior(x-bpp) data
            psrlq mm3, ShiftRem
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            punpcklbw mm3, mm0      // Unpack Low bytes of c
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4        // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4           // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5        // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5           // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6        // Create mask pcv bytes < 0
            pand mm0, mm6           // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5        // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6        // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            paddw mm7, mm3
            pxor mm0, mm0
            packuswb mm7, mm1
            movq mm3, [esi + ebx - 8]  // load c=Prior(x-bpp)
            pand mm7, ActiveMask
            psrlq mm3, ShiftRem
            movq mm2, [esi + ebx]      // load b=Prior(x) step 1
            paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
            movq mm6, mm2
            movq [edi + ebx], mm7      // write back updated value
        movq mm1, [edi+ebx-8]
            psllq mm6, ShiftBpp
            movq mm5, mm7
            psrlq mm1, ShiftRem
            por mm3, mm6
            psllq mm5, ShiftBpp
            punpckhbw mm3, mm0         // Unpack High bytes of c
            por mm1, mm5
            // Do second set of 4 bytes
            punpckhbw mm2, mm0         // Unpack High bytes of b
            punpckhbw mm1, mm0         // Unpack High bytes of a
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4           // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4              // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5           // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5              // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6           // Create mask pcv bytes < 0
            pand mm0, mm6              // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5           // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            pxor mm1, mm1
            paddw mm7, mm3
            pxor mm0, mm0
            // Step ex to next set of 8 bytes and repeat loop til done
      add ebx, 8
            packuswb mm1, mm7
            paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
      cmp ebx, MMXLength
            movq [edi + ebx - 8], mm1      // write back updated value
                                // mm1 will be used as Raw(x-bpp) next loop
      jb dpth6lp
  } // end _asm block
      }
      break;
      case 4:
      {
         ActiveMask.use  = 0x00000000ffffffff;
  _asm {
            mov ebx, diff
         mov edi, row               //
         mov esi, prev_row
            pxor mm0, mm0
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm1, [edi+ebx-8] // Only time should need to read a=Raw(x-bpp) bytes
dpth4lp:
            // Do first set of 4 bytes
          movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
            punpckhbw mm1, mm0       // Unpack Low bytes of a
            movq mm2, [esi + ebx]    // load b=Prior(x)
            punpcklbw mm2, mm0       // Unpack High bytes of b
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            punpckhbw mm3, mm0       // Unpack High bytes of c
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4           // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4              // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5           // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5              // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6           // Create mask pcv bytes < 0
            pand mm0, mm6              // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5           // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            paddw mm7, mm3
            pxor mm0, mm0
            packuswb mm7, mm1
            movq mm3, [esi + ebx]      // load c=Prior(x-bpp)
            pand mm7, ActiveMask
            movq mm2, mm3              // load b=Prior(x) step 1
            paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
            punpcklbw mm3, mm0         // Unpack High bytes of c
            movq [edi + ebx], mm7      // write back updated value
            movq mm1, mm7              // Now mm1 will be used as Raw(x-bpp)
            // Do second set of 4 bytes
            punpckhbw mm2, mm0         // Unpack Low bytes of b
            punpcklbw mm1, mm0         // Unpack Low bytes of a
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4           // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4              // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5           // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5              // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6           // Create mask pcv bytes < 0
            pand mm0, mm6              // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5           // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            pxor mm1, mm1
            paddw mm7, mm3
            pxor mm0, mm0
            // Step ex to next set of 8 bytes and repeat loop til done
        add ebx, 8
            packuswb mm1, mm7
            paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
      cmp ebx, MMXLength
            movq [edi + ebx - 8], mm1      // write back updated value
                                // mm1 will be used as Raw(x-bpp) next loop
      jb dpth4lp
  } // end _asm block
      }
      break;
      case 8:                          // bpp == 8
      {
         ActiveMask.use  = 0x00000000ffffffff;
   _asm {
            mov ebx, diff
         mov edi, row               //
         mov esi, prev_row
            pxor mm0, mm0
            // PRIME the pump (load the first Raw(x-bpp) data set
      movq mm1, [edi+ebx-8] // Only time should need to read a=Raw(x-bpp) bytes
dpth8lp:
            // Do first set of 4 bytes
      movq mm3, [esi+ebx-8]      // read c=Prior(x-bpp) bytes
            punpcklbw mm1, mm0         // Unpack Low bytes of a
            movq mm2, [esi + ebx]      // load b=Prior(x)
            punpcklbw mm2, mm0         // Unpack Low bytes of b
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            punpcklbw mm3, mm0         // Unpack Low bytes of c
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4           // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4              // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5           // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5              // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6           // Create mask pcv bytes < 0
            pand mm0, mm6              // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5           // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            paddw mm7, mm3
            pxor mm0, mm0
            packuswb mm7, mm1
        movq mm3, [esi+ebx-8]    // read c=Prior(x-bpp) bytes
            pand mm7, ActiveMask
            movq mm2, [esi + ebx]      // load b=Prior(x)
            paddb mm7, [edi + ebx]     // add Paeth predictor with Raw(x)
            punpckhbw mm3, mm0         // Unpack High bytes of c
            movq [edi + ebx], mm7      // write back updated value
        movq mm1, [edi+ebx-8]    // read a=Raw(x-bpp) bytes

            // Do second set of 4 bytes
            punpckhbw mm2, mm0         // Unpack High bytes of b
            punpckhbw mm1, mm0         // Unpack High bytes of a
            // pav = p - a = (a + b - c) - a = b - c
            movq mm4, mm2
            // pbv = p - b = (a + b - c) - b = a - c
            movq mm5, mm1
            psubw mm4, mm3
            pxor mm7, mm7
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            movq mm6, mm4
            psubw mm5, mm3
            // pa = abs(p-a) = abs(pav)
            // pb = abs(p-b) = abs(pbv)
            // pc = abs(p-c) = abs(pcv)
            pcmpgtw mm0, mm4           // Create mask pav bytes < 0
            paddw mm6, mm5
            pand mm0, mm4              // Only pav bytes < 0 in mm7
            pcmpgtw mm7, mm5           // Create mask pbv bytes < 0
            psubw mm4, mm0
            pand mm7, mm5              // Only pbv bytes < 0 in mm0
            psubw mm4, mm0
            psubw mm5, mm7
            pxor mm0, mm0
            pcmpgtw mm0, mm6           // Create mask pcv bytes < 0
            pand mm0, mm6              // Only pav bytes < 0 in mm7
            psubw mm5, mm7
            psubw mm6, mm0
            //  test pa <= pb
            movq mm7, mm4
            psubw mm6, mm0
            pcmpgtw mm7, mm5           // pa > pb?
            movq mm0, mm7
            // use mm7 mask to merge pa & pb
            pand mm5, mm7
            // use mm0 mask copy to merge a & b
            pand mm2, mm0
            pandn mm7, mm4
            pandn mm0, mm1
            paddw mm7, mm5
            paddw mm0, mm2
            //  test  ((pa <= pb)? pa:pb) <= pc
            pcmpgtw mm7, mm6           // pab > pc?
            pxor mm1, mm1
            pand mm3, mm7
            pandn mm7, mm0
            pxor mm1, mm1
            paddw mm7, mm3
            pxor mm0, mm0
            // Step ex to next set of 8 bytes and repeat loop til done
        add ebx, 8
            packuswb mm1, mm7
            paddb mm1, [edi + ebx - 8]     // add Paeth predictor with Raw(x)
        cmp ebx, MMXLength
            movq [edi + ebx - 8], mm1      // write back updated value
                            // mm1 will be used as Raw(x-bpp) next loop
        jb dpth8lp
      } // end _asm block
      }
      break;
      case 1:                          // bpp = 1
      case 2:                          // bpp = 2
      default:                         // bpp > 8
      {
   _asm {
      mov ebx, diff
      cmp ebx, FullLength
      jnb dpthdend
        mov edi, row               //
        mov esi, prev_row
            // Do Paeth decode for remaining bytes
            mov edx, ebx
            xor ecx, ecx        // zero ecx before using cl & cx in loop below
            sub edx, bpp        // Set edx = ebx - bpp
dpthdlp:
            xor eax, eax
            // pav = p - a = (a + b - c) - a = b - c
            mov al, [esi + ebx]        // load Prior(x) into al
            mov cl, [esi + edx]        // load Prior(x-bpp) into cl
            sub eax, ecx                 // subtract Prior(x-bpp)
            mov patemp, eax                 // Save pav for later use
            xor eax, eax
            // pbv = p - b = (a + b - c) - b = a - c
            mov al, [edi + edx]        // load Raw(x-bpp) into al
            sub eax, ecx                 // subtract Prior(x-bpp)
            mov ecx, eax
            // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
            add eax, patemp                 // pcv = pav + pbv
            // pc = abs(pcv)
            test eax, 0x80000000
            jz dpthdpca
            neg eax                     // reverse sign of neg values
dpthdpca:
            mov pctemp, eax             // save pc for later use
            // pb = abs(pbv)
            test ecx, 0x80000000
            jz dpthdpba
            neg ecx                     // reverse sign of neg values
dpthdpba:
            mov pbtemp, ecx             // save pb for later use
            // pa = abs(pav)
            mov eax, patemp
            test eax, 0x80000000
            jz dpthdpaa
            neg eax                     // reverse sign of neg values
dpthdpaa:
            mov patemp, eax             // save pa for later use
            // test if pa <= pb
            cmp eax, ecx
            jna dpthdabb
            // pa > pb; now test if pb <= pc
            cmp ecx, pctemp
            jna dpthdbbc
            // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
            mov cl, [esi + edx]  // load Prior(x-bpp) into cl
            jmp dpthdpaeth
dpthdbbc:
            // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
            mov cl, [esi + ebx]        // load Prior(x) into cl
            jmp dpthdpaeth
dpthdabb:
            // pa <= pb; now test if pa <= pc
            cmp eax, pctemp
            jna dpthdabc
            // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
            mov cl, [esi + edx]  // load Prior(x-bpp) into cl
            jmp dpthdpaeth
dpthdabc:
            // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
            mov cl, [edi + edx]  // load Raw(x-bpp) into cl
dpthdpaeth:
      inc ebx
      inc edx
            // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
            add [edi + ebx - 1], cl
      cmp ebx, FullLength
      jb dpthdlp
dpthdend:
        } // end _asm block
      }
      return;                   // No need to go further with this one
      }                         // end switch ( bpp )
      _asm {
         // MMX acceleration complete now do clean-up
         // Check if any remaining bytes left to decode
   mov ebx, MMXLength
   cmp ebx, FullLength
   jnb dpthend
     mov edi, row
     mov esi, prev_row
         // Do Paeth decode for remaining bytes
         mov edx, ebx
         xor ecx, ecx         // zero ecx before using cl & cx in loop below
         sub edx, bpp         // Set edx = ebx - bpp
dpthlp2:
         xor eax, eax
         // pav = p - a = (a + b - c) - a = b - c
         mov al, [esi + ebx]  // load Prior(x) into al
         mov cl, [esi + edx]  // load Prior(x-bpp) into cl
         sub eax, ecx         // subtract Prior(x-bpp)
         mov patemp, eax      // Save pav for later use
         xor eax, eax
         // pbv = p - b = (a + b - c) - b = a - c
         mov al, [edi + edx]  // load Raw(x-bpp) into al
         sub eax, ecx         // subtract Prior(x-bpp)
         mov ecx, eax
         // pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv
         add eax, patemp      // pcv = pav + pbv
         // pc = abs(pcv)
         test eax, 0x80000000
         jz dpthpca2
         neg eax              // reverse sign of neg values
dpthpca2:
         mov pctemp, eax      // save pc for later use
         // pb = abs(pbv)
         test ecx, 0x80000000
         jz dpthpba2
         neg ecx              // reverse sign of neg values
dpthpba2:
         mov pbtemp, ecx      // save pb for later use
         // pa = abs(pav)
         mov eax, patemp
         test eax, 0x80000000
         jz dpthpaa2
         neg eax              // reverse sign of neg values
dpthpaa2:
         mov patemp, eax      // save pa for later use
         // test if pa <= pb
         cmp eax, ecx
         jna dpthabb2
         // pa > pb; now test if pb <= pc
         cmp ecx, pctemp
         jna dpthbbc2
         // pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
         mov cl, [esi + edx]  // load Prior(x-bpp) into cl
         jmp dpthpaeth2
dpthbbc2:
         // pb <= pc; Raw(x) = Paeth(x) + Prior(x)
         mov cl, [esi + ebx]        // load Prior(x) into cl
         jmp dpthpaeth2
dpthabb2:
         // pa <= pb; now test if pa <= pc
         cmp eax, pctemp
         jna dpthabc2
         // pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp)
         mov cl, [esi + edx]  // load Prior(x-bpp) into cl
         jmp dpthpaeth2
dpthabc2:
         // pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp)
         mov cl, [edi + edx]  // load Raw(x-bpp) into cl
dpthpaeth2:
      inc ebx
      inc edx
         // Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256
         add [edi + ebx - 1], cl
      cmp ebx, FullLength
      jb dpthlp2
dpthend:
      emms             // End MMX instructions; prep for possible FP instrs.
     } // end _asm block
}

// Optimized code for PNG Sub filter decoder
void
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row)
{
    //int test;
      int bpp;
    png_uint_32 FullLength;
    png_uint_32 MMXLength;
    int diff;
      bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel
    FullLength  = row_info->rowbytes - bpp; // # of bytes to filter
    _asm {
        mov edi, row
        mov esi, edi               // lp = row
            add edi, bpp               // rp = row + bpp
            xor eax, eax
            // get # of bytes to alignment
            mov diff, edi               // take start of row
            add diff, 0xf               // add 7 + 8 to incr past
                                        // alignment boundary
            xor ebx, ebx
            and diff, 0xfffffff8        // mask to alignment boundary
            sub diff, edi               // subtract from start ==> value
                                        //  ebx at alignment
            jz dsubgo
            // fix alignment
dsublp1:
         mov al, [esi+ebx]
         add [edi+ebx], al
          inc ebx
          cmp ebx, diff
         jb dsublp1
dsubgo:
         mov ecx, FullLength
            mov edx, ecx
            sub edx, ebx                  // subtract alignment fix
            and edx, 0x00000007           // calc bytes over mult of 8
            sub ecx, edx                  // drop over bytes from length
            mov MMXLength, ecx
     } // end _asm block
      // Now do the math for the rest of the row
      switch ( bpp )
      {
      case 3:
    {
         ActiveMask.use  = 0x0000ffffff000000;
         ShiftBpp.use = 24;       // == 3 * 8
         ShiftRem.use  = 40;      // == 64 - 24
      _asm {
            mov edi, row
            movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group
        mov esi, edi              // lp = row
            add edi, bpp          // rp = row + bpp
            movq mm6, mm7
            mov ebx, diff
            psllq mm6, ShiftBpp   // Move mask in mm6 to cover 3rd active
                                  // byte group
            // PRIME the pump (load the first Raw(x-bpp) data set
            movq mm1, [edi+ebx-8]
dsub3lp:
            psrlq mm1, ShiftRem   // Shift data for adding 1st bpp bytes
                          // no need for mask; shift clears inactive bytes
            // Add 1st active group
            movq mm0, [edi+ebx]
        paddb mm0, mm1
            // Add 2nd active group
            movq mm1, mm0         // mov updated Raws to mm1
            psllq mm1, ShiftBpp   // shift data to position correctly
            pand mm1, mm7         // mask to use only 2nd active group
        paddb mm0, mm1
            // Add 3rd active group
            movq mm1, mm0         // mov updated Raws to mm1
            psllq mm1, ShiftBpp   // shift data to position correctly
            pand mm1, mm6         // mask to use only 3rd active group
        add ebx, 8
        paddb mm0, mm1
        cmp ebx, MMXLength
        movq [edi+ebx-8], mm0     // Write updated Raws back to array
            // Prep for doing 1st add at top of loop
            movq mm1, mm0
        jb dsub3lp
      } // end _asm block
      }
      break;
      case 1:
    {
      /* Placed here just in case this is a duplicate of the
      non-MMX code for the SUB filter in png_read_filter_row
                        above
      */
//         png_bytep rp;
//         png_bytep lp;
//         png_uint_32 i;
//         bpp = (row_info->pixel_depth + 7) >> 3;
//         for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
//            i < row_info->rowbytes; i++, rp++, lp++)
//      {
//            *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);
//      }
      _asm {
            mov ebx, diff
            mov edi, row
        cmp ebx, FullLength
        jnb dsub1end
        mov esi, edi          // lp = row
        xor eax, eax
            add edi, bpp      // rp = row + bpp
dsub1lp:
        mov al, [esi+ebx]
        add [edi+ebx], al
          inc ebx
          cmp ebx, FullLength
        jb dsub1lp
dsub1end:
      } // end _asm block
    }
      return;
      case 6:
      case 7:
      case 4:
      case 5:
    {
         ShiftBpp.use = bpp << 3;
         ShiftRem.use = 64 - ShiftBpp.use;
      _asm {
            mov edi, row
            mov ebx, diff
        mov esi, edi               // lp = row
            add edi, bpp           // rp = row + bpp
            // PRIME the pump (load the first Raw(x-bpp) data set
            movq mm1, [edi+ebx-8]
dsub4lp:
            psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes
                          // no need for mask; shift clears inactive bytes
        movq mm0, [edi+ebx]
        paddb mm0, mm1
            // Add 2nd active group
            movq mm1, mm0          // mov updated Raws to mm1
            psllq mm1, ShiftBpp    // shift data to position correctly
                                   // there is no need for any mask
                                   // since shift clears inactive bits/bytes
        add ebx, 8
        paddb mm0, mm1
        cmp ebx, MMXLength
        movq [edi+ebx-8], mm0
            movq mm1, mm0          // Prep for doing 1st add at top of loop
        jb dsub4lp
      } // end _asm block
      }
      break;
      case 2:
    {
         ActiveMask.use  = 0x00000000ffff0000;
         ShiftBpp.use = 16;       // == 2 * 8
         ShiftRem.use = 48;       // == 64 - 16
      _asm {
            movq mm7, ActiveMask  // Load ActiveMask for 2nd active byte group
            mov ebx, diff
            movq mm6, mm7
        mov edi, row
            psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active byte group
        mov esi, edi            // lp = row
            movq mm5, mm6
            add edi, bpp        // rp = row + bpp
            psllq mm5, ShiftBpp // Move mask in mm5 to cover 4th active byte group
            // PRIME the pump (load the first Raw(x-bpp) data set
            movq mm1, [edi+ebx-8]
dsub2lp:
            // Add 1st active group
            psrlq mm1, ShiftRem    // Shift data for adding 1st bpp bytes
                                 // no need for mask; shift clears inactive bytes
            movq mm0, [edi+ebx]
        paddb mm0, mm1
            // Add 2nd active group
            movq mm1, mm0              // mov updated Raws to mm1
            psllq mm1, ShiftBpp      // shift data to position correctly
            pand mm1, mm7              // mask to use only 2nd active group
        paddb mm0, mm1
            // Add 3rd active group
            movq mm1, mm0              // mov updated Raws to mm1
            psllq mm1, ShiftBpp      // shift data to position correctly
            pand mm1, mm6              // mask to use only 3rd active group
        paddb mm0, mm1
            // Add 4th active group
            movq mm1, mm0              // mov updated Raws to mm1
            psllq mm1, ShiftBpp      // shift data to position correctly
            pand mm1, mm5              // mask to use only 4th active group
        add ebx, 8
        paddb mm0, mm1
        cmp ebx, MMXLength
        movq [edi+ebx-8], mm0        // Write updated Raws back to array
            movq mm1, mm0            // Prep for doing 1st add at top of loop
        jb dsub2lp
      } // end _asm block
      }
      break;
      case 8:
    {
      _asm {
        mov edi, row
            mov ebx, diff
        mov esi, edi               // lp = row
            add edi, bpp             // rp = row + bpp
         mov ecx, MMXLength
            movq mm7, [edi+ebx-8]   // PRIME the pump (load the first
                                    // Raw(x-bpp) data set
            and ecx, 0x0000003f     // calc bytes over mult of 64
dsub8lp:
        movq mm0, [edi+ebx]         // Load Sub(x) for 1st 8 bytes
        paddb mm0, mm7
               movq mm1, [edi+ebx+8]   // Load Sub(x) for 2nd 8 bytes
        movq [edi+ebx], mm0        // Write Raw(x) for 1st 8 bytes
                                   // Now mm0 will be used as Raw(x-bpp) for
                                   // the 2nd group of 8 bytes.  This will be
                                   // repeated for each group of 8 bytes with
                                   // the 8th group being used as the Raw(x-bpp)
                                   // for the 1st group of the next loop.
        paddb mm1, mm0
        movq mm2, [edi+ebx+16]      // Load Sub(x) for 3rd 8 bytes
        movq [edi+ebx+8], mm1      // Write Raw(x) for 2nd 8 bytes
        paddb mm2, mm1
        movq mm3, [edi+ebx+24]      // Load Sub(x) for 4th 8 bytes
        movq [edi+ebx+16], mm2      // Write Raw(x) for 3rd 8 bytes
        paddb mm3, mm2
        movq mm4, [edi+ebx+32] // Load Sub(x) for 5th 8 bytes
        movq [edi+ebx+24], mm3      // Write Raw(x) for 4th 8 bytes
        paddb mm4, mm3
        movq mm5, [edi+ebx+40] // Load Sub(x) for 6th 8 bytes
        movq [edi+ebx+32], mm4      // Write Raw(x) for 5th 8 bytes
        paddb mm5, mm4
        movq mm6, [edi+ebx+48]  // Load Sub(x) for 7th 8 bytes
        movq [edi+ebx+40], mm5      // Write Raw(x) for 6th 8 bytes
        paddb mm6, mm5
        movq mm7, [edi+ebx+56]      // Load Sub(x) for 8th 8 bytes
        movq [edi+ebx+48], mm6      // Write Raw(x) for 7th 8 bytes
        add ebx, 64
        paddb mm7, mm6
        cmp ebx, ecx
        movq [edi+ebx-8], mm7      // Write Raw(x) for 8th 8 bytes
        jb dsub8lp
        cmp ebx, MMXLength
        jnb dsub8lt8
dsub8lpA:
            movq mm0, [edi+ebx]
        add ebx, 8
        paddb mm0, mm7
        cmp ebx, MMXLength
        movq [edi+ebx-8], mm0   // use -8 to offset early add to ebx
            movq mm7, mm0       // Move calculated Raw(x) data to mm1 to
                                // be the new Raw(x-bpp) for the next loop
        jb dsub8lpA
dsub8lt8:
      } // end _asm block
      }
      break;
      default:                // bpp greater than 8 bytes
    {
      _asm {
            mov ebx, diff
        mov edi, row
        mov esi, edi               // lp = row
            add edi, bpp           // rp = row + bpp
dsubAlp:
        movq mm0, [edi+ebx]
        movq mm1, [esi+ebx]
        add ebx, 8
        paddb mm0, mm1
        cmp ebx, MMXLength
        movq [edi+ebx-8], mm0 // mov does not affect flags; -8 to offset add ebx
        jb dsubAlp
      } // end _asm block
      }
      break;
      }                                // end switch ( bpp )

      _asm {
            mov ebx, MMXLength
            mov edi, row
        cmp ebx, FullLength
        jnb dsubend
        mov esi, edi               // lp = row
        xor eax, eax
            add edi, bpp           // rp = row + bpp
dsublp2:
        mov al, [esi+ebx]
        add [edi+ebx], al
          inc ebx
          cmp ebx, FullLength
        jb dsublp2
dsubend:
         emms             // End MMX instructions; prep for possible FP instrs.
    } // end _asm block
}

// Optimized code for PNG Up filter decoder
void
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row,
   png_bytep prev_row)
{
      png_uint_32 len;
    len  = row_info->rowbytes;       // # of bytes to filter
    _asm {
      mov edi, row
         // get # of bytes to alignment
         mov ecx, edi
       xor ebx, ebx
         add ecx, 0x7
         xor eax, eax
         and ecx, 0xfffffff8
      mov esi, prev_row
         sub ecx, edi
         jz dupgo
         // fix alignment
duplp1:
      mov al, [edi+ebx]
      add al, [esi+ebx]
      inc ebx
      cmp ebx, ecx
      mov [edi + ebx-1], al  // mov does not affect flags; -1 to offset inc ebx
      jb duplp1
dupgo:
      mov ecx, len
         mov edx, ecx
         sub edx, ebx                  // subtract alignment fix
         and edx, 0x0000003f           // calc bytes over mult of 64
         sub ecx, edx                  // drop over bytes from length
         // Unrolled loop - use all MMX registers and interleave to reduce
         // number of branch instructions (loops) and reduce partial stalls
duploop:
      movq mm1, [esi+ebx]
      movq mm0, [edi+ebx]
          movq mm3, [esi+ebx+8]
      paddb mm0, mm1
          movq mm2, [edi+ebx+8]
      movq [edi+ebx], mm0
          paddb mm2, mm3
            movq mm5, [esi+ebx+16]
          movq [edi+ebx+8], mm2
            movq mm4, [edi+ebx+16]
               movq mm7, [esi+ebx+24]
            paddb mm4, mm5
               movq mm6, [edi+ebx+24]
            movq [edi+ebx+16], mm4
               paddb mm6, mm7
      movq mm1, [esi+ebx+32]
               movq [edi+ebx+24], mm6
      movq mm0, [edi+ebx+32]
         movq mm3, [esi+ebx+40]
      paddb mm0, mm1
         movq mm2, [edi+ebx+40]
      movq [edi+ebx+32], mm0
         paddb mm2, mm3
            movq mm5, [esi+ebx+48]
         movq [edi+ebx+40], mm2
            movq mm4, [edi+ebx+48]
               movq mm7, [esi+ebx+56]
            paddb mm4, mm5
               movq mm6, [edi+ebx+56]
            movq [edi+ebx+48], mm4
         add ebx, 64
               paddb mm6, mm7
      cmp ebx, ecx
               movq [edi+ebx-8], mm6 // (+56)movq does not affect flags;
                                     // -8 to offset add ebx
      jb duploop

      cmp edx, 0                     // Test for bytes over mult of 64
      jz dupend


         // 2 lines added by lcreeve@netins.net
         // (mail 11 Jul 98 in png-implement list)
         cmp edx, 8 //test for less than 8 bytes
         jb duplt8


         add ecx, edx
         and edx, 0x00000007           // calc bytes over mult of 8
         sub ecx, edx                  // drop over bytes from length
      jz duplt8
         // Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously
duplpA:
      movq mm1, [esi+ebx]
      movq mm0, [edi+ebx]
      add ebx, 8
      paddb mm0, mm1
      cmp ebx, ecx
      movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx
      jb duplpA
      cmp edx, 0            // Test for bytes over mult of 8
      jz dupend
duplt8:
         xor eax, eax
      add ecx, edx          // move over byte count into counter
         // Loop using x86 registers to update remaining bytes
duplp2:
      mov al, [edi + ebx]
      add al, [esi + ebx]
      inc ebx
      cmp ebx, ecx
      mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx
      jb duplp2
dupend:
         // Conversion of filtered row completed
      emms          // End MMX instructions; prep for possible FP instrs.
    } // end _asm block
}


// Optimized png_read_filter_row routines
void
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep
   row, png_bytep prev_row, int filter)
{
   char filnm[6];
   #define UseMMX (1)


   if (mmx_supported==2)
       mmx_supported=mmxsupport();
   //if (!mmx_supported)
   {
       png_read_filter_row_c(png_ptr, row_info, row, prev_row, filter);
       return ;
   }


   png_debug(1, "in png_read_filter_row\n");
   png_debug1(0,"%s, ", (UseMMX?"MMX":"x86"));
   switch (filter)
   {
   case 0: sprintf(filnm, "None ");
      break;
   case 1: sprintf(filnm, "Sub  ");
      break;
   case 2: sprintf(filnm, "Up   ");
      break;
   case 3: sprintf(filnm, "Avg  ");
      break;
   case 4: sprintf(filnm, "Paeth");
      break;
   default: sprintf(filnm, "Unknw");
      break;
   }
   png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm);
   png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth,
      (int)((row_info->pixel_depth + 7) >> 3));
   png_debug1(0,"len=%8d, ", row_info->rowbytes);

   switch (filter)
   {
      case PNG_FILTER_VALUE_NONE:
         break;
      case PNG_FILTER_VALUE_SUB:
      {
         if ( UseMMX && (row_info->pixel_depth > 8) &&
            (row_info->rowbytes >= 128) )
         {
            png_read_filter_row_mmx_sub(row_info, row);
         }  //end if UseMMX
         else
         {
            int bpp;
            png_bytep rp;
            png_bytep lp;
            png_uint_32 i;
            bpp = (row_info->pixel_depth + 7) >> 3;
            for (i = (png_uint_32)bpp, rp = row + bpp, lp = row;
               i < row_info->rowbytes; i++, rp++, lp++)
            {
               *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff);
         }
         }  //end !UseMMX
         break;
      }
      case PNG_FILTER_VALUE_UP:
      {
         if ( UseMMX && (row_info->pixel_depth > 8) &&
             (row_info->rowbytes >= 128) )
         {
            png_read_filter_row_mmx_up(row_info, row, prev_row);
         }  //end if UseMMX
         else
         {
            png_bytep rp;
            png_bytep pp;
            png_uint_32 i;
            for (i = 0, rp = row, pp = prev_row;
               i < row_info->rowbytes; i++, rp++, pp++)
            {
                  *rp = (png_byte)(((int)(*rp) + (int)(*pp)) & 0xff);
            }
         }  //end !UseMMX
         break;
      }
      case PNG_FILTER_VALUE_AVG:
      {
         if ( UseMMX && (row_info->pixel_depth > 8) &&
             (row_info->rowbytes >= 128) )
         {
            png_read_filter_row_mmx_avg(row_info, row, prev_row);
         }  //end if UseMMX
         else
         {
      png_uint_32 i;
      int bpp;
      png_bytep rp;
      png_bytep pp;
      png_bytep lp;
            bpp = (row_info->pixel_depth + 7) >> 3;
            for (i = 0, rp = row, pp = prev_row;
               i < (png_uint_32)bpp; i++, rp++, pp++)
      {
               *rp = (png_byte)(((int)(*rp) +
                  ((int)(*pp) / 2)) & 0xff);
      }
            for (lp = row; i < row_info->rowbytes; i++, rp++, lp++, pp++)
      {
               *rp = (png_byte)(((int)(*rp) +
                  (int)(*pp + *lp) / 2) & 0xff);
      }
         }  //end !UseMMX
         break;
      }
      case PNG_FILTER_VALUE_PAETH:
      {
         if ( UseMMX && (row_info->pixel_depth > 8) &&
             (row_info->rowbytes >= 128) )
         {
            png_read_filter_row_mmx_paeth(row_info, row, prev_row);
         }  //end if UseMMX
         else
         {
            int bpp;
            png_uint_32 i;
            png_bytep rp;
            png_bytep pp;
            png_bytep lp;
            png_bytep cp;
            bpp = (row_info->pixel_depth + 7) >> 3;
            for (i = 0, rp = row, pp = prev_row;
               i < (png_uint_32)bpp; i++, rp++, pp++)
            {
               *rp = (png_byte)(((int)(*rp) + (int)(*pp)) & 0xff);
            }
            for (lp = rp - bpp, cp = pp - bpp;
               i < row_info->rowbytes; i++, rp++, pp++, lp++, cp++)
            {
               int a, b, c, pa, pb, pc, p;
               b = *pp;
               c = *cp;
               a = *lp;
               p = a + b - c;
               pa = abs(p - a);
               pb = abs(p - b);
               pc = abs(p - c);
               if (pa <= pb && pa <= pc)
                  p = a;
               else if (pb <= pc)
                  p = b;
               else
                  p = c;
               *rp = (png_byte)(((int)(*rp) + p) & 0xff);
            }
         }  //end !UseMMX
         break;
      }
      default:
         png_error(png_ptr, "Bad adaptive filter type");
         break;
   }
}
#endif