Subversion Repositories Kolibri OS

; Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson

; (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

; (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

; For conditions of distribution and use, see the disclaimer

; and license in png.inc

;void (png_structrp png_ptr)

align 4

proc png_set_bgr uses edi, png_ptr:dword

	png_debug 1, 'in png_set_bgr'

	cmp edi,0

	je @f ;if (..==0) return

		or dword[edi+png_struct.transformations], PNG_BGR

	@@:

	ret

endp

;void (png_structrp png_ptr)

align 4

proc png_set_swap uses edi, png_ptr:dword

	png_debug 1, 'in png_set_swap'

	cmp edi,0

	je @f ;if (..==0) return

	jne @f ;if (..==..)

		or dword[edi+png_struct.transformations], PNG_SWAP_BYTES

	@@:

	ret

endp

;void (png_structrp png_ptr)

align 4

proc png_set_packing uses edi, png_ptr:dword

	png_debug 1, 'in png_set_packing'

	cmp edi,0

	je @f ;if (..==0) return

	jge @f ;if (..<..)

		or dword[edi+png_struct.transformations], PNG_PACK

if PNG_WRITE_SUPPORTED eq 1

		mov byte[edi+png_struct.usr_bit_depth],8

end if

	@@:

	ret

endp

;void (png_structrp png_ptr)

align 4

proc png_set_packswap uses edi, png_ptr:dword

	png_debug 1, 'in png_set_packswap'

	cmp edi,0

	je @f ;if (..==0) return

	jge @f ;if (..<..)

		or dword[edi+png_struct.transformations], PNG_PACKSWAP

	@@:

	ret

endp

align 4

proc png_set_shift uses ecx edi, png_ptr:dword, true_bits:dword

	png_debug 1, 'in png_set_shift'

	cmp edi,0

	je @f ;if (..==0) return

	mov ecx,sizeof.png_color_8

	mov edi,[edi+png_struct.shift]

	mov esi,[true_bits]

	rep movsb

	@@:

	ret

endp

align 4

proc png_set_interlace_handling uses edi, png_ptr:dword

	png_debug 1, 'in png_set_interlace handling'

	cmp edi,0

	je @f

	cmp byte[edi+png_struct.interlaced],0

	je @f ;if(..!=0 && ..!=0)

		or dword[edi+png_struct.transformations], PNG_INTERLACE

		mov eax,7

		jmp .end_f

	@@:

	inc eax

.end_f:

	ret

endp

; The filler type has changed in v0.95 to allow future 2-byte fillers

; for 48-bit input data, as well as to avoid problems with some compilers

; that don't like bytes as parameters.

align 4

proc png_set_filler uses eax edi, png_ptr:dword, filler:dword, filler_loc:dword

	png_debug 1, 'in png_set_filler'

	cmp edi,0

	je .end_f ;if (..==0) return

	; operation and therefore to do more checking here for a valid call.

	and eax,PNG_IS_READ_STRUCT

	jz @f ;if (..!=0)

if PNG_READ_FILLER_SUPPORTED eq 1

		; On read png_set_filler is always valid, regardless of the base PNG

		; format, because other transformations can give a format where the

		; filler code can execute (basically an 8 or 16-bit component RGB or G

		; format.)

		; confusion in the past.)  The filler is only used in the read code.

		mov [edi+png_struct.filler],ax

		jmp .end0

else

		cStr ,'png_set_filler not supported on read'

		stdcall png_app_error, edi, eax

		jmp .end_f

end if

	@@: ;else ;write

if PNG_WRITE_FILLER_SUPPORTED eq 1

	; On write the usr_channels parameter must be set correctly at the

	; start to record the number of channels in the app-supplied data.

;         {

;            case PNG_COLOR_TYPE_RGB:

;               png_ptr->usr_channels = 4;

;               break;

;               if (png_ptr->bit_depth >= 8)

;               {

;                  png_ptr->usr_channels = 2;

;                  break;

;               }

;               {

			; There simply isn't any code in libpng to strip out bits

			; from bytes when the components are less than a byte in

			; size!

;                      "png_set_filler is invalid for"

;                      " low bit depth gray output");

;                  return;

;               }

;               png_app_error(png_ptr,

;                   "png_set_filler: inappropriate color type");

;               return;

;         }

else

		cStr ,'png_set_filler not supported on write'

		stdcall png_app_error, edi, eax

		jmp .end_f

end if

	.end0:

	; and the flag to say where the filler channel is.

	jne @f ;if (..==..)

		or dword[edi+png_struct.flags],PNG_FLAG_FILLER_AFTER

		jmp .end_f

	@@: ;else

		and dword[edi+png_struct.flags],not PNG_FLAG_FILLER_AFTER

.end_f:

	ret

endp

;void (png_structrp png_ptr, uint_32 filler, int filler_loc)

align 4

proc png_set_add_alpha uses eax edi, png_ptr:dword, filler:dword, filler_loc:dword

	png_debug 1, 'in png_set_add_alpha'

	cmp edi,0

	je .end_f ;if (..==0) return

	; The above may fail to do anything.

	mov eax,[edi+png_struct.transformations]

	and eax,PNG_FILLER

	jz .end_f ;if (..!=0)

		or dword[edi+png_struct.transformations],PNG_ADD_ALPHA

.end_f:

	ret

endp

align 4

proc png_set_swap_alpha uses edi, png_ptr:dword

	png_debug 1, 'in png_set_swap_alpha'

	cmp edi,0

	je .end_f ;if (..==0) return

		or dword[edi+png_struct.transformations], PNG_SWAP_ALPHA

.end_f:

	ret

endp

align 4

proc png_set_invert_alpha uses edi, png_ptr:dword

	png_debug 1, 'in png_set_invert_alpha'

	cmp edi,0

	je .end_f ;if (..==0) return

		or dword[edi+png_struct.transformations], PNG_INVERT_ALPHA

.end_f:

	ret

endp

align 4

proc png_set_invert_mono uses edi, png_ptr:dword

	png_debug 1, 'in png_set_invert_mono'

	cmp edi,0

	je .end_f ;if (..==0) return

		or dword[edi+png_struct.transformations], PNG_INVERT_MONO

.end_f:

	ret

endp

;void (png_row_infop row_info, bytep row)

align 4

proc png_do_invert, row_info:dword, row:dword

	png_debug 1, 'in png_do_invert'

	;   if (row_info->bit_depth == 1 &&

;   {

;      bytep rp = row;

;      png_size_t i;

;      png_size_t istop = row_info->rowbytes;

;      {

;         *rp = (byte)(~(*rp));

;         rp++;

;      }

;   }

;      row_info->bit_depth == 8)

;   {

;      bytep rp = row;

;      png_size_t i;

;      png_size_t istop = row_info->rowbytes;

;      {

;         *rp = (byte)(~(*rp));

;         rp += 2;

;      }

;   }

;   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&

;      row_info->bit_depth == 16)

;   {

;      bytep rp = row;

;      png_size_t i;

;      png_size_t istop = row_info->rowbytes;

;      {

;         *rp = (byte)(~(*rp));

;         *(rp + 1) = (byte)(~(*(rp + 1)));

;         rp += 4;

;      }

;   }

end if

	ret

endp

;void (png_row_infop row_info, bytep row)

align 4

proc png_do_swap, row_info:dword, row:dword

	png_debug 1, 'in png_do_swap'

;   {

;      bytep rp = row;

;      uint_32 i;

;      uint_32 istop= row_info->width * row_info->channels;

;      {

if PNG_BUILTIN_BSWAP16_SUPPORTED eq 1

	; Feature added to libpng-1.6.11 for testing purposes, not

	; enabled by default.

else

;         byte t = *rp;

;         *rp = *(rp + 1);

;         *(rp + 1) = t;

end if

;      }

;   }

	ret

endp

align 4

onebppswaptable db 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,\

   0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,\

   0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,\

   0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,\

   0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,\

   0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,\

   0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,\

   0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,\

   0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,\

   0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,\

   0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,\

   0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,\

   0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,\

   0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,\

   0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,\

   0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,\

   0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,\

   0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,\

   0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,\

   0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,\

   0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,\

   0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,\

   0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,\

   0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,\

   0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,\

   0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,\

   0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,\

   0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,\

   0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,\

   0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,\

   0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,\

   0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF

twobppswaptable db 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,\

   0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,\

   0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,\

   0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,\

   0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,\

   0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,\

   0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,\

   0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,\

   0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,\

   0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,\

   0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,\

   0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,\

   0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,\

   0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,\

   0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,\

   0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,\

   0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,\

   0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,\

   0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,\

   0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,\

   0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,\

   0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,\

   0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,\

   0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,\

   0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,\

   0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,\

   0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,\

   0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,\

   0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,\

   0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,\

   0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,\

   0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF

fourbppswaptable db 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,\

   0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,\

   0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,\

   0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,\

   0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,\

   0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,\

   0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,\

   0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,\

   0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,\

   0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,\

   0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,\

   0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,\

   0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,\

   0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,\

   0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,\

   0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,\

   0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,\

   0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,\

   0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,\

   0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,\

   0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,\

   0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,\

   0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,\

   0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,\

   0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,\

   0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,\

   0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,\

   0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,\

   0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,\

   0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,\

   0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,\

   0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF

end if ;PACKSWAP || WRITE_PACKSWAP

;void (png_row_infop row_info, bytep row)

align 4

proc png_do_packswap uses eax edx edi esi, row_info:dword, row:dword

	png_debug 1, 'in png_do_packswap'

	cmp byte[eax+png_row_info.bit_depth],8

	jge .end_f ;if (..<..)

		;edi = rp

		;esi = table

		mov edi,[row]

		add edx,edi

		jne @f ;if (..==..)

			mov esi,onebppswaptable

			jmp .cycle0

		@@:

		cmp byte[eax+png_row_info.bit_depth],2

		jne @f ;else if (..==..)

			mov esi,twobppswaptable

			jmp .cycle0

		@@:

		cmp byte[eax+png_row_info.bit_depth],4

		jne .end_f ;else if (..==..)

			mov esi,fourbppswaptable

align 4

		.cycle0: ;for (..=..;..<..;..)

			cmp edi,edx

			jge .end_f

			movzx eax,byte[edi]

			mov al,byte[esi+eax]

			stosb ;*rp = table[*rp]

			jmp .cycle0

.end_f:

	ret

endp

; somewhat weird combination of flags to determine what to do.  All the calls

; to png_do_strip_filler are changed in 1.5.2 to call this instead with the

; correct arguments.

; end (not in the middle) of each pixel.

align 4

proc png_do_strip_channel, row_info:dword, row:dword, at_start:dword

;   bytep sp = row; /* source pointer */

;   bytep dp = row; /* destination pointer */

;   bytep ep = row + row_info->rowbytes; /* One beyond end of row */

	; it is copied to.  ep always points just beyond the end of the row, so

	; the loop simply copies (channels-1) channels until sp reaches ep.

	;            nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.

;   if (row_info->channels == 2)

;   {

;      if (row_info->bit_depth == 8)

;      {

;         if (at_start != 0) /* Skip initial filler */

;            ++sp;

;         else          /* Skip initial channel and, for sp, the filler */

;            sp += 2, ++dp;

;         while (sp < ep)

;            *dp++ = *sp, sp += 2;

;      }

;      {

;         if (at_start != 0) /* Skip initial filler */

;            sp += 2;

;         else          /* Skip initial channel and, for sp, the filler */

;            sp += 4, dp += 2;

;            *dp++ = *sp++, *dp++ = *sp, sp += 3;

;      }

;         return; /* bad bit depth */

;      if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

;         row_info->color_type = PNG_COLOR_TYPE_GRAY;

;   }

;   else if (row_info->channels == 4)

;   {

;      if (row_info->bit_depth == 8)

;      {

;         if (at_start != 0) /* Skip initial filler */

;            ++sp;

;         else          /* Skip initial channels and, for sp, the filler */

;            sp += 4, dp += 3;

;         while (sp < ep)

;            *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;

;      }

;      {

;         if (at_start != 0) /* Skip initial filler */

;            sp += 2;

;         else          /* Skip initial channels and, for sp, the filler */

;            sp += 8, dp += 6;

;         {

;            /* Copy 6 bytes, skip 2 */

;            *dp++ = *sp++, *dp++ = *sp++;

;            *dp++ = *sp++, *dp++ = *sp++;

;            *dp++ = *sp++, *dp++ = *sp, sp += 3;

;         }

;      }

;         return; /* bad bit depth */

;      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)

;         row_info->color_type = PNG_COLOR_TYPE_RGB;

;   }

;      return; /* The filler channel has gone already */

;   row_info->rowbytes = dp-row;

	ret

endp

;void (png_row_infop row_info, bytep row)

align 4

proc png_do_bgr, row_info:dword, row:dword

	png_debug 1, 'in png_do_bgr'

;   {

;      uint_32 row_width = row_info->width;

;      if (row_info->bit_depth == 8)

;      {

;         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

;         {

;            bytep rp;

;            uint_32 i;

;            {

;               byte save = *rp;

;               *rp = *(rp + 2);

;               *(rp + 2) = save;

;            }

;         }

;         {

;            bytep rp;

;            uint_32 i;

;            {

;               byte save = *rp;

;               *rp = *(rp + 2);

;               *(rp + 2) = save;

;            }

;         }

;      }

;      else if (row_info->bit_depth == 16)

;      {

;         if (row_info->color_type == PNG_COLOR_TYPE_RGB)

;         {

;            bytep rp;

;            uint_32 i;

;            {

;               byte save = *rp;

;               *rp = *(rp + 4);

;               *(rp + 4) = save;

;               save = *(rp + 1);

;               *(rp + 1) = *(rp + 5);

;               *(rp + 5) = save;

;            }

;         }

;         {

;            bytep rp;

;            uint_32 i;

;            {

;               byte save = *rp;

;               *rp = *(rp + 4);

;               *(rp + 4) = save;

;               save = *(rp + 1);

;               *(rp + 1) = *(rp + 5);

;               *(rp + 5) = save;

;            }

;         }

;      }

end if

;   }

	ret

endp

;void (png_structrp png_ptr, png_row_infop row_info)

align 4

proc png_do_check_palette_indexes, png_ptr:dword, row_info:dword

;   if (png_ptr->num_palette < (1 << row_info->bit_depth) &&

;      png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */

;   {

	; Calculations moved outside switch in an attempt to stop different

	; compiler warnings.  'padding' is in *bits* within the last byte, it is

	; an 'int' because pixel_depth becomes an 'int' in the expression below,

	; and this calculation is used because it avoids warnings that other

	; forms produced on either GCC or MSVC.

;      bytep rp = png_ptr->row_buf + row_info->rowbytes;

;      {

;         case 1:

;         {

;            /* in this case, all bytes must be 0 so we don't need

	; to unpack the pixels except for the rightmost one.

;            {

;              if ((*rp >> padding) != 0)

;                 png_ptr->num_palette_max = 1;

;              padding = 0;

;            }

;         }

;         {

;            for (; rp > png_ptr->row_buf; rp--)

;            {

;              int i = ((*rp >> padding) & 0x03);

;                 png_ptr->num_palette_max = i;

;                 png_ptr->num_palette_max = i;

;                 png_ptr->num_palette_max = i;

;                 png_ptr->num_palette_max = i;

;            }

;         }

;         {

;            for (; rp > png_ptr->row_buf; rp--)

;            {

;              int i = ((*rp >> padding) & 0x0f);

;                 png_ptr->num_palette_max = i;

;                 png_ptr->num_palette_max = i;

;            }

;         }

;         {

;            for (; rp > png_ptr->row_buf; rp--)

;            {

;               if (*rp > png_ptr->num_palette_max)

;                  png_ptr->num_palette_max = (int) *rp;

;            }

;         }

;            break;

;      }

;   }

	ret

endp

align 4

proc png_set_user_transform_info uses eax edi, png_ptr:dword, user_transform_ptr:dword, user_transform_depth:dword, user_transform_channels:dword

	png_debug 1, 'in png_set_user_transform_info'

	cmp edi,0

	je .end_f

	mov eax,[edi+png_struct.mode]

	and eax,PNG_IS_READ_STRUCT

	jz @f

	mov eax,[edi+png_struct.flags]

	and eax,PNG_FLAG_ROW_INIT

	jz @f ;if (..!=0 && ..!=0)

		cStr ,'info change after png_start_read_image or png_read_update_info'

		stdcall png_app_error, edi, eax

		jmp .end_f

	@@:

end if

	mov [edi+png_struct.user_transform_ptr],eax

	mov eax,[user_transform_depth]

	mov [edi+png_struct.user_transform_depth],al

	mov eax,[user_transform_channels]

	mov [edi+png_struct.user_transform_channels],al

.end_f:

	ret

endp

; the user transform functions.  The application should free any memory

; associated with this pointer before png_write_destroy and png_read_destroy

; are called.

align 4

proc png_get_user_transform_ptr, png_ptr:dword

	mov eax,[png_ptr]

	cmp eax,0

	je @f

		mov eax,[eax+png_struct.user_transform_ptr]

	@@:

	ret

endp

align 4

proc png_get_current_row_number, png_ptr:dword

	; See the comments in png.inc - this is the sub-image row when reading an

	; interlaced image.

	cmp eax,0

	je @f ;if (..!=0)

		mov eax,[eax+png_struct.row_number]

		jmp .end_f

	@@:

	mov eax,PNG_UINT_32_MAX ;help the app not to fail silently

.end_f:

	ret

endp

align 4

proc png_get_current_pass_number, png_ptr:dword

	mov eax,[png_ptr]

	cmp eax,0

	je @f ;if (..!=0)

		mov eax,[eax+png_struct.pass]

		jmp .end_f

	@@:

	mov eax,8 ;invalid

.end_f:

	ret

endp

end if

>