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