Subversion Repositories Kolibri OS

; Copyright (c) 1998-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

; into the info struct, and during writes to store application data

; into the info struct for writing into the file.  This abstracts the

; info struct and allows us to change the structure in the future.

align 4

proc png_set_bKGD uses ecx edi esi, png_ptr:dword, info_ptr:dword, background:dword

	png_debug1 1, 'in %s storage function', 'bKGD'

	je .end_f

	mov edi,[info_ptr]

	cmp edi,0

	je .end_f

	mov esi,[background]

	cmp esi,0

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

	add edi,png_info_def.background

	mov ecx,sizeof.png_color_16

	rep movsb

.end_f:

	ret

endp

;    png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,

;    png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,

;    png_fixed_point blue_x, png_fixed_point blue_y)

align 4

proc png_set_cHRM_fixed, png_ptr:dword, info_ptr:dword,\

	white_x:dword, white_y:dword, red_x:dword, red_y:dword,\

	green_x:dword, green_y:dword, blue_x:dword, blue_y:dword

;   png_xy xy;

;      return;

;   xy.redy = red_y;

;   xy.greenx = green_x;

;   xy.greeny = green_y;

;   xy.bluex = blue_x;

;   xy.bluey = blue_y;

;   xy.whitex = white_x;

;   xy.whitey = white_y;

;       2/* override with app values*/) != 0)

;      info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;

.end_f:

	ret

endp

;    png_fixed_point int_red_X, png_fixed_point int_red_Y,

;    png_fixed_point int_red_Z, png_fixed_point int_green_X,

;    png_fixed_point int_green_Y, png_fixed_point int_green_Z,

;    png_fixed_point int_blue_X, png_fixed_point int_blue_Y,

;    png_fixed_point int_blue_Z)

align 4

proc png_set_cHRM_XYZ_fixed uses edi esi, png_ptr:dword, info_ptr:dword,\

	int_red_X:dword, int_red_Y:dword, int_red_Z:dword,\

	int_green_X:dword, int_green_Y:dword, int_green_Z:dword,\

	int_blue_X:dword, int_blue_Y:dword, int_blue_Z:dword

;   png_XYZ XYZ;

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

;   XYZ.red_Y = int_red_Y;

;   XYZ.red_Z = int_red_Z;

;   XYZ.green_X = int_green_X;

;   XYZ.green_Y = int_green_Y;

;   XYZ.green_Z = int_green_Z;

;   XYZ.blue_X = int_blue_X;

;   XYZ.blue_Y = int_blue_Y;

;   XYZ.blue_Z = int_blue_Z;

;       &XYZ, 2) != 0)

;      info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;

.end_f:

	ret

endp

;    double white_x, double white_y, double red_x, double red_y,

;    double green_x, double green_y, double blue_x, double blue_y)

align 4

proc png_set_cHRM, png_ptr:dword, info_ptr:dword,\

	white_x:dword, white_y:dword, red_x:dword, red_y:dword,\

	green_x:dword, green_y:dword, blue_x:dword, blue_y:dword

;   png_set_cHRM_fixed(png_ptr, info_ptr,

;       png_fixed(png_ptr, white_x, "cHRM White X"),

;       png_fixed(png_ptr, white_y, "cHRM White Y"),

;       png_fixed(png_ptr, red_x, "cHRM Red X"),

;       png_fixed(png_ptr, red_y, "cHRM Red Y"),

;       png_fixed(png_ptr, green_x, "cHRM Green X"),

;       png_fixed(png_ptr, green_y, "cHRM Green Y"),

;       png_fixed(png_ptr, blue_x, "cHRM Blue X"),

;       png_fixed(png_ptr, blue_y, "cHRM Blue Y"));

	ret

endp

;    double red_Y, double red_Z, double green_X, double green_Y, double green_Z,

;    double blue_X, double blue_Y, double blue_Z)

align 4

proc png_set_cHRM_XYZ, png_ptr:dword, info_ptr:dword, red_X:dword, red_Y:dword, red_Z:dword, green_X:dword, green_Y:dword, green_Z:dword, blue_X:dword, blue_Y:dword, blue_Z:dword

;   png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,

;       png_fixed(png_ptr, red_X, "cHRM Red X"),

;       png_fixed(png_ptr, red_Y, "cHRM Red Y"),

;       png_fixed(png_ptr, red_Z, "cHRM Red Z"),

;       png_fixed(png_ptr, green_X, "cHRM Green X"),

;       png_fixed(png_ptr, green_Y, "cHRM Green Y"),

;       png_fixed(png_ptr, green_Z, "cHRM Green Z"),

;       png_fixed(png_ptr, blue_X, "cHRM Blue X"),

;       png_fixed(png_ptr, blue_Y, "cHRM Blue Y"),

;       png_fixed(png_ptr, blue_Z, "cHRM Blue Z"));

	ret

endp

align 4

proc png_set_gAMA_fixed uses eax edi esi, png_ptr:dword, info_ptr:dword, file_gamma:dword

	png_debug1 1, 'in %s storage function', 'gAMA'

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

	add eax,png_info_def.colorspace

	stdcall png_colorspace_set_gamma, edi, eax, [file_gamma]

	stdcall png_colorspace_sync_info, edi, esi

.end_f:

	ret

endp

align 4

proc png_set_gAMA uses eax, png_ptr:dword, info_ptr:dword, file_gamma:dword

	cStr ,'png_set_gAMA'

	stdcall png_fixed, [png_ptr], [file_gamma], eax

	stdcall png_set_gAMA_fixed, [png_ptr], [info_ptr], eax

	ret

endp

align 4

proc png_set_hIST uses edi esi, png_ptr:dword, info_ptr:dword, hist:dword

;   int i;

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

;       > PNG_MAX_PALETTE_LENGTH)

;   {

;      png_warning(png_ptr,

;          "Invalid palette size, hIST allocation skipped");

;   }

	; version 1.2.1

;       PNG_MAX_PALETTE_LENGTH * (sizeof (uint_16)));

;   {

;      png_warning(png_ptr, "Insufficient memory for hIST chunk data");

;   }

;      info_ptr->hist[i] = hist[i];

.end_f:

	ret

endp

;    uint_32 width, uint_32 height, int bit_depth,

;    int color_type, int interlace_type, int compression_type, int filter_type)

align 4

proc png_set_IHDR, png_ptr:dword, info_ptr:dword,\

	width:dword, height:dword, bit_depth:dword, color_type:dword,\

	interlace_type:dword, compression_type:dword, filter_type:dword

	png_debug1 1, 'in %s storage function', 'IHDR'

pushad

	mov edi,[png_ptr]

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

	mov [esi+png_info_def.width],eax

	mov eax,[height]

	mov [esi+png_info_def.height],eax

	movzx eax,byte[filter_type]

	mov [esi+png_info_def.filter_type],al

	push eax

	movzx eax,byte[compression_type]

	mov [esi+png_info_def.compression_type],al

	push eax

	movzx eax,byte[interlace_type]

	mov [esi+png_info_def.interlace_type],al

	push eax

	movzx ebx,byte[color_type]

	mov [esi+png_info_def.color_type],bl

	push ebx

	movzx ecx,byte[bit_depth]

	mov [esi+png_info_def.bit_depth],cl

		;, color_type, interlace_type, compression_type, filter_type

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

		mov byte[esi+png_info_def.channels], 1

		jmp .end0

	@@:

	mov eax,ebx

	and eax,PNG_COLOR_MASK_COLOR

	cmp eax,0

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

		mov byte[esi+png_info_def.channels], 3

		jmp .end0

	@@: ;else

		mov byte[esi+png_info_def.channels], 1

	.end0:

	and eax,PNG_COLOR_MASK_ALPHA

	cmp eax,0

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

		inc byte[esi+png_info_def.channels]

	@@:

	imul eax,ecx

	mov byte[esi+png_info_def.pixel_depth],al ;channels * bit_depth

	mov [esi+png_info_def.rowbytes], eax

.end_f:

popad

	ret

endp

;void (png_structrp png_ptr, png_inforp info_ptr,

;    int_32 offset_x, int_32 offset_y, int unit_type)

align 4

proc png_set_oFFs uses eax esi, png_ptr:dword, info_ptr:dword, offset_x:dword, offset_y:dword, unit_type:dword

	png_debug1 1, 'in %s storage function', 'oFFs'

	je @f

	mov esi,[info_ptr]

	cmp esi,0

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

	mov [esi+png_info_def.x_offset],eax

	mov eax,[offset_y]

	mov [esi+png_info_def.y_offset],eax

	mov al,[unit_type]

	mov [esi+png_info_def.offset_unit_type],al

	or dword[esi+png_info_def.valid], PNG_INFO_oFFs

	@@:

	ret

endp

;    charp purpose, int_32 X0, int_32 X1, int type,

;    int nparams, charp units, charpp params)

align 4

proc png_set_pCAL uses edi esi, png_ptr:dword, info_ptr:dword, purpose:dword, X0:dword, X1:dword, type:dword, nparams:dword, units:dword, params:dword

;   png_size_t length;

;   int i;

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

	je .end_f

	cmp dword[purpose],0

	je .end_f

	cmp dword[units],0

	je .end_f

	cmp dword[nparams],0

	jle @f

	cmp dword[params],0

	jne @f

		jmp .end_f

	@@: ;if (..==0 || ..==0 || ..==0 || ..==0 || (nparams > 0 && params == 0)) return

	png_debug1 3, 'allocating purpose for info (%lu bytes)','(unsigned long)length'

	cmp dword[type],0

	jl @f

	cmp dword[type],3

	jle .end0 ;if (..<0 || ..>3)

	@@:

		png_error edi, 'Invalid pCAL equation type'

	.end0:

	jl @f

	cmp dword[nparams],255

	jle .end1 ;if (..<0 || ..>255)

	@@:

		png_error edi, 'Invalid pCAL parameter count'

	.end1:

;   for (i=0; i

;   {

;      if (params[i] == NULL ||

;          !png_check_fp_string(params[i], strlen(params[i])))

;         png_error(png_ptr, "Invalid format for pCAL parameter");

;   }

;   {

;      png_warning(png_ptr, "Insufficient memory for pCAL purpose");

;   }

;   info_ptr->pcal_X0 = X0;

;   info_ptr->pcal_X1 = X1;

;   info_ptr->pcal_type = (byte)type;

;   info_ptr->pcal_nparams = (byte)nparams;

	png_debug1 3, 'allocating units for info (%lu bytes)','(unsigned long)length'

;   {

;      png_warning(png_ptr, "Insufficient memory for pCAL units");

;   }

;       (png_size_t)((nparams + 1) * (sizeof (charp))));

;   {

;      png_warning(png_ptr, "Insufficient memory for pCAL params");

;   }

;   {

;      length = strlen(params[i]) + 1;

;      png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,

;          (unsigned long)length);

;      {

;         png_warning(png_ptr, "Insufficient memory for pCAL parameter");

;      }

;   }

	or dword[esi+png_info_def.free_me],PNG_FREE_PCAL

.end_f:

	ret

endp

;    int unit, charp swidth, charp sheight)

align 4

proc png_set_sCAL_s, png_ptr:dword, info_ptr:dword, unit:dword, swidth:dword, sheight:dword

;   png_size_t lengthw = 0, lengthh = 0;

;      return;

	; unit unless this is an API call.)

;      png_error(png_ptr, "Invalid sCAL unit");

;       swidth[0] == 45 /* '-' */ || !png_check_fp_string(swidth, lengthw))

;      png_error(png_ptr, "Invalid sCAL width");

;       sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh))

;      png_error(png_ptr, "Invalid sCAL height");

;   {

;      png_warning(png_ptr, "Memory allocation failed while processing sCAL");

;   }

;   {

;      png_free (png_ptr, info_ptr->scal_s_width);

;      info_ptr->scal_s_width = NULL;

;   }

;

;   info_ptr->valid |= PNG_INFO_sCAL;

;   info_ptr->free_me |= PNG_FREE_SCAL;

	ret

endp

;    double width, double height)

align 4

proc png_set_sCAL, png_ptr:dword, info_ptr:dword, unit:dword, width:dword, height:dword

	png_debug1 1, 'in %s storage function', 'sCAL'

;   if (width <= 0)

;      png_warning(png_ptr, "Invalid sCAL width ignored");

;      png_warning(png_ptr, "Invalid sCAL height ignored");

;   {

	; Convert 'width' and 'height' to ASCII.

;      char swidth[PNG_sCAL_MAX_DIGITS+1];

;      char sheight[PNG_sCAL_MAX_DIGITS+1];

;          PNG_sCAL_PRECISION);

;      png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height,

;          PNG_sCAL_PRECISION);

;   }

	ret

endp

;    png_fixed_point width, png_fixed_point height)

align 4

proc png_set_sCAL_fixed uses ebx ecx edi, png_ptr:dword, info_ptr:dword, unit:dword, width:dword, height:dword

locals

	swidth  rb PNG_sCAL_MAX_DIGITS+1 ;char[]

	sheight rb PNG_sCAL_MAX_DIGITS+1 ;char[]

endl

	png_debug1 1, 'in %s storage function', 'sCAL'

	mov edi,[png_ptr]

	cmp dword[width],0

	jg @f ;if (..<=0)

		png_warning edi, 'Invalid sCAL width ignored'

		jmp .end0

	@@:

	cmp dword[height],0

	jg @f ;else if (..<=0)

		png_warning edi, 'Invalid sCAL height ignored'

		jmp .end0

	@@: ;else

		; Convert 'width' and 'height' to ASCII.

		mov ebx,ebp

		sub ebx,PNG_sCAL_MAX_DIGITS+1 ;sheight

		mov ecx,ebx

		sub ecx,PNG_sCAL_MAX_DIGITS+1 ;swidth

		stdcall png_ascii_from_fixed, edi, ebx, PNG_sCAL_MAX_DIGITS+1, [height]

	.end0:

	ret

endp

;    uint_32 res_x, uint_32 res_y, int unit_type)

align 4

proc png_set_pHYs, png_ptr:dword, info_ptr:dword, res_x:dword, res_y:dword, unit_type:dword

	png_debug1 1, 'in %s storage function', 'pHYs'

;      return;

;   info_ptr->y_pixels_per_unit = res_y;

;   info_ptr->phys_unit_type = (byte)unit_type;

;   info_ptr->valid |= PNG_INFO_pHYs;

	ret

endp

align 4

proc png_set_PLTE uses eax edi esi, png_ptr:dword, info_ptr:dword, palette:dword, num_palette:dword

;   uint_32 max_palette_length;

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

;      (1 << info_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;

;   {

;      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)

;         png_error(png_ptr, "Invalid palette length");

;      {

;         png_warning(png_ptr, "Invalid palette length");

;      }

;   }

;      (num_palette == 0

if PNG_MNG_FEATURES_SUPPORTED eq 1

;            && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0

end if

;      ))

;   {

;      png_error(png_ptr, "Invalid palette");

;   }

	; we do it for backward compatibility with the way the png_handle_tRNS

	; function used to do the allocation.

	; the palette inside png_struct on read.

	; of num_palette entries, in case of an invalid PNG file or incorrect

	; call to png_set_PLTE() with too-large sample values.

;       PNG_MAX_PALETTE_LENGTH * (sizeof (png_color)));

;      memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color)));

	mov eax,[edi+png_struct.palette]

	mov [esi+png_info_def.palette],eax

;   info_ptr->num_palette = png_ptr->num_palette = (uint_16)num_palette;

	or dword[esi+png_info_def.valid], PNG_INFO_PLTE

.end_f:

	ret

endp

align 4

proc png_set_sBIT, png_ptr:dword, info_ptr:dword, sig_bit:dword

	png_debug1 1, 'in %s storage function', 'sBIT'

;      return;

;   info_ptr->valid |= PNG_INFO_sBIT;

.end_f:

	ret

endp

align 4

proc png_set_sRGB uses eax edi esi, png_ptr:dword, info_ptr:dword, srgb_intent:dword

	png_debug1 1, 'in %s storage function', 'sRGB'

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

	add eax,png_info_def.colorspace

	stdcall png_colorspace_set_sRGB, edi, eax, [srgb_intent]

	stdcall png_colorspace_sync_info, edi, esi

.end_f:

	ret

endp

align 4

proc png_set_sRGB_gAMA_and_cHRM, png_ptr:dword, info_ptr:dword, srgb_intent:dword

	png_debug1 1, 'in %s storage function', 'sRGB_gAMA_and_cHRM'

;      return;

;       srgb_intent) != 0)

;   {

	; This causes the gAMA and cHRM to be written too

;      info_ptr->colorspace.flags |=

;         PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;

;   }

.end_f:

	ret

endp

;    charp name, int compression_type, bytep profile, uint_32 proflen)

align 4

proc png_set_iCCP uses edi esi, png_ptr:dword, info_ptr:dword, name:dword, compression_type:dword, profile:dword, proflen:dword

;   charp new_iccp_name;

;   bytep new_iccp_profile;

;   png_size_t length;

;   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)

;      return;

;      png_app_error(png_ptr, "Invalid iCCP compression method");

	; override previously set app cHRM or gAMA here (because likely as not the

	; application knows better than libpng what the correct values are.)  Pass

	; the info_ptr color_type field to png_colorspace_set_ICC because in the

	; write case it has not yet been stored in png_ptr.

;      int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name,

;          proflen, profile, info_ptr->color_type);

;      if (result == 0)

;         return;

;      info_ptr->colorspace.flags |=

;         PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;

;   }

;   new_iccp_name = png_malloc_warn(png_ptr, length);

;   {

;      png_benign_error(png_ptr, "Insufficient memory to process iCCP chunk");

;      return;

;   }

;   new_iccp_profile = png_malloc_warn(png_ptr, proflen);

;   {

;      png_free(png_ptr, new_iccp_name);

;      png_benign_error(png_ptr,

;          "Insufficient memory to process iCCP profile");

;      return;

;   }

;   info_ptr->iccp_name = new_iccp_name;

;   info_ptr->iccp_profile = new_iccp_profile;

	or dword[esi+png_info_def.free_me],PNG_FREE_ICCP

	or dword[esi+png_info_def.valid],PNG_INFO_iCCP

	ret

endp

align 4

proc png_set_text uses eax edi, png_ptr:dword, info_ptr:dword, text_ptr:dword, num_text:dword

	mov edi,[png_ptr]

	stdcall png_set_text_2, edi, [info_ptr], [text_ptr], [num_text]

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

		png_error edi, 'Insufficient memory to store text'

	@@:

	ret

endp

;    png_textp text_ptr, int num_text)

align 4

proc png_set_text_2, png_ptr:dword, info_ptr:dword, text_ptr:dword, num_text:dword

;   int i;

;      return(0);

	; to hold all of the incoming text_ptr objects.  This compare can't overflow

	; because max_text >= num_text (anyway, subtract of two positive integers

	; can't overflow in any case.)

;   {

;      int old_num_text = info_ptr->num_text;

;      int max_text;

;      png_textp new_text = NULL;

;      max_text = old_num_text;

;      if (num_text <= INT_MAX - max_text)

;      {

;         max_text += num_text;

;         if (max_text < INT_MAX-8)

;            max_text = (max_text + 8) & ~0x7;

;            max_text = INT_MAX;

	; the overflow checks.

;             info_ptr->text, old_num_text, max_text-old_num_text,

;             sizeof *new_text);

;      }

;      {

;         png_chunk_report(png_ptr, "too many text chunks",

;             PNG_CHUNK_WRITE_ERROR);

;      }

;      info_ptr->free_me |= PNG_FREE_TEXT;

;      info_ptr->max_text = max_text;

;      /* num_text is adjusted below as the entries are copied in */

;   }

;   {

;      size_t text_length, key_len;

;      size_t lang_len, lang_key_len;

;      png_textp textp = &(info_ptr->text[info_ptr->num_text]);

;          continue;

;          text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST)

;      {

;         png_chunk_report(png_ptr, "text compression mode is out of range",

;             PNG_CHUNK_WRITE_ERROR);

;         continue;

;      }

;      {

;         lang_len = 0;

;         lang_key_len = 0;

;      }

if PNG_iTXt_SUPPORTED eq 1

;      {

;         /* Set iTXt data */

;            lang_len = strlen(text_ptr[i].lang);

;

;         else

;            lang_len = 0;

;            lang_key_len = strlen(text_ptr[i].lang_key);

;            lang_key_len = 0;

;      }

else ;iTXt

;      {

;         png_chunk_report(png_ptr, "iTXt chunk not supported",

;             PNG_CHUNK_WRITE_ERROR);

;         continue;

;      }

end if

;      {

;         text_length = 0;

if PNG_iTXt_SUPPORTED eq 1

;         if (text_ptr[i].compression > 0)

;            textp->compression = PNG_ITXT_COMPRESSION_NONE;

end if

;            textp->compression = PNG_TEXT_COMPRESSION_NONE;

;      }

;      {

;         text_length = strlen(text_ptr[i].text);

;         textp->compression = text_ptr[i].compression;

;      }

;          key_len + text_length + lang_len + lang_key_len + 4);

;      {

;         png_chunk_report(png_ptr, "text chunk: out of memory",

;             PNG_CHUNK_WRITE_ERROR);

;      }

;          (unsigned long)(uint_32)

;          (key_len + lang_len + lang_key_len + text_length + 4),

;          textp->key);

;      *(textp->key + key_len) = '\0';

;      {

;         textp->lang = textp->key + key_len + 1;

;         memcpy(textp->lang, text_ptr[i].lang, lang_len);

;         *(textp->lang + lang_len) = '\0';

;         textp->lang_key = textp->lang + lang_len + 1;

;         memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);

;         *(textp->lang_key + lang_key_len) = '\0';

;         textp->text = textp->lang_key + lang_key_len + 1;

;      }

;      {

;         textp->lang=NULL;

;         textp->lang_key=NULL;

;         textp->text = textp->key + key_len + 1;

;      }

;         memcpy(textp->text, text_ptr[i].text, text_length);

;      if (textp->compression > 0)

;      {

;         textp->text_length = 0;

;         textp->itxt_length = text_length;

;      }

end if

;      {

;         textp->text_length = text_length;

;         textp->itxt_length = 0;

;      }

;      png_debug1(3, "transferred text chunk %d", info_ptr->num_text);

;   }

.end_f:

	ret

endp

align 4

proc png_set_tIME uses eax ebx ecx edi esi, png_ptr:dword, info_ptr:dword, mod_time:dword

	png_debug1 1, 'in %s storage function', 'tIME'

	cmp ebx,0

	je .end_f

	mov edi,[info_ptr]

	cmp edi,0

	je .end_f

	mov esi,[mod_time]

	cmp esi,0

	je .end_f

	mov eax,[ebx+png_struct.mode]

	and eax,PNG_WROTE_tIME

	cmp eax,0

	jne .end_f ;if (..==0 || ..==0 || ..==0 || ..!=0) return

	je @f

	cmp byte[esi+png_time.month],12

	jg @f

	cmp byte[esi+png_time.day],0

	je @f

	cmp byte[esi+png_time.day],31

	jg @f

	cmp byte[esi+png_time.hour],23

	jg @f

	cmp byte[esi+png_time.minute],59

	jg @f

	cmp byte[esi+png_time.second],60

	jle .end0

	@@: ;if (..==0 || ..>.. || ..==0 || ..>.. || ..>.. || ..>.. || ..>..)

		png_warning ebx, 'Ignoring invalid time value'

		jmp .end_f

	.end0:

	push edi

	add edi,png_info_def.mod_time

	rep movsb

	pop edi

	or dword[edi+png_info_def.valid],PNG_INFO_tIME

.end_f:

	ret

endp

;    bytep trans_alpha, int num_trans, png_color_16p trans_color)

align 4

proc png_set_tRNS, png_ptr:dword, info_ptr:dword, trans_alpha:dword, num_trans:dword, trans_color:dword

	png_debug1 1, 'in %s storage function', 'tRNS'

;      return;

;   {

	; It may not actually be necessary to set png_ptr->trans_alpha here;

	; we do it for backward compatibility with the way the png_handle_tRNS

	; function used to do the allocation.

	; relies on png_set_tRNS storing the information in png_struct

	; (otherwise it won't be there for the code in pngrtran.c).

;       {

	; Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1

;          info_ptr->trans_alpha = png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH);

;          memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);

;       }

;       png_ptr->trans_alpha = info_ptr->trans_alpha;

;   }

;   {

if PNG_WARNINGS_SUPPORTED eq 1

;      if (info_ptr->bit_depth < 16)

;      {

;         int sample_max = (1 << info_ptr->bit_depth) - 1;

;

;         if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&

;             trans_color->gray > sample_max) ||

;             (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&

;             (trans_color->red > sample_max ||

;             trans_color->green > sample_max ||

;             trans_color->blue > sample_max)))

;            png_warning(png_ptr,

;                "tRNS chunk has out-of-range samples for bit_depth");

;      }

end if

;         num_trans = 1;

;   }

;   {

;      info_ptr->valid |= PNG_INFO_tRNS;

;      info_ptr->free_me |= PNG_FREE_TRNS;

;   }

	ret

endp

;void (png_structrp png_ptr,

;    png_inforp info_ptr, png_sPLT_tp entries, int nentries)

;                   to be added to the list of palettes

;                   in the info structure.

;                   added.

proc png_set_sPLT, png_ptr:dword, info_ptr:dword, entries:dword, nentries:dword

;   png_sPLT_tp np;

;      return;

	; overflows.  Notice that the parameters are (int) and (size_t)

;       info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries,