Context Navigation

pngvcrd.c @ 18166

Visit:

Revision 18166, 139.1 KB checked in by ghudson, 22 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r18165, which included commits to RCS files with non-trunk default branches.

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/libpng/pngvcrd.c @ 18166

Download in other formats: