Subversion Repositories Kolibri OS

; Copyright (c) 1998-2002,2004,2006-2014,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

; need special memory handling are expected to supply replacement

; functions for png_malloc() and png_free(), and to use

; png_create_read_struct_2() and png_create_write_struct_2() to

; identify the replacement functions.

;void (png_structrp png_ptr)

align 4

proc png_destroy_png_struct uses eax ecx edi esi, png_ptr:dword

locals

	dummy_struct png_struct

endl

	mov edi,[png_ptr]

	cmp edi,0

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

		; png_free might call png_error and may certainly call

		; png_get_mem_ptr, so fake a temporary png_struct to support this.

		mov esi,edi

		mov edi,ebp

		sub edi,ecx

		rep movsb ;dummy_struct = *png_ptr

		mov edi,[png_ptr]

		xor eax,eax

		mov ecx,sizeof.png_struct

		rep stosb ;memset(png_ptr, 0, (sizeof *png_ptr))

		mov esi,ebp

		sub esi,sizeof.png_struct

		stdcall png_free, esi, [png_ptr]

		; We may have a jmp_buf left to deallocate.

		stdcall png_free_jmpbuf, esi

end if

	@@:

	ret

endp

; 64K.  However, zlib may allocate more than 64K if you don't tell

; it not to.  See zconf.h and png.h for more information.  zlib does

; need to allocate exactly 64K, so whatever you call here must

; have the ability to do that.

align 4

proc png_calloc uses ebx ecx edi, png_ptr:dword, size:dword

	stdcall png_malloc, [png_ptr], [size]

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

		mov ebx,eax

		mov edi,eax

		mov ecx,[size]

		xor eax,eax

		rep stosb ;memset(ret, 0, size)

		mov eax,ebx

	@@:

	ret

endp

; allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED.

; Checking and error handling must happen outside this routine; it returns NULL

; if the allocation cannot be done (for any reason.)

align 4

proc png_malloc_base uses ebx ecx, png_ptr:dword, size:dword

	; Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS

	; allocators have also been removed in 1.6.0, so any 16-bit system now has

	; to implement a user memory handler.  This checks to be sure it isn't

	; called with big numbers.

	; can be false when integer overflow happens.

	jle .end0

	cmp dword[size],PNG_SIZE_MAX

	jg .end0 ;   if (..>.. && ..<=..)

if PNG_MAX_MALLOC_64K eq 1

	cmp dword[size],65536

	jg .end0

end if

if PNG_USER_MEM_SUPPORTED eq 1

	mov ebx,[png_ptr]

	cmp ebx,0

	je @f

	cmp dword[ebx+png_struct.malloc_fn],0

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

		stdcall [ebx+png_struct.malloc_fn], ebx, [size]

		jmp .end_f

	@@: ;else

end if

		;stdcall [mem.alloc], [size]

		mcall SF_SYS_MISC, SSF_MEM_ALLOC, [size]

		jmp .end_f ;checked for truncation above

	.end0: ;else

	xor eax,eax

.end_f:

	ret

endp

; that arises because of the checks in png_realloc_array that are repeated in

; png_malloc_array.

align 4

proc png_malloc_array_checked, png_ptr:dword, nelements:dword, element_size:dword

;   png_alloc_size_t req = nelements; /* known to be > 0 */

;      return png_malloc_base(png_ptr, req * element_size);

	xor eax,eax

.end_f:

	ret

endp

align 4

proc png_malloc_array, png_ptr:dword, nelements:dword, element_size:dword

;   if (nelements <= 0 || element_size == 0)

;      png_error(png_ptr, "internal error: array alloc");

	ret

endp

;    int old_elements, int add_elements, size_t element_size)

align 4

proc png_realloc_array, png_ptr:dword, old_array:dword, old_elements:dword, add_elements:dword, element_size:dword

	; These are internal errors:

;   if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||

;      (old_array == NULL && old_elements > 0))

;      png_error(png_ptr, "internal error: array realloc");

	; check.)

;   {

;      voidp new_array = png_malloc_array_checked(png_ptr,

;          old_elements+add_elements, element_size);

;

;      if (new_array != NULL)

;      {

	; Because png_malloc_array worked the size calculations below cannot

	; overflow.

;            memcpy(new_array, old_array, element_size*(unsigned)old_elements);

;

;         memset((char*)new_array + element_size*(unsigned)old_elements, 0,

;             element_size*(unsigned)add_elements);

;

;         return new_array;

;      }

;   }

.end_f:

	ret

endp

; png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate

; function png_malloc_default is also provided.

align 4

proc png_malloc uses edi, png_ptr:dword, size:dword

	xor eax,eax

	mov edi,[png_ptr]

	cmp edi,0

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

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

		png_error edi, 'Out of memory' ;'m' means png_malloc

	@@:

	ret

endp

align 4

proc png_malloc_default uses edi, png_ptr:dword, size:dword

	xor eax,eax

	mov edi,[png_ptr]

	cmp edi,0

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

	stdcall png_malloc_base, 0, [size] ;0 - use malloc

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

		png_error edi, 'Out of Memory' ;'M' means png_malloc_default

	@@:

	ret

endp

; function will issue a png_warning and return NULL instead of issuing a

; png_error, if it fails to allocate the requested memory.

align 4

proc png_malloc_warn uses edi, png_ptr:dword, size:dword

	mov edi,[png_ptr]

	cmp edi,0

	je .end0 ;if (..!=0)

		stdcall png_malloc_base, edi, [size]

		cmp eax,0

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

	.end0:

	xor eax,eax

.end_f:

	ret

endp

; without taking any action.

align 4

proc png_free uses eax ebx ecx, png_ptr:dword, p2ptr:dword

	mov ebx,[png_ptr]

	cmp ebx,0

	je .end_f

	mov ecx,[p2ptr]

	cmp ecx,0

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

	cmp dword[ebx+png_struct.free_fn],0

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

		stdcall dword[ebx+png_struct.free_fn], ebx, [p2ptr]

		jmp .end_f

	@@: ;else

end if

		mcall SF_SYS_MISC, SSF_MEM_FREE, [p2ptr]

.end_f:

	ret

endp

; of allocating and freeing memory.

align 4

proc png_set_mem_fn uses eax edi, png_ptr:dword, mem_ptr:dword, malloc_fn:dword, free_fn:dword

	mov edi,[png_ptr]

	cmp edi,0

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

		mov eax,[mem_ptr]

		mov [edi+png_struct.mem_ptr],eax

		mov eax,[malloc_fn]

		mov [edi+png_struct.malloc_fn],eax

		mov eax,[free_fn]

		mov [edi+png_struct.free_fn],eax

	@@:

	ret

endp

; 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_mem_ptr uses edi, png_ptr:dword

	xor eax,eax

	mov edi,[png_ptr]

	cmp edi,0

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

		mov eax,[edi+png_struct.mem_ptr]

	@@:

	ret

endp

if>