forked from KolibriOS/kolibrios
3283 lines
90 KiB
NASM
3283 lines
90 KiB
NASM
|
|
; pngwrite.asm - general routines to write a PNG file
|
|
|
|
; Last changed in libpng 1.6.24 [August 4, 2016]
|
|
; 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.)
|
|
|
|
; This code is released under the libpng license.
|
|
; For conditions of distribution and use, see the disclaimer
|
|
; and license in png.inc
|
|
|
|
; Write out all the unknown chunks for the current given location
|
|
;void (png_structrp png_ptr, png_const_inforp info_ptr, unsigned int where)
|
|
align 4
|
|
proc write_unknown_chunks, png_ptr:dword, info_ptr:dword, where:dword
|
|
pushad
|
|
mov esi,[info_ptr]
|
|
cmp dword[esi+png_info_def.unknown_chunks_num],0
|
|
je .end_f ;if(..!=0)
|
|
mov edi,[png_ptr]
|
|
;ecx = up
|
|
|
|
png_debug 5, 'writing extra chunks'
|
|
|
|
mov ecx,[esi+png_info_def.unknown_chunks]
|
|
mov edx,[esi+png_info_def.unknown_chunks_num]
|
|
imul edx,sizeof.png_unknown_chunk
|
|
add edx,ecx
|
|
.cycle0: ;for (..;..<..;..)
|
|
cmp ecx,edx
|
|
jge .end_f
|
|
movzx eax,byte[ecx+png_unknown_chunk.location]
|
|
and eax,[where]
|
|
jz .end0 ;if (..!=0)
|
|
; If per-chunk unknown chunk handling is enabled use it, otherwise
|
|
; just write the chunks the application has set.
|
|
|
|
if PNG_SET_UNKNOWN_CHUNKS_SUPPORTED eq 1
|
|
mov eax,ecx
|
|
add eax,png_unknown_chunk.name
|
|
stdcall png_handle_as_unknown, edi, eax
|
|
|
|
; NOTE: this code is radically different from the read side in the
|
|
; matter of handling an ancillary unknown chunk. In the read side
|
|
; the default behavior is to discard it, in the code below the default
|
|
; behavior is to write it. Critical chunks are, however, only
|
|
; written if explicitly listed or if the default is set to write all
|
|
; unknown chunks.
|
|
|
|
; The default handling is also slightly weird - it is not possible to
|
|
; stop the writing of all unsafe-to-copy chunks!
|
|
|
|
; TODO: REVIEW: this would seem to be a bug.
|
|
|
|
cmp eax,PNG_HANDLE_CHUNK_NEVER
|
|
je .end0
|
|
mov bl,byte[ecx+png_unknown_chunk.name+3]
|
|
and bl,0x20
|
|
cmp bl,0
|
|
jne .beg0
|
|
cmp eax,PNG_HANDLE_CHUNK_ALWAYS
|
|
je .beg0
|
|
cmp eax,PNG_HANDLE_CHUNK_AS_DEFAULT
|
|
jne .end0
|
|
cmp dword[edi+png_struct.unknown_default],PNG_HANDLE_CHUNK_ALWAYS
|
|
jne .end0
|
|
end if
|
|
.beg0: ;if (..!=.. && (.. safe-to-copy overrides everything || ..==.. || (..==.. && ..==..)))
|
|
; TODO: review, what is wrong with a zero length unknown chunk?
|
|
cmp dword[ecx+png_unknown_chunk.size],0
|
|
jne @f ;if (..==0)
|
|
png_warning [png_ptr], 'Writing zero-length unknown chunk'
|
|
@@:
|
|
mov eax,dword[ecx+png_unknown_chunk.name]
|
|
stdcall png_write_chunk, edi, eax, [ecx+png_unknown_chunk.podata], [ecx+png_unknown_chunk.size]
|
|
.end0:
|
|
add ecx,sizeof.png_unknown_chunk
|
|
jmp .cycle0
|
|
;.cycle0end:
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
; Writes all the PNG information. This is the suggested way to use the
|
|
; library. If you have a new chunk to add, make a function to write it,
|
|
; and put it in the correct location here. If you want the chunk written
|
|
; after the image data, put it in png_write_end(). I strongly encourage
|
|
; you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
|
|
; the chunk, as that will keep the code from breaking if you want to just
|
|
; write a plain PNG file. If you have long comments, I suggest writing
|
|
; them in png_write_end(), and compressing them.
|
|
|
|
;void (png_structrp png_ptr, png_const_inforp info_ptr)
|
|
align 4
|
|
proc png_write_info_before_PLTE, png_ptr:dword, info_ptr:dword
|
|
png_debug 1, 'in png_write_info_before_PLTE'
|
|
|
|
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 eax,[edi+png_struct.mode]
|
|
and eax,PNG_WROTE_INFO_BEFORE_PLTE
|
|
jnz .end_f ;if (..==0)
|
|
|
|
; Write PNG signature
|
|
stdcall png_write_sig, edi
|
|
|
|
if PNG_MNG_FEATURES_SUPPORTED eq 1
|
|
mov eax,[edi+png_struct.mode]
|
|
and eax,PNG_HAVE_PNG_SIGNATURE
|
|
jz @f
|
|
cmp dword[edi+png_struct.mng_features_permitted],0
|
|
je @f ;if(..!=0 && ..!=0)
|
|
png_warning edi, 'MNG features are not allowed in a PNG datastream'
|
|
mov dword[edi+png_struct.mng_features_permitted],0
|
|
@@:
|
|
end if
|
|
|
|
; Write IHDR information.
|
|
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
|
|
movzx eax,byte[esi+png_info_def.interlace_type]
|
|
push eax
|
|
else
|
|
push dword 0
|
|
end if
|
|
movzx eax,byte[esi+png_info_def.filter_type]
|
|
push eax
|
|
movzx eax,byte[esi+png_info_def.compression_type]
|
|
push eax
|
|
movzx eax,byte[esi+png_info_def.color_type]
|
|
push eax
|
|
movzx eax,byte[esi+png_info_def.bit_depth]
|
|
stdcall png_write_IHDR, edi,\
|
|
dword[esi+png_info_def.width], dword[esi+png_info_def.height], eax
|
|
|
|
; The rest of these check to see if the valid field has the appropriate
|
|
; flag set, and if it does, writes the chunk.
|
|
|
|
; 1.6.0: COLORSPACE support controls the writing of these chunks too, and
|
|
; the chunks will be written if the WRITE routine is there and
|
|
; information * is available in the COLORSPACE. (See
|
|
; png_colorspace_sync_info in png.c for where the valid flags get set.)
|
|
|
|
; Under certain circumstances the colorspace can be invalidated without
|
|
; syncing the info_struct 'valid' flags; this happens if libpng detects
|
|
; an error and calls png_error while the color space is being set, yet
|
|
; the application continues writing the PNG. So check the 'invalid'
|
|
; flag here too.
|
|
|
|
if PNG_GAMMA_SUPPORTED eq 1
|
|
if PNG_WRITE_gAMA_SUPPORTED eq 1
|
|
movzx eax,word[esi+png_info_def.colorspace.flags]
|
|
and eax,PNG_COLORSPACE_INVALID
|
|
jnz @f
|
|
movzx eax,word[esi+png_info_def.colorspace.flags]
|
|
and eax,PNG_COLORSPACE_FROM_gAMA
|
|
jz @f
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_gAMA
|
|
jz @f ;if (..==0 && ..!=0 && ..!=0)
|
|
stdcall png_write_gAMA_fixed, edi, [esi+png_info_def.colorspace.gamma]
|
|
@@:
|
|
end if
|
|
end if
|
|
|
|
if PNG_COLORSPACE_SUPPORTED eq 1
|
|
; Write only one of sRGB or an ICC profile. If a profile was supplied
|
|
; and it matches one of the known sRGB ones issue a warning.
|
|
|
|
if PNG_WRITE_iCCP_SUPPORTED eq 1
|
|
movzx eax,word[esi+png_info_def.colorspace.flags]
|
|
and eax,PNG_COLORSPACE_INVALID
|
|
jnz .end0
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_iCCP
|
|
jz .end0 ;if (..==0 && ..!=0)
|
|
if PNG_WRITE_sRGB_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_sRGB
|
|
jz @f ;if (..!=0)
|
|
png_app_warning edi, 'profile matches sRGB but writing iCCP instead'
|
|
@@:
|
|
end if
|
|
stdcall png_write_iCCP, edi, [esi+png_info_def.iccp_name],\
|
|
[esi+png_info_def.iccp_profile]
|
|
if PNG_WRITE_sRGB_SUPPORTED eq 1
|
|
jmp .end1
|
|
end if
|
|
.end0: ;else
|
|
end if
|
|
|
|
if PNG_WRITE_sRGB_SUPPORTED eq 1
|
|
movzx eax,word[esi+png_info_def.colorspace.flags]
|
|
and eax,PNG_COLORSPACE_INVALID
|
|
jnz .end1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_sRGB
|
|
jz .end1 ;if (..==0 && ..!=0)
|
|
movzx eax,word[esi+png_info_def.colorspace.rendering_intent]
|
|
stdcall png_write_sRGB, edi, eax
|
|
.end1:
|
|
end if ;sRGB
|
|
end if ;COLORSPACE
|
|
|
|
if PNG_WRITE_sBIT_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_sBIT
|
|
jz @f ;if (..!=0)
|
|
movzx eax,byte[esi+png_info_def.color_type]
|
|
push eax
|
|
mov eax,esi
|
|
add eax,png_info_def.sig_bit
|
|
stdcall png_write_sBIT, edi, eax ;, ...color_type
|
|
@@:
|
|
end if
|
|
|
|
if PNG_COLORSPACE_SUPPORTED eq 1
|
|
if PNG_WRITE_cHRM_SUPPORTED eq 1
|
|
movzx eax,word[esi+png_info_def.colorspace.flags]
|
|
and eax,PNG_COLORSPACE_INVALID
|
|
jnz @f
|
|
movzx eax,word[esi+png_info_def.colorspace.flags]
|
|
and eax,PNG_COLORSPACE_FROM_cHRM
|
|
jz @f
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_cHRM
|
|
jz @f ;if (..==0 && ..!=0 && ..!=0)
|
|
stdcall png_write_cHRM_fixed, edi, [esi+png_info_def.colorspace.end_points_xy]
|
|
@@:
|
|
end if
|
|
end if
|
|
|
|
if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
|
|
stdcall write_unknown_chunks, edi, esi, PNG_HAVE_IHDR
|
|
end if
|
|
or dword[edi+png_struct.mode],PNG_WROTE_INFO_BEFORE_PLTE
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, png_const_inforp info_ptr)
|
|
align 4
|
|
proc png_write_info, png_ptr:dword, info_ptr:dword
|
|
if (PNG_WRITE_TEXT_SUPPORTED eq 1) | (PNG_WRITE_sPLT_SUPPORTED eq 1)
|
|
; int i;
|
|
end if
|
|
pushad
|
|
png_debug 1, 'in png_write_info'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f
|
|
mov esi,[info_ptr]
|
|
cmp esi,0
|
|
je .end_f ;if (..==0 || ..==0) return
|
|
|
|
stdcall png_write_info_before_PLTE, edi, esi
|
|
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_PLTE
|
|
jz @f ;if (..!=0)
|
|
movzx eax,word[esi+png_info_def.num_palette]
|
|
stdcall png_write_PLTE, edi, [esi+png_info_def.palette], eax
|
|
jmp .end_0
|
|
@@:
|
|
mov al,byte[esi+png_info_def.color_type]
|
|
cmp al,PNG_COLOR_TYPE_PALETTE
|
|
jne .end_0 ;else if (..==..)
|
|
png_error edi, 'Valid palette required for paletted images'
|
|
.end_0:
|
|
|
|
if PNG_WRITE_tRNS_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_tRNS
|
|
jz .end_1 ;if (..!=0)
|
|
if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
|
|
; Invert the alpha channel (in tRNS)
|
|
; if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
|
|
; info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
|
|
; {
|
|
; int j, jend;
|
|
|
|
; jend = info_ptr->num_trans;
|
|
; if (jend > PNG_MAX_PALETTE_LENGTH)
|
|
; jend = PNG_MAX_PALETTE_LENGTH;
|
|
|
|
; for (j = 0; j<jend; ++j)
|
|
; info_ptr->trans_alpha[j] =
|
|
; (byte)(255 - info_ptr->trans_alpha[j]);
|
|
; }
|
|
end if
|
|
mov eax,esi
|
|
add eax,png_info_def.trans_color
|
|
movzx ebx,word[esi+png_info_def.num_trans]
|
|
movzx ecx,byte[esi+png_info_def.color_type]
|
|
stdcall png_write_tRNS, edi, dword[esi+png_info_def.trans_alpha], eax, ebx, ecx
|
|
.end_1:
|
|
end if
|
|
if PNG_WRITE_bKGD_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_bKGD
|
|
jz @f ;if (..!=0)
|
|
mov eax,esi
|
|
add eax,png_info_def.background
|
|
movzx ebx,byte[esi+png_info_def.color_type]
|
|
stdcall png_write_bKGD, edi, eax, ebx
|
|
@@:
|
|
end if
|
|
|
|
if PNG_WRITE_hIST_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_hIST
|
|
jz @f ;if (..!=0)
|
|
movzx ebx,word[esi+png_info_def.num_palette]
|
|
stdcall png_write_hIST, edi, [esi+png_info_def.hist], ebx
|
|
@@:
|
|
end if
|
|
|
|
if PNG_WRITE_oFFs_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_oFFs
|
|
jz @f ;if (..!=0)
|
|
movzx ebx,byte[esi+png_info_def.offset_unit_type]
|
|
stdcall png_write_oFFs, edi, [esi+png_info_def.x_offset], [esi+png_info_def.y_offset], ebx
|
|
@@:
|
|
end if
|
|
|
|
if PNG_WRITE_pCAL_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_pCAL
|
|
jz @f ;if (..!=0)
|
|
movzx ebx,byte[esi+png_info_def.pcal_type]
|
|
movzx ecx,byte[esi+png_info_def.pcal_nparams]
|
|
stdcall png_write_pCAL, edi, [esi+png_info_def.pcal_purpose], [esi+png_info_def.pcal_X0], [esi+png_info_def.pcal_X1], ebx, ecx, [esi+png_info_def.pcal_units], [esi+png_info_def.pcal_params]
|
|
@@:
|
|
end if
|
|
|
|
if PNG_WRITE_sCAL_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_sCAL
|
|
jz @f ;if (..!=0)
|
|
movzx ebx,byte[esi+png_info_def.scal_unit]
|
|
stdcall png_write_sCAL_s, edi, ebx, [esi+png_info_def.scal_s_width], [esi+png_info_def.scal_s_height]
|
|
@@:
|
|
end if ;sCAL
|
|
|
|
if PNG_WRITE_pHYs_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_pHYs
|
|
jz @f ;if (..!=0)
|
|
movzx ebx,byte[esi+png_info_def.phys_unit_type]
|
|
stdcall png_write_pHYs, edi, [esi+png_info_def.x_pixels_per_unit], [esi+png_info_def.y_pixels_per_unit], ebx
|
|
@@:
|
|
end if ;pHYs
|
|
|
|
if PNG_WRITE_tIME_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_tIME
|
|
jz @f ;if (..!=0)
|
|
mov eax,esi
|
|
add eax,png_info_def.mod_time
|
|
stdcall png_write_tIME, edi, eax
|
|
or [edi+png_struct.mode],PNG_WROTE_tIME
|
|
@@:
|
|
end if ;tIME
|
|
|
|
if PNG_WRITE_sPLT_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_sPLT
|
|
jz @f ;if (..!=0)
|
|
mov eax,[esi+png_info_def.splt_palettes]
|
|
mov ecx,[esi+png_info_def.splt_palettes_num]
|
|
cmp ecx,1
|
|
jl @f
|
|
.cycle0:
|
|
stdcall png_write_sPLT, edi, eax
|
|
add eax,4
|
|
loop .cycle0
|
|
@@:
|
|
end if ;sPLT
|
|
|
|
if PNG_WRITE_TEXT_SUPPORTED eq 1
|
|
; Check to see if we need to write text chunks
|
|
; for (i = 0; i < info_ptr->num_text; i++)
|
|
; {
|
|
; png_debug2(2, "Writing header text chunk %d, type %d", i,
|
|
; info_ptr->text[i].compression);
|
|
; An internationalized chunk?
|
|
; if (info_ptr->text[i].compression > 0)
|
|
; {
|
|
if PNG_WRITE_iTXt_SUPPORTED eq 1
|
|
; Write international chunk
|
|
; png_write_iTXt(png_ptr,
|
|
; info_ptr->text[i].compression,
|
|
; info_ptr->text[i].key,
|
|
; info_ptr->text[i].lang,
|
|
; info_ptr->text[i].lang_key,
|
|
; info_ptr->text[i].text);
|
|
; Mark this chunk as written
|
|
; if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
|
|
; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
|
|
; else
|
|
; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
|
|
else
|
|
png_warning edi, 'Unable to write international text'
|
|
end if
|
|
; }
|
|
|
|
; If we want a compressed text chunk
|
|
; else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
|
|
; {
|
|
if PNG_WRITE_zTXt_SUPPORTED eq 1
|
|
; Write compressed chunk
|
|
; png_write_zTXt(png_ptr, info_ptr->text[i].key,
|
|
; info_ptr->text[i].text, info_ptr->text[i].compression);
|
|
; Mark this chunk as written
|
|
; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
|
|
else
|
|
png_warning edi, 'Unable to write compressed text'
|
|
end if
|
|
; }
|
|
|
|
; else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
|
|
; {
|
|
if PNG_WRITE_tEXt_SUPPORTED eq 1
|
|
; Write uncompressed chunk
|
|
; png_write_tEXt(png_ptr, info_ptr->text[i].key,
|
|
; info_ptr->text[i].text,
|
|
; 0);
|
|
; Mark this chunk as written
|
|
; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
|
|
else
|
|
; Can't get here
|
|
png_warning edi, 'Unable to write uncompressed text'
|
|
end if
|
|
; }
|
|
; }
|
|
end if ;tEXt
|
|
|
|
if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
|
|
stdcall write_unknown_chunks, edi, esi, PNG_HAVE_PLTE
|
|
end if
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
; Writes the end of the PNG file. If you don't want to write comments or
|
|
; time information, you can pass NULL for info. If you already wrote these
|
|
; in png_write_info(), do not write them again here. If you have long
|
|
; comments, I suggest writing them here, and compressing them.
|
|
|
|
;void (png_structrp png_ptr, png_inforp info_ptr)
|
|
align 4
|
|
proc png_write_end, png_ptr:dword, info_ptr:dword
|
|
pushad
|
|
png_debug 1, 'in png_write_end'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
mov eax,[edi+png_struct.mode]
|
|
and eax,PNG_HAVE_IDAT
|
|
jnz @f ;if (..==0)
|
|
png_error edi, 'No IDATs written into file'
|
|
@@:
|
|
|
|
if PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED eq 1
|
|
mov eax,[edi+png_struct.num_palette_max]
|
|
cmp ax,[edi+png_struct.num_palette]
|
|
jle @f ;if (..>..)
|
|
png_benign_error edi, 'Wrote palette index exceeding num_palette'
|
|
@@:
|
|
end if
|
|
|
|
; See if user wants us to write information chunks
|
|
mov esi,[info_ptr]
|
|
cmp esi,0
|
|
je .end0 ;if (..!=0)
|
|
if PNG_WRITE_TEXT_SUPPORTED eq 1
|
|
; int i; /* local index variable */
|
|
end if
|
|
if PNG_WRITE_tIME_SUPPORTED eq 1
|
|
; Check to see if user has supplied a time chunk
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_tIME
|
|
jz @f
|
|
mov eax,[edi+png_struct.mode]
|
|
and eax,PNG_WROTE_tIME
|
|
jnz @f ;if (..!=0 && ..==0)
|
|
mov eax,esi
|
|
add eax,png_info_def.mod_time
|
|
stdcall png_write_tIME, edi, eax
|
|
@@:
|
|
|
|
end if
|
|
if PNG_WRITE_TEXT_SUPPORTED eq 1
|
|
; Loop through comment chunks
|
|
cmp dword[esi+png_info_def.num_text],0
|
|
jle .cycle0end
|
|
xor ecx,ecx
|
|
align 4
|
|
.cycle0: ;for (i = 0; i < info_ptr->num_text; i++)
|
|
|
|
; png_debug2(2, "Writing trailer text chunk %d, type %d", i,
|
|
; info_ptr->text[i].compression);
|
|
; An internationalized chunk?
|
|
mov eax,ecx
|
|
shl eax,2
|
|
add eax,[esi+png_info_def.text] ;eax = info_ptr.text[i]
|
|
cmp dword[eax+png_text.compression],0
|
|
jle .end1 ;if (info_ptr.text[i].compression > 0)
|
|
if PNG_WRITE_iTXt_SUPPORTED eq 1
|
|
; Write international chunk
|
|
stdcall png_write_iTXt, edi,\
|
|
[eax+png_text.compression],\
|
|
[eax+png_text.key],\
|
|
[eax+png_text.lang],\
|
|
[eax+png_text.lang_key],\
|
|
[eax+png_text.text]
|
|
; Mark this chunk as written
|
|
mov ebx,PNG_TEXT_COMPRESSION_zTXt_WR
|
|
cmp dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_NONE
|
|
jne @f
|
|
mov ebx,PNG_TEXT_COMPRESSION_NONE_WR
|
|
@@:
|
|
mov dword[eax+png_text.compression],ebx
|
|
else
|
|
png_warning edi, 'Unable to write international text'
|
|
end if
|
|
jmp .end3
|
|
.end1:
|
|
cmp dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_zTXt
|
|
jl .end2 ;else if (info_ptr.text[i].compression >= ..)
|
|
if PNG_WRITE_zTXt_SUPPORTED eq 1
|
|
; Write compressed chunk
|
|
stdcall png_write_zTXt, edi, [eax+png_text.key],\
|
|
[eax+png_text.text], [eax+png_text.compression]
|
|
; Mark this chunk as written
|
|
mov dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_zTXt_WR
|
|
else
|
|
png_warning edi, 'Unable to write compressed text'
|
|
end if
|
|
jmp .end3
|
|
.end2:
|
|
cmp dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_NONE
|
|
jl .end3 ;else if (info_ptr.text[i].compression == ..)
|
|
if PNG_WRITE_tEXt_SUPPORTED eq 1
|
|
; Write uncompressed chunk
|
|
stdcall png_write_tEXt, edi, [eax+png_text.key],\
|
|
[eax+png_text.text], 0
|
|
; Mark this chunk as written
|
|
mov dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_NONE_WR
|
|
else
|
|
png_warning edi, 'Unable to write uncompressed text'
|
|
end if
|
|
.end3:
|
|
|
|
inc ecx
|
|
cmp ecx,[esi+png_info_def.num_text]
|
|
jl .cycle0
|
|
.cycle0end:
|
|
end if
|
|
if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
|
|
stdcall write_unknown_chunks, edi, esi, PNG_AFTER_IDAT
|
|
end if
|
|
.end0:
|
|
|
|
or dword[edi+png_struct.mode], PNG_AFTER_IDAT
|
|
|
|
; Write end of PNG file
|
|
stdcall png_write_IEND, edi
|
|
|
|
; This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
|
|
; and restored again in libpng-1.2.30, may cause some applications that
|
|
; do not set png_ptr->output_flush_fn to crash. If your application
|
|
; experiences a problem, please try building libpng with
|
|
; PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
|
|
; png-mng-implement at lists.sf.net .
|
|
|
|
if PNG_WRITE_FLUSH_SUPPORTED eq 1
|
|
if PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED eq 1
|
|
stdcall png_flush, edi
|
|
end if
|
|
end if
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
;void (png_timep ptime, struct tm * ttime)
|
|
align 4
|
|
proc png_convert_from_struct_tm, ptime:dword, ttime:dword
|
|
png_debug 1, 'in png_convert_from_struct_tm'
|
|
|
|
; ptime->year = (uint_16)(1900 + ttime->tm_year);
|
|
; ptime->month = (byte)(ttime->tm_mon + 1);
|
|
; ptime->day = (byte)ttime->tm_mday;
|
|
; ptime->hour = (byte)ttime->tm_hour;
|
|
; ptime->minute = (byte)ttime->tm_min;
|
|
; ptime->second = (byte)ttime->tm_sec;
|
|
ret
|
|
endp
|
|
|
|
;void (png_timep ptime, time_t ttime)
|
|
align 4
|
|
proc png_convert_from_time_t, ptime:dword, ttime:dword
|
|
; struct tm *tbuf;
|
|
|
|
png_debug 1, 'in png_convert_from_time_t'
|
|
|
|
; tbuf = gmtime(&ttime);
|
|
; png_convert_from_struct_tm(ptime, tbuf);
|
|
ret
|
|
endp
|
|
|
|
; Initialize png_ptr structure, and allocate any memory needed
|
|
;png_structp (charp user_png_ver, voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)
|
|
align 4
|
|
proc png_create_write_struct, user_png_ver:dword, error_ptr:dword, error_fn:dword, warn_fn:dword
|
|
if PNG_USER_MEM_SUPPORTED eq 1
|
|
stdcall png_create_png_struct, [user_png_ver], [error_ptr], [error_fn], [warn_fn], 0, 0, 0
|
|
;eax = png_ptr
|
|
end if ;USER_MEM
|
|
cmp eax,0
|
|
je .end0 ;if (..!=0)
|
|
; Set the zlib control values to defaults; they can be overridden by the
|
|
; application after the struct has been created.
|
|
|
|
mov dword[eax+png_struct.zbuffer_size], PNG_ZBUF_SIZE
|
|
|
|
; The 'zlib_strategy' setting is irrelevant because png_default_claim in
|
|
; pngwutil.asm defaults it according to whether or not filters will be
|
|
; used, and ignores this setting.
|
|
|
|
mov dword[eax+png_struct.zlib_strategy], PNG_Z_DEFAULT_STRATEGY
|
|
mov dword[eax+png_struct.zlib_level], PNG_Z_DEFAULT_COMPRESSION
|
|
mov dword[eax+png_struct.zlib_mem_level], 8
|
|
mov dword[eax+png_struct.zlib_window_bits], 15
|
|
mov dword[eax+png_struct.zlib_method], 8
|
|
|
|
if PNG_WRITE_COMPRESSED_TEXT_SUPPORTED eq 1
|
|
mov dword[eax+png_struct.zlib_text_strategy], PNG_TEXT_Z_DEFAULT_STRATEGY
|
|
mov dword[eax+png_struct.zlib_text_level], PNG_TEXT_Z_DEFAULT_COMPRESSION
|
|
mov dword[eax+png_struct.zlib_text_mem_level], 8
|
|
mov dword[eax+png_struct.zlib_text_window_bits], 15
|
|
mov dword[eax+png_struct.zlib_text_method], 8
|
|
end if
|
|
; This is a highly dubious configuration option; by default it is off,
|
|
; but it may be appropriate for private builds that are testing
|
|
; extensions not conformant to the current specification, or of
|
|
; applications that must not fail to write at all costs!
|
|
|
|
if PNG_BENIGN_WRITE_ERRORS_SUPPORTED eq 1
|
|
; In stable builds only warn if an application error can be completely
|
|
; handled.
|
|
|
|
or dword[eax+png_struct.flags], PNG_FLAG_BENIGN_ERRORS_WARN
|
|
end if
|
|
; App warnings are warnings in release (or release candidate) builds but
|
|
; are errors during development.
|
|
|
|
if PNG_RELEASE_BUILD eq 1
|
|
or dword[eax+png_struct.flags], PNG_FLAG_APP_WARNINGS_WARN
|
|
end if
|
|
; TODO: delay this, it can be done in png_init_io() (if the app doesn't
|
|
; do it itself) avoiding setting the default function if it is not
|
|
; required.
|
|
|
|
stdcall png_set_write_fn, eax, 0, 0, 0
|
|
.end0:
|
|
ret
|
|
endp
|
|
|
|
|
|
; Write a few rows of image data. If the image is interlaced,
|
|
; either you will have to write the 7 sub images, or, if you
|
|
; have called png_set_interlace_handling(), you will have to
|
|
; "write" the image seven times.
|
|
|
|
;void (png_structrp png_ptr, bytepp row, uint_32 num_rows)
|
|
align 4
|
|
proc png_write_rows uses ebx ecx edi, png_ptr:dword, row:dword, num_rows:dword
|
|
;locals
|
|
;i dd ? ;uint_32 ;row counter
|
|
;rp dd ? ;bytepp ;row pointer
|
|
;endl
|
|
png_debug 1, 'in png_write_rows'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if(..==0) return
|
|
|
|
; Loop through the rows
|
|
mov ecx,[num_rows]
|
|
cmp ecx,1
|
|
jl .end_f
|
|
mov ebx,[row]
|
|
@@: ;for (i = 0, rp = row; i < num_rows; i++, rp++)
|
|
stdcall png_write_row, edi, [ebx]
|
|
add ebx,4
|
|
loop @b
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; Write the image. You only need to call this function once, even
|
|
; if you are writing an interlaced image.
|
|
|
|
;void (png_structrp png_ptr, bytepp image)
|
|
align 4
|
|
proc png_write_image, png_ptr:dword, image:dword
|
|
pushad
|
|
;ebx ;bytepp ;points to current row
|
|
;ecx ;uint_32 ;row index
|
|
;edx ;int ;pass
|
|
;esi ;int ;num_pass
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
png_debug 1, 'in png_write_image'
|
|
|
|
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
|
|
; Initialize interlace handling. If image is not interlaced,
|
|
; this will set pass to 1
|
|
|
|
stdcall png_set_interlace_handling, edi
|
|
mov esi,eax
|
|
else
|
|
xor esi,esi
|
|
inc esi
|
|
end if
|
|
; Loop through passes
|
|
xor edx,edx
|
|
.cycle0: ;for (edx = 0; edx < esi; edx++)
|
|
cmp edx,esi
|
|
jge .cycle0end
|
|
; Loop through image
|
|
mov ebx,[image]
|
|
xor ecx,ecx
|
|
.cycle1: ;for (ecx = 0, ebx = image; ecx < png_ptr.height; ecx++, ebx++)
|
|
stdcall png_write_row, edi,[ebx]
|
|
inc ecx
|
|
add ebx,4
|
|
cmp ecx,[edi+png_struct.height]
|
|
jl .cycle1
|
|
;.cycle1end:
|
|
inc edx
|
|
jmp .cycle0
|
|
.cycle0end:
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
; Performs intrapixel differencing
|
|
;void (png_row_infop row_info, bytep row)
|
|
align 4
|
|
proc png_do_write_intrapixel uses eax ebx ecx edx edi, row_info:dword, row:dword
|
|
png_debug 1, 'in png_do_write_intrapixel'
|
|
|
|
mov ebx,[row_info]
|
|
movzx eax,byte[ebx+png_row_info.color_type]
|
|
and eax,PNG_COLOR_MASK_COLOR
|
|
jz .end_f ;if (..!=0)
|
|
;edx = bytes_per_pixel
|
|
mov ecx,[ebx+png_row_info.width] ;ecx = row_width
|
|
cmp byte[ebx+png_row_info.bit_depth],8 ;if (..==8)
|
|
jne .end0
|
|
; bytep rp;
|
|
; uint_32 i;
|
|
|
|
cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB
|
|
jne @f ;if (..==..)
|
|
mov edx,3-1 ;(-1) for stosb
|
|
jmp .end2
|
|
@@:
|
|
cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB_ALPHA
|
|
jne @f ;else if (..==..)
|
|
mov edx,4-1 ;(-1) for stosb
|
|
jmp .end2
|
|
@@:
|
|
jmp .end_f ;else return
|
|
.end2:
|
|
|
|
mov edi,[row]
|
|
align 4
|
|
.cycle0: ;for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
|
|
mov ax,word[edi]
|
|
sub al,ah
|
|
stosb ;*(rp) = (byte)(*rp - *(rp + 1))
|
|
mov ax,word[edi]
|
|
sub ah,al
|
|
mov byte[edi+1],ah ;*(rp + 2) = (byte)(*(rp + 2) - *(rp + 1))
|
|
add edi,edx
|
|
loop .cycle0
|
|
.cycle0end:
|
|
jmp .end_f
|
|
.end0:
|
|
|
|
if PNG_WRITE_16BIT_SUPPORTED eq 1
|
|
cmp byte[ebx+png_row_info.bit_depth],16 ;else if (..==16)
|
|
jne .end1
|
|
; bytep rp;
|
|
; uint_32 i;
|
|
|
|
cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB
|
|
jne @f ;if (..==..)
|
|
mov edx,6
|
|
jmp .end3
|
|
@@:
|
|
cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB_ALPHA
|
|
jne @f ;else if (..==..)
|
|
mov edx,8
|
|
jmp .end3
|
|
@@:
|
|
jmp .end_f ;else return
|
|
.end3:
|
|
|
|
mov edi,[row]
|
|
align 4
|
|
.cycle1: ;for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
|
|
; uint_32 s0 = (*(rp ) << 8) | *(rp + 1);
|
|
; uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);
|
|
; uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);
|
|
; uint_32 red = (uint_32)((s0 - s1) & 0xffffL);
|
|
; uint_32 blue = (uint_32)((s2 - s1) & 0xffffL);
|
|
; *(rp ) = (byte)(red >> 8);
|
|
; *(rp + 1) = (byte)red;
|
|
; *(rp + 4) = (byte)(blue >> 8);
|
|
; *(rp + 5) = (byte)blue;
|
|
add edi,edx
|
|
loop .cycle1
|
|
.cycle1end:
|
|
.end1:
|
|
end if ;WRITE_16BIT
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; Called by user to write a row of image data
|
|
;void (png_structrp png_ptr, bytep row)
|
|
align 4
|
|
proc png_write_row, png_ptr:dword, row:dword
|
|
locals
|
|
; 1.5.6: moved from png_struct to be a local structure:
|
|
row_info png_row_info
|
|
endl
|
|
pushad
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if(..==0) return
|
|
|
|
; png_debug2(1, "in png_write_row (row %u, pass %d)",
|
|
; png_ptr->row_number, png_ptr->pass);
|
|
png_debug1 1, 'in png_write_row (row %u)',[edi+png_struct.row_number]
|
|
|
|
; Initialize transformations and other stuff if first time
|
|
cmp dword[edi+png_struct.row_number],0
|
|
jne .end0
|
|
cmp byte[edi+png_struct.pass],0
|
|
jne .end0 ;if(..==0 && ..==0)
|
|
|
|
; Make sure we wrote the header info
|
|
mov eax,[edi+png_struct.mode]
|
|
and eax,PNG_WROTE_INFO_BEFORE_PLTE
|
|
jnz @f ;if(..==0)
|
|
png_error edi, 'png_write_info was never called before png_write_row'
|
|
@@:
|
|
|
|
; Check for transforms that have been set but were defined out
|
|
if (PNG_WRITE_INVERT_SUPPORTED eq 0) & (PNG_READ_INVERT_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_INVERT_MONO
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_INVERT_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
if (PNG_WRITE_FILLER_SUPPORTED eq 0) & (PNG_READ_FILLER_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_FILLER
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_FILLER_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
if (PNG_WRITE_PACKSWAP_SUPPORTED eq 0) & (PNG_READ_PACKSWAP_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_PACKSWAP
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_PACKSWAP_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
if (PNG_WRITE_PACK_SUPPORTED eq 0) & (PNG_READ_PACK_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_PACK
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_PACK_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
if (PNG_WRITE_SHIFT_SUPPORTED eq 0) & (PNG_READ_SHIFT_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_SHIFT
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_SHIFT_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
if (PNG_WRITE_BGR_SUPPORTED eq 0) & (PNG_READ_BGR_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_BGR
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_BGR_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
if (PNG_WRITE_SWAP_SUPPORTED eq 0) & (PNG_READ_SWAP_SUPPORTED eq 1)
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_SWAP_BYTES
|
|
jz @f ;if(..!=0)
|
|
png_warning edi, 'PNG_WRITE_SWAP_SUPPORTED is not defined'
|
|
@@:
|
|
end if
|
|
|
|
stdcall png_write_start_row, edi
|
|
.end0:
|
|
|
|
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
|
|
; If interlaced and not interested in row, return
|
|
cmp byte[edi+png_struct.interlaced],0
|
|
je .end1
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_INTERLACE
|
|
jz .end1 ;if(..!=0 && ..!=0)
|
|
cmp byte[edi+png_struct.pass],0
|
|
jne @f
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x07
|
|
jz .end1 ;if (..!=0)
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
cmp byte[edi+png_struct.pass],1
|
|
jne @f
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x07
|
|
jnz .end2
|
|
cmp dword[edi+png_struct.width],5
|
|
jge .end1 ;if (..!=0 || ..<..)
|
|
.end2:
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
cmp byte[edi+png_struct.pass],2
|
|
jne @f
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x07
|
|
cmp eax,4
|
|
je .end1 ;if (..!=..)
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
cmp byte[edi+png_struct.pass],3
|
|
jne @f
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x03
|
|
jnz .end3
|
|
cmp dword[edi+png_struct.width],3
|
|
jge .end1 ;if (..!=0 || ..<..)
|
|
.end3:
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
cmp byte[edi+png_struct.pass],4
|
|
jne @f
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x03
|
|
cmp eax,2
|
|
je .end1 ;if (..!=..)
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
cmp byte[edi+png_struct.pass],5
|
|
jne @f
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x01
|
|
jnz .end4
|
|
cmp dword[edi+png_struct.width],2
|
|
jge .end1 ;if (..!=0 || ..<..)
|
|
.end4:
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
cmp byte[edi+png_struct.pass],6
|
|
jne .end1
|
|
mov eax,[edi+png_struct.row_number]
|
|
and eax,0x01
|
|
jnz .end1 ;if (..==0)
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
.end1:
|
|
end if
|
|
|
|
; Set up row info for transformations
|
|
mov ebx,ebp
|
|
sub ebx,sizeof.png_row_info
|
|
mov al,byte[edi+png_struct.color_type]
|
|
mov byte[ebx+png_row_info.color_type],al
|
|
mov eax,[edi+png_struct.usr_width]
|
|
mov [ebx+png_row_info.width],eax
|
|
movzx eax,byte[edi+png_struct.usr_channels]
|
|
mov byte[ebx+png_row_info.channels],al
|
|
movzx ecx,byte[edi+png_struct.usr_bit_depth]
|
|
mov byte[ebx+png_row_info.bit_depth],cl
|
|
imul eax,ecx ;.bit_depth * .channels
|
|
mov byte[ebx+png_row_info.pixel_depth],al
|
|
PNG_ROWBYTES eax, [ebx+png_row_info.width]
|
|
mov [ebx+png_row_info.rowbytes], eax
|
|
|
|
push eax
|
|
movzx eax,byte[ebx+png_row_info.color_type]
|
|
png_debug1 3, 'row_info->color_type = %d', eax
|
|
png_debug1 3, 'row_info->width = %u', [ebx+png_row_info.width]
|
|
movzx eax,byte[ebx+png_row_info.channels]
|
|
png_debug1 3, 'row_info->channels = %d', eax
|
|
movzx eax,byte[ebx+png_row_info.bit_depth]
|
|
png_debug1 3, 'row_info->bit_depth = %d', eax
|
|
movzx eax,byte[ebx+png_row_info.pixel_depth]
|
|
png_debug1 3, 'row_info->pixel_depth = %d', eax
|
|
png_debug1 3, 'row_info->rowbytes = %lu', [ebx+png_row_info.rowbytes]
|
|
pop eax
|
|
|
|
; Copy user's row into buffer, leaving room for filter byte.
|
|
push edi
|
|
mov edi,[edi+png_struct.row_buf]
|
|
inc edi
|
|
mov esi,[row]
|
|
mov ecx,eax
|
|
rep movsb ;memcpy(...
|
|
pop edi
|
|
|
|
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
|
|
; Handle interlacing
|
|
cmp byte[edi+png_struct.interlaced],0
|
|
je @f
|
|
cmp byte[edi+png_struct.pass],6
|
|
jge @f
|
|
mov eax,[edi+png_struct.transformations]
|
|
and eax,PNG_INTERLACE
|
|
jz @f ;if (.. && ..<.. && ..!=0)
|
|
movzx eax,byte[edi+png_struct.pass]
|
|
push eax
|
|
mov eax,[edi+png_struct.row_buf]
|
|
inc eax
|
|
stdcall png_do_write_interlace, ebx, eax ;, ...pass
|
|
; This should always get caught above, but still ...
|
|
cmp dword[ebx+png_row_info.width],0
|
|
jne @f ;if (..==0)
|
|
stdcall png_write_finish_row, edi
|
|
jmp .end_f
|
|
@@:
|
|
end if
|
|
|
|
if PNG_WRITE_TRANSFORMS_SUPPORTED eq 1
|
|
; Handle other transformations
|
|
cmp dword[edi+png_struct.transformations],0
|
|
je @f ;if (..!=0)
|
|
stdcall png_do_write_transformations, edi, ebx
|
|
@@:
|
|
end if
|
|
|
|
; At this point the row_info pixel depth must match the 'transformed' depth,
|
|
; which is also the output depth.
|
|
|
|
mov al,[ebx+png_row_info.pixel_depth]
|
|
cmp al,[edi+png_struct.pixel_depth]
|
|
jne @f
|
|
cmp al,[edi+png_struct.transformed_pixel_depth]
|
|
je .end5
|
|
@@: ;if (..!=.. || ..!=..)
|
|
png_error edi, 'internal write transform logic error'
|
|
.end5:
|
|
|
|
if PNG_MNG_FEATURES_SUPPORTED eq 1
|
|
; Write filter_method 64 (intrapixel differencing) only if
|
|
; 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
|
|
; 2. Libpng did not write a PNG signature (this filter_method is only
|
|
; used in PNG datastreams that are embedded in MNG datastreams) and
|
|
; 3. The application called png_permit_mng_features with a mask that
|
|
; included PNG_FLAG_MNG_FILTER_64 and
|
|
; 4. The filter_method is 64 and
|
|
; 5. The color_type is RGB or RGBA
|
|
|
|
mov eax,[edi+png_struct.mng_features_permitted]
|
|
and eax,PNG_FLAG_MNG_FILTER_64
|
|
jz @f
|
|
cmp byte[edi+png_struct.filter_type],PNG_INTRAPIXEL_DIFFERENCING
|
|
jne @f ;if (..!=0 && ..==..)
|
|
; Intrapixel differencing
|
|
mov eax,[edi+png_struct.row_buf]
|
|
inc eax
|
|
stdcall png_do_write_intrapixel, ebx, eax
|
|
@@:
|
|
end if
|
|
|
|
; Added at libpng-1.5.10
|
|
if PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED eq 1
|
|
; Check for out-of-range palette index
|
|
cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_PALETTE
|
|
jne @f
|
|
cmp dword[edi+png_struct.num_palette_max],0
|
|
jl @f ;if (..==.. && ..>=0)
|
|
stdcall png_do_check_palette_indexes, edi, ebx
|
|
@@:
|
|
end if
|
|
|
|
; Find a filter if necessary, filter the row and write it out.
|
|
mov ebx,ebp
|
|
sub ebx,sizeof.png_row_info
|
|
stdcall png_write_find_filter, edi, ebx
|
|
|
|
cmp dword[edi+png_struct.write_row_fn],0
|
|
je .end_f ;if (..!=0)
|
|
movzx eax,byte[edi+png_struct.pass]
|
|
stdcall dword[edi+png_struct.write_row_fn], edi, [edi+png_struct.row_number], eax
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
; Set the automatic flush interval or 0 to turn flushing off
|
|
;void (png_structrp png_ptr, int nrows)
|
|
align 4
|
|
proc png_set_flush uses eax edi, png_ptr:dword, nrows:dword
|
|
png_debug 1, 'in png_set_flush'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
mov eax,[nrows]
|
|
cmp eax,0
|
|
jge @f ;(nrows < 0 ? 0 : nrows)
|
|
xor eax,eax
|
|
@@:
|
|
mov [edi+png_struct.flush_dist],eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; Flush the current output buffers now
|
|
;void (png_structrp png_ptr)
|
|
align 4
|
|
proc png_write_flush uses eax edi, png_ptr:dword
|
|
png_debug 1, 'in png_write_flush'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
; We have already written out all of the data
|
|
mov eax,[edi+png_struct.num_rows]
|
|
cmp [edi+png_struct.row_number],eax
|
|
jge .end_f ;if (..>=..) return
|
|
|
|
stdcall png_compress_IDAT, 0, 0, Z_SYNC_FLUSH
|
|
mov dword[edi+png_struct.flush_rows],0
|
|
stdcall png_flush, edi
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
; Free any memory used in png_ptr struct without freeing the struct itself.
|
|
;void (png_structrp png_ptr)
|
|
align 4
|
|
proc png_write_destroy uses eax edi, png_ptr:dword
|
|
png_debug 1, 'in png_write_destroy'
|
|
|
|
; Free any memory zlib uses
|
|
mov edi,[png_ptr]
|
|
mov eax,[edi+png_struct.flags]
|
|
and eax,PNG_FLAG_ZSTREAM_INITIALIZED
|
|
jz @f ;if (..!=0)
|
|
mov eax,edi
|
|
add eax,png_struct.zstream
|
|
stdcall [deflateEnd], eax
|
|
@@:
|
|
|
|
; Free our memory. png_free checks NULL for us.
|
|
mov eax,edi
|
|
add eax,png_struct.zbuffer_list
|
|
stdcall png_free_buffer_list, edi, eax
|
|
stdcall png_free, edi, [edi+png_struct.row_buf]
|
|
mov dword[edi+png_struct.row_buf],0
|
|
if PNG_WRITE_FILTER_SUPPORTED eq 1
|
|
stdcall png_free, edi, [edi+png_struct.prev_row]
|
|
stdcall png_free, edi, [edi+png_struct.try_row]
|
|
stdcall png_free, edi, [edi+png_struct.tst_row]
|
|
mov dword[edi+png_struct.prev_row],0
|
|
mov dword[edi+png_struct.try_row],0
|
|
mov dword[edi+png_struct.tst_row],0
|
|
end if
|
|
|
|
if PNG_SET_UNKNOWN_CHUNKS_SUPPORTED eq 1
|
|
stdcall png_free, edi, [edi+png_struct.chunk_list]
|
|
mov dword[edi+png_struct.chunk_list],0
|
|
end if
|
|
|
|
; The error handling and memory handling information is left intact at this
|
|
; point: the jmp_buf may still have to be freed. See png_destroy_png_struct
|
|
; for how this happens.
|
|
ret
|
|
endp
|
|
|
|
; Free all memory used by the write.
|
|
; In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for
|
|
; *png_ptr_ptr. Prior to 1.6.0 it would accept such a value and it would free
|
|
; the passed in info_structs but it would quietly fail to free any of the data
|
|
; inside them. In 1.6.0 it quietly does nothing (it has to be quiet because it
|
|
; has no png_ptr.)
|
|
|
|
;void (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
|
|
align 4
|
|
proc png_destroy_write_struct uses edi esi, png_ptr_ptr:dword, info_ptr_ptr:dword
|
|
png_debug 1, 'in png_destroy_write_struct'
|
|
|
|
mov esi,[png_ptr_ptr]
|
|
cmp esi,0
|
|
je @f ;if (..!=0)
|
|
mov edi,[esi]
|
|
|
|
cmp edi,0
|
|
je @f ;if (..!=0) ;added in libpng 1.6.0
|
|
stdcall png_destroy_info_struct, edi, [info_ptr_ptr]
|
|
|
|
mov dword[esi],0
|
|
stdcall png_write_destroy, edi
|
|
stdcall png_destroy_png_struct, edi
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
; Allow the application to select one or more row filters to use.
|
|
;void (png_structrp png_ptr, int method, int filters)
|
|
align 4
|
|
proc png_set_filter uses eax ebx ecx edi, png_ptr:dword, method:dword, filters:dword
|
|
png_debug 1, 'in png_set_filter'
|
|
pushad
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
if PNG_MNG_FEATURES_SUPPORTED eq 1
|
|
mov eax,[edi+png_struct.mng_features_permitted]
|
|
and eax,PNG_FLAG_MNG_FILTER_64
|
|
je @f
|
|
cmp dword[method], PNG_INTRAPIXEL_DIFFERENCING
|
|
jne @f ;if (..!=0 && ..==..)
|
|
mov dword[method], PNG_FILTER_TYPE_BASE
|
|
@@:
|
|
end if
|
|
cmp dword[method], PNG_FILTER_TYPE_BASE
|
|
jne .end0 ;if (..==..)
|
|
mov ebx,[filters]
|
|
and ebx,PNG_ALL_FILTERS or 0x07 ;switch (..)
|
|
|
|
if PNG_WRITE_FILTER_SUPPORTED eq 1
|
|
cmp ebx,5
|
|
je .end2
|
|
cmp ebx,6
|
|
je .end2
|
|
cmp ebx,7
|
|
je .end2
|
|
jmp @f
|
|
.end2:
|
|
cStr ,'Unknown row filter for method 0'
|
|
stdcall png_app_error, edi, eax
|
|
; FALL THROUGH
|
|
@@:
|
|
end if ;WRITE_FILTER
|
|
cmp ebx,PNG_FILTER_VALUE_NONE
|
|
jne @f
|
|
mov byte[edi+png_struct.do_filter],PNG_FILTER_NONE
|
|
jmp .end1
|
|
@@:
|
|
if PNG_WRITE_FILTER_SUPPORTED eq 1
|
|
cmp ebx,PNG_FILTER_VALUE_SUB
|
|
jne @f
|
|
mov byte[edi+png_struct.do_filter],PNG_FILTER_SUB
|
|
jmp .end1
|
|
@@:
|
|
cmp ebx,PNG_FILTER_VALUE_UP
|
|
jne @f
|
|
mov byte[edi+png_struct.do_filter],PNG_FILTER_UP
|
|
jmp .end1
|
|
@@:
|
|
cmp ebx,PNG_FILTER_VALUE_AVG
|
|
jne @f
|
|
mov byte[edi+png_struct.do_filter],PNG_FILTER_AVG
|
|
jmp .end1
|
|
@@:
|
|
cmp ebx,PNG_FILTER_VALUE_PAETH
|
|
jne @f
|
|
mov byte[edi+png_struct.do_filter],PNG_FILTER_PAETH
|
|
jmp .end1
|
|
@@: ;default:
|
|
mov eax,[filters]
|
|
mov byte[edi+png_struct.do_filter],al
|
|
jmp .end1
|
|
else
|
|
@@: ;default:
|
|
cStr ,'Unknown row filter for method 0'
|
|
stdcall png_app_error edi, eax
|
|
end if ;WRITE_FILTER
|
|
.end1:
|
|
|
|
if PNG_WRITE_FILTER_SUPPORTED eq 1
|
|
; If we have allocated the row_buf, this means we have already started
|
|
; with the image and we should have allocated all of the filter buffers
|
|
; that have been selected. If prev_row isn't already allocated, then
|
|
; it is too late to start using the filters that need it, since we
|
|
; will be missing the data in the previous row. If an application
|
|
; wants to start and stop using particular filters during compression,
|
|
; it should start out with all of the filters, and then remove them
|
|
; or add them back after the start of compression.
|
|
|
|
; NOTE: this is a nasty constraint on the code, because it means that the
|
|
; prev_row buffer must be maintained even if there are currently no
|
|
; 'prev_row' requiring filters active.
|
|
|
|
cmp dword[edi+png_struct.row_buf],0
|
|
je .end3 ;if (..!=0)
|
|
;ebx = num_filters
|
|
;ecx = buf_size
|
|
|
|
; Repeat the checks in png_write_start_row; 1 pixel high or wide
|
|
; images cannot benefit from certain filters. If this isn't done here
|
|
; the check below will fire on 1 pixel high images.
|
|
|
|
cmp dword[edi+png_struct.height],1
|
|
jne @f ;if (..==..)
|
|
and dword[filters],not (PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH)
|
|
@@:
|
|
cmp dword[edi+png_struct.width],1
|
|
jne @f ;if (..==..)
|
|
and dword[filters],not (PNG_FILTER_SUB or PNG_FILTER_AVG or PNG_FILTER_PAETH)
|
|
@@:
|
|
mov eax,[filters]
|
|
and eax,PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH
|
|
jz @f
|
|
cmp dword[edi+png_struct.prev_row],0
|
|
je @f;if (..!=0 && ..==0)
|
|
; This is the error case, however it is benign - the previous row
|
|
; is not available so the filter can't be used. Just warn here.
|
|
|
|
png_app_warning edi, 'png_set_filter: UP/AVG/PAETH cannot be added after start'
|
|
and dword[filters],not (PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH)
|
|
@@:
|
|
|
|
xor ebx,ebx
|
|
|
|
mov eax,[filters]
|
|
and eax,PNG_FILTER_SUB
|
|
jz @f ;if (..)
|
|
inc ebx
|
|
@@:
|
|
mov eax,[filters]
|
|
and eax,PNG_FILTER_UP
|
|
jz @f ;if (..)
|
|
inc ebx
|
|
@@:
|
|
mov eax,[filters]
|
|
and eax,PNG_FILTER_AVG
|
|
jz @f ;if (..)
|
|
inc ebx
|
|
@@:
|
|
mov eax,[filters]
|
|
and eax,PNG_FILTER_PAETH
|
|
jz @f ;if (..)
|
|
inc ebx
|
|
@@:
|
|
; Allocate needed row buffers if they have not already been
|
|
; allocated.
|
|
|
|
movzx eax,byte[edi+png_struct.usr_channels]
|
|
movzx ecx,byte[edi+png_struct.usr_bit_depth]
|
|
imul eax,ecx ;.bit_depth * .channels
|
|
mov ecx,[edi+png_struct.width]
|
|
inc ecx
|
|
PNG_ROWBYTES eax, ecx
|
|
mov ecx, eax
|
|
|
|
cmp dword[edi+png_struct.try_row],0
|
|
jne @f ;if (..==0)
|
|
stdcall png_malloc, edi, ecx
|
|
mov [edi+png_struct.try_row],eax
|
|
@@:
|
|
|
|
cmp ebx,1
|
|
jle .end3 ;if (..>..)
|
|
cmp dword[edi+png_struct.tst_row],0
|
|
jne .end3 ;if (..==0)
|
|
stdcall png_malloc, edi, ecx
|
|
mov [edi+png_struct.tst_row],eax
|
|
.end3:
|
|
mov eax,[filters]
|
|
mov byte[edi+png_struct.do_filter],al
|
|
end if
|
|
jmp .end_f
|
|
.end0: ;else
|
|
png_error edi, 'Unknown custom filter method'
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
; Provide floating and fixed point APIs
|
|
;void (png_structrp png_ptr, int heuristic_method,
|
|
; int num_weights, png_const_doublep filter_weights, png_const_doublep filter_costs)
|
|
align 4
|
|
proc png_set_filter_heuristics, png_ptr:dword, heuristic_method:dword, num_weights:dword, filter_weights:dword, filter_costs:dword
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int heuristic_method,
|
|
; int num_weights, png_const_fixed_point_p filter_weights,
|
|
; png_const_fixed_point_p filter_costs)
|
|
align 4
|
|
proc png_set_filter_heuristics_fixed, png_ptr:dword, heuristic_method:dword, num_weights:dword, filter_weights:dword, filter_costs:dword
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int level)
|
|
align 4
|
|
proc png_set_compression_level uses edi, png_ptr:dword, level:dword
|
|
png_debug 1, 'in png_set_compression_level'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je @f ;if (..==0) return
|
|
|
|
m2m [edi+png_struct.zlib_level], [level]
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int mem_level)
|
|
align 4
|
|
proc png_set_compression_mem_level uses edi, png_ptr:dword, mem_level:dword
|
|
png_debug 1, 'in png_set_compression_mem_level'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je @f ;if (..==0) return
|
|
|
|
m2m [edi+png_struct.zlib_mem_level], [mem_level]
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int strategy)
|
|
align 4
|
|
proc png_set_compression_strategy uses edi, png_ptr:dword, strategy:dword
|
|
png_debug 1, 'in png_set_compression_strategy'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
; The flag setting here prevents the libpng dynamic selection of strategy.
|
|
|
|
or dword[edi+png_struct.flags], PNG_FLAG_ZLIB_CUSTOM_STRATEGY
|
|
m2m [edi+png_struct.zlib_strategy], [strategy]
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
|
|
; smaller value of window_bits if it can do so safely.
|
|
|
|
;void (png_structrp png_ptr, int window_bits)
|
|
align 4
|
|
proc png_set_compression_window_bits uses eax edi, png_ptr:dword, window_bits:dword
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
; Prior to 1.6.0 this would warn but then set the window_bits value. This
|
|
; meant that negative window bits values could be selected that would cause
|
|
; libpng to write a non-standard PNG file with raw deflate or gzip
|
|
; compressed IDAT or ancillary chunks. Such files can be read and there is
|
|
; no warning on read, so this seems like a very bad idea.
|
|
|
|
mov eax,[window_bits]
|
|
cmp eax,15
|
|
jle @f ;if (..>..)
|
|
png_warning edi, 'Only compression windows <= 32k supported by PNG'
|
|
mov eax,15
|
|
jmp .end0
|
|
@@: ;else if (..<..)
|
|
cmp eax,8
|
|
jge @f
|
|
png_warning edi, 'Only compression windows >= 256 supported by PNG'
|
|
mov eax,8
|
|
.end0:
|
|
|
|
mov [edi+png_struct.zlib_window_bits],eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int method)
|
|
align 4
|
|
proc png_set_compression_method uses eax edi, png_ptr:dword, method:dword
|
|
png_debug 1, 'in png_set_compression_method'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
; This would produce an invalid PNG file if it worked, but it doesn't and
|
|
; deflate will fault it, so it is harmless to just warn here.
|
|
|
|
mov eax,[method]
|
|
cmp eax,8
|
|
je @f ;if (..!=..)
|
|
png_warning edi, 'Only compression method 8 is supported by PNG'
|
|
@@:
|
|
mov [edi+png_struct.zlib_method],eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; The following were added to libpng-1.5.4
|
|
if PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED eq 1
|
|
;void (png_structrp png_ptr, int level)
|
|
align 4
|
|
proc png_set_text_compression_level uses edi, png_ptr:dword, level:dword
|
|
png_debug 1, 'in png_set_text_compression_level'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je @f ;if (..==0) return
|
|
|
|
m2m [edi+png_struct.zlib_text_level], [level]
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int mem_level)
|
|
align 4
|
|
proc png_set_text_compression_mem_level uses edi, png_ptr:dword, mem_level:dword
|
|
png_debug 1, 'in png_set_text_compression_mem_level'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je @f ;if (..==0) return
|
|
|
|
m2m [edi+png_struct.zlib_text_mem_level], [mem_level]
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int strategy)
|
|
align 4
|
|
proc png_set_text_compression_strategy uses edi, png_ptr:dword, strategy:dword
|
|
png_debug 1, 'in png_set_text_compression_strategy'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
m2m [edi+png_struct.zlib_text_strategy], [strategy]
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
|
|
; smaller value of window_bits if it can do so safely.
|
|
|
|
;void (png_structrp png_ptr, int window_bits)
|
|
align 4
|
|
proc png_set_text_compression_window_bits uses eax edi, png_ptr:dword, window_bits:dword
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
mov eax,[window_bits]
|
|
cmp eax,15
|
|
jle @f ;if (..>..)
|
|
png_warning edi, 'Only compression windows <= 32k supported by PNG'
|
|
mov eax,15
|
|
jmp .end0
|
|
@@: ;else if (..<..)
|
|
cmp eax,8
|
|
jge @f
|
|
png_warning edi, 'Only compression windows >= 256 supported by PNG'
|
|
mov eax,8
|
|
.end0:
|
|
|
|
mov [edi+png_struct.zlib_text_window_bits],eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, int method)
|
|
align 4
|
|
proc png_set_text_compression_method uses edi, png_ptr:dword, method:dword
|
|
png_debug 1, 'in png_set_text_compression_method'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je .end_f ;if (..==0) return
|
|
|
|
cmp dword[method],8
|
|
je @f ;if (..!=..)
|
|
png_warning edi, 'Only compression method 8 is supported by PNG'
|
|
@@:
|
|
m2m [edi+png_struct.zlib_text_method], [method]
|
|
.end_f:
|
|
ret
|
|
endp
|
|
end if ;WRITE_CUSTOMIZE_ZTXT_COMPRESSION
|
|
; end of API added to libpng-1.5.4
|
|
|
|
;void (png_structrp png_ptr, png_write_status_ptr write_row_fn)
|
|
align 4
|
|
proc png_set_write_status_fn uses edi, png_ptr:dword, write_row_fn:dword
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je @f ;if (..==0) return
|
|
m2m [edi+png_struct.write_row_fn], [write_row_fn]
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, png_user_transform_ptr write_user_transform_fn)
|
|
align 4
|
|
proc png_set_write_user_transform_fn uses edi, png_ptr:dword, write_user_transform_fn:dword
|
|
png_debug 1, 'in png_set_write_user_transform_fn'
|
|
|
|
mov edi,[png_ptr]
|
|
cmp edi,0
|
|
je @f ;if (..==0) return
|
|
or dword[edi+png_struct.transformations], PNG_USER_TRANSFORM
|
|
m2m [edi+png_struct.write_user_transform_fn], [write_user_transform_fn]
|
|
@@:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structrp png_ptr, png_inforp info_ptr, int transforms, voidp params)
|
|
align 4
|
|
proc png_write_png, png_ptr:dword, info_ptr:dword, transforms:dword, params:dword
|
|
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
|
|
|
|
and dword[esi+png_info_def.valid],PNG_INFO_IDAT
|
|
cmp esi,0 ;if(..==0)
|
|
jne @f
|
|
cStr ,'no rows for png_write_image to write'
|
|
stdcall png_app_error edi, eax
|
|
jmp .end_f ;return
|
|
@@:
|
|
|
|
; Write the file header information.
|
|
stdcall png_write_info, edi, esi
|
|
|
|
; ------ these transformations don't touch the info structure -------
|
|
|
|
; Invert monochrome pixels
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_INVERT_MONO
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_INVERT_SUPPORTED eq 1
|
|
stdcall png_set_invert_mono,edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_INVERT_MONO not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Shift the pixels up to a legal bit depth and fill in
|
|
; as appropriate to correctly scale the image.
|
|
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_SHIFT
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_SHIFT_SUPPORTED eq 1
|
|
mov eax,[esi+png_info_def.valid]
|
|
and eax,PNG_INFO_sBIT
|
|
jz @f ;if(..!=0)
|
|
mov eax,esi
|
|
add eax,png_info_def.sig_bit
|
|
stdcall png_set_shift, edi, eax
|
|
else
|
|
cStr ,'PNG_TRANSFORM_SHIFT not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Pack pixels into bytes
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_PACKING
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_PACK_SUPPORTED eq 1
|
|
stdcall png_set_packing, edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_PACKING not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Swap location of alpha bytes from ARGB to RGBA
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_SWAP_ALPHA
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_SWAP_ALPHA_SUPPORTED eq 1
|
|
stdcall png_set_swap_alpha, edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_SWAP_ALPHA not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Remove a filler (X) from XRGB/RGBX/AG/GA into to convert it into
|
|
; RGB, note that the code expects the input color type to be G or RGB; no
|
|
; alpha channel.
|
|
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_STRIP_FILLER_AFTER or PNG_TRANSFORM_STRIP_FILLER_BEFORE
|
|
jz .end_0 ;if(..!=0)
|
|
if PNG_WRITE_FILLER_SUPPORTED eq 1
|
|
and eax,PNG_TRANSFORM_STRIP_FILLER_AFTER
|
|
jz .end_1 ;if(..!=0)
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_STRIP_FILLER_BEFORE
|
|
jz @f ;if(..!=0)
|
|
cStr ,'PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported'
|
|
stdcall png_app_error edi, eax
|
|
@@:
|
|
|
|
; Continue if ignored - this is the pre-1.6.10 behavior
|
|
stdcall png_set_filler, edi, 0, PNG_FILLER_AFTER
|
|
jmp .end_0
|
|
.end_1: ;else if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
|
|
stdcall png_set_filler, edi, 0, PNG_FILLER_BEFORE
|
|
else
|
|
cStr ,'PNG_TRANSFORM_STRIP_FILLER not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
.end_0:
|
|
|
|
; Flip BGR pixels to RGB
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_BGR
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_BGR_SUPPORTED eq 1
|
|
stdcall png_set_bgr, edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_BGR not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Swap bytes of 16-bit files to most significant byte first
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_SWAP_ENDIAN
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_SWAP_SUPPORTED eq 1
|
|
stdcall png_set_swap, edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_SWAP_ENDIAN not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_PACKSWAP
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_PACKSWAP_SUPPORTED eq 1
|
|
stdcall png_set_packswap, edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_PACKSWAP not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; Invert the alpha channel from opacity to transparency
|
|
mov eax,[transforms]
|
|
and eax,PNG_TRANSFORM_INVERT_ALPHA
|
|
jz @f ;if(..!=0)
|
|
if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
|
|
stdcall png_set_invert_alpha, edi
|
|
else
|
|
cStr ,'PNG_TRANSFORM_INVERT_ALPHA not supported'
|
|
stdcall png_app_error edi, eax
|
|
end if
|
|
@@:
|
|
|
|
; ----------------------- end of transformations -------------------
|
|
|
|
; Write the bits
|
|
stdcall png_write_image, edi, dword[esi+png_info_def.row_pointers]
|
|
|
|
; It is REQUIRED to call this to finish writing the rest of the file
|
|
stdcall png_write_end, edi, esi
|
|
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
if PNG_SIMPLIFIED_WRITE_SUPPORTED eq 1
|
|
; Initialize the write structure - general purpose utility.
|
|
;int (png_imagep image)
|
|
align 4
|
|
proc png_image_write_init uses ebx ecx edx edi esi, image:dword
|
|
mov ebx,[image]
|
|
stdcall png_create_write_struct, PNG_LIBPNG_VER_STRING, ebx, png_safe_error, png_safe_warning
|
|
;eax = png_ptr
|
|
|
|
cmp eax,0
|
|
je .end0 ;if (..!=0)
|
|
mov edi,eax
|
|
stdcall png_create_info_struct, edi
|
|
;eax = info_ptr
|
|
|
|
cmp eax,0
|
|
je .end1 ;if (..!=0)
|
|
mov esi,eax
|
|
stdcall png_malloc_warn, edi, sizeof.png_control
|
|
;control = eax
|
|
|
|
cmp eax,0
|
|
je .end2 ;if (..!=0)
|
|
push eax
|
|
mov edx,edi ; edx = png_ptr
|
|
mov ecx,sizeof.png_control
|
|
mov edi,eax
|
|
xor eax,eax
|
|
rep stosb ;memset(control, 0, (sizeof.control))
|
|
pop eax
|
|
|
|
mov [eax+png_control.png_ptr], edx
|
|
mov [eax+png_control.info_ptr], esi
|
|
mov [eax+png_control.for_write], 1
|
|
|
|
mov [ebx+png_image.opaque], eax
|
|
xor eax,eax
|
|
inc eax
|
|
jmp .end_f
|
|
.end2:
|
|
|
|
; Error clean up
|
|
push esi
|
|
mov esi,esp
|
|
stdcall png_destroy_info_struct, edi, esi
|
|
add esp,4
|
|
.end1:
|
|
|
|
push edi
|
|
mov edi,esp
|
|
stdcall png_destroy_write_struct, edi, 0
|
|
add esp,4
|
|
.end0:
|
|
|
|
std_png_image_error ebx, 'png_image_write_: out of memory'
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
; Arguments to png_image_write_main:
|
|
struct png_image_write_control
|
|
; Arguments:
|
|
image dd ? ;png_imagep
|
|
buffer dd ? ;png_const_voidp
|
|
row_stride dd ? ;int_32
|
|
colormap dd ? ;png_const_voidp
|
|
convert_to_8bit dd ? ;int
|
|
; Local variables:
|
|
first_row dd ? ;png_const_voidp
|
|
row_bytes dd ? ;ptrdiff_t
|
|
local_row dd ? ;voidp
|
|
; Byte count for memory writing
|
|
memory dd ? ;bytep
|
|
memory_bytes dd ? ;png_alloc_size_t ;not used for STDIO
|
|
output_bytes dd ? ;png_alloc_size_t ;running total
|
|
ends
|
|
|
|
; Write uint_16 input to a 16-bit PNG; the png_ptr has already been set to
|
|
; do any necessary byte swapping. The component order is defined by the
|
|
; png_image format value.
|
|
|
|
;int (voidp argument)
|
|
align 4
|
|
proc png_write_image_16bit uses ebx ecx edx, argument:dword
|
|
locals
|
|
display dd ? ;png_image_write_control* ;= argument
|
|
image dd ? ;png_imagep ;= display->image
|
|
png_ptr dd ? ;png_structrp ;= image->opaque->png_ptr
|
|
input_row dd ? ;const_uint_16p ;= display->first_row
|
|
output_row dd ? ;uint_16p ;= display->local_row
|
|
row_end dd ? ;uint_16p
|
|
channels dd ? ;const int ;= (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
|
|
aindex dd 0 ;int ;= 0
|
|
y dd ? ;uint_32 ;= image->height
|
|
endl
|
|
mov ebx,[argument]
|
|
mov [display],ebx
|
|
mov edx,[ebx+png_image_write_control.image]
|
|
mov [image],edx
|
|
mov ecx,[edx+png_image.opaque]
|
|
mov ecx,[ecx+png_control.png_ptr]
|
|
mov [png_ptr],ecx
|
|
mov ecx,[ebx+png_image_write_control.first_row]
|
|
mov [input_row],ecx
|
|
mov ecx,[ebx+png_image_write_control.local_row]
|
|
mov [output_row],ecx
|
|
|
|
mov ecx,1
|
|
mov eax,[edx+png_image.format]
|
|
and eax,PNG_FORMAT_FLAG_COLOR
|
|
jz @f
|
|
mov ecx,3
|
|
@@:
|
|
mov [channels],ecx
|
|
mov eax,[edx+png_image.height]
|
|
mov [y],eax
|
|
|
|
mov eax,[edx+png_image.format]
|
|
and eax,PNG_FORMAT_FLAG_ALPHA
|
|
jz .end0 ;if (..!=0)
|
|
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
|
|
mov eax,[edx+png_image.format]
|
|
and eax,PNG_FORMAT_FLAG_AFIRST
|
|
jz @f ;if (..!=0)
|
|
mov dword[aindex],-1
|
|
inc dword[input_row] ;To point to the first component
|
|
inc dword[output_row]
|
|
jmp .end1
|
|
@@: ;else
|
|
end if
|
|
mov eax,[channels]
|
|
mov [aindex],eax
|
|
jmp .end1
|
|
.end0: ;else
|
|
png_error [png_ptr], 'png_write_image: internal call error'
|
|
.end1:
|
|
|
|
; Work out the output row end and count over this, note that the increment
|
|
; above to 'row' means that row_end can actually be beyond the end of the
|
|
; row; this is correct.
|
|
|
|
mov eax,[channels]
|
|
inc eax
|
|
imul eax,[edx+png_image.width]
|
|
add eax,[output_row]
|
|
mov [row_end],eax
|
|
|
|
; while (y-- > 0)
|
|
; {
|
|
; const_uint_16p in_ptr = input_row;
|
|
; uint_16p out_ptr = output_row;
|
|
|
|
; while (out_ptr < row_end)
|
|
; {
|
|
; const uint_16 alpha = in_ptr[aindex];
|
|
; uint_32 reciprocal = 0;
|
|
; int c;
|
|
|
|
; out_ptr[aindex] = alpha;
|
|
|
|
; Calculate a reciprocal. The correct calculation is simply
|
|
; component/alpha*65535 << 15. (I.e. 15 bits of precision); this
|
|
; allows correct rounding by adding .5 before the shift. 'reciprocal'
|
|
; is only initialized when required.
|
|
|
|
; if (alpha > 0 && alpha < 65535)
|
|
; reciprocal = ((0xffff<<15)+(alpha>>1))/alpha;
|
|
|
|
; c = channels;
|
|
; do /* always at least one channel */
|
|
; {
|
|
; uint_16 component = *in_ptr++;
|
|
|
|
; The following gives 65535 for an alpha of 0, which is fine,
|
|
; otherwise if 0/0 is represented as some other value there is more
|
|
; likely to be a discontinuity which will probably damage
|
|
; compression when moving from a fully transparent area to a
|
|
; nearly transparent one. (The assumption here is that opaque
|
|
; areas tend not to be 0 intensity.)
|
|
|
|
; if (component >= alpha)
|
|
; component = 65535;
|
|
|
|
; component<alpha, so component/alpha is less than one and
|
|
; component*reciprocal is less than 2^31.
|
|
|
|
; else if (component > 0 && alpha < 65535)
|
|
; {
|
|
; uint_32 calc = component * reciprocal;
|
|
; calc += 16384; /* round to nearest */
|
|
; component = (uint_16)(calc >> 15);
|
|
; }
|
|
|
|
; *out_ptr++ = component;
|
|
; }
|
|
; while (--c > 0);
|
|
|
|
; Skip to next component (skip the intervening alpha channel)
|
|
; ++in_ptr;
|
|
; ++out_ptr;
|
|
; }
|
|
|
|
; png_write_row(png_ptr, display->local_row);
|
|
; input_row += display->row_bytes/(sizeof (uint_16));
|
|
; }
|
|
|
|
xor eax,eax
|
|
inc eax ;return 1
|
|
ret
|
|
endp
|
|
|
|
; Given 16-bit input (1 to 4 channels) write 8-bit output. If an alpha channel
|
|
; is present it must be removed from the components, the components are then
|
|
; written in sRGB encoding. No components are added or removed.
|
|
|
|
; Calculate an alpha reciprocal to reverse pre-multiplication. As above the
|
|
; calculation can be done to 15 bits of accuracy; however, the output needs to
|
|
; be scaled in the range 0..255*65535, so include that scaling here.
|
|
|
|
;# define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
|
|
|
|
;byte (uint_32 component, uint_32 alpha, uint_32 reciprocal/*from the above macro*/)
|
|
align 4
|
|
proc png_unpremultiply, component:dword, alpha:dword, reciprocal:dword
|
|
; The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
|
|
; is represented as some other value there is more likely to be a
|
|
; discontinuity which will probably damage compression when moving from a
|
|
; fully transparent area to a nearly transparent one. (The assumption here
|
|
; is that opaque areas tend not to be 0 intensity.)
|
|
|
|
; There is a rounding problem here; if alpha is less than 128 it will end up
|
|
; as 0 when scaled to 8 bits. To avoid introducing spurious colors into the
|
|
; output change for this too.
|
|
|
|
mov eax,[alpha]
|
|
cmp [component],eax
|
|
jge @f
|
|
cmp eax,128
|
|
jge .end0
|
|
@@: ;if (..>=.. || ..<..)
|
|
mov eax,255
|
|
jmp .end_f
|
|
; component<alpha, so component/alpha is less than one and
|
|
; component*reciprocal is less than 2^31.
|
|
|
|
.end0: ;else if (component > 0)
|
|
cmp dword[component],0
|
|
jle .end1
|
|
; The test is that alpha/257 (rounded) is less than 255, the first value
|
|
; that becomes 255 is 65407.
|
|
; NOTE: this must agree with the PNG_DIV257 macro (which must, therefore,
|
|
; be exact!) [Could also test reciprocal != 0]
|
|
|
|
; if (alpha < 65407)
|
|
; {
|
|
; component *= reciprocal;
|
|
; component += 64; /* round to nearest */
|
|
; component >>= 7;
|
|
; }
|
|
|
|
; else
|
|
; component *= 255;
|
|
|
|
; Convert the component to sRGB.
|
|
PNG_sRGB_FROM_LINEAR [component]
|
|
and eax,0xff
|
|
jmp .end_f
|
|
.end1: ;else
|
|
xor eax,eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
;int (voidp argument)
|
|
align 4
|
|
proc png_write_image_8bit uses ebx ecx edx edi esi, argument:dword
|
|
locals
|
|
display dd ? ;png_image_write_control* ;= argument
|
|
image dd ? ;png_imagep ;= display->image
|
|
png_ptr dd ? ;png_structrp ;= image->opaque->png_ptr
|
|
input_row dd ? ;const_uint_16p ;= display->first_row
|
|
output_row dd ? ;uint_16p ;= display->local_row
|
|
row_end dd ? ;uint_16p
|
|
channels dd ? ;const int ;= (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
|
|
aindex dd 0 ;int ;= 0
|
|
y dd ? ;uint_32 ;= image->height
|
|
component dd ? ;uint_32
|
|
endl
|
|
mov ebx,[argument]
|
|
mov [display],ebx
|
|
mov edx,[ebx+png_image_write_control.image]
|
|
mov [image],edx
|
|
mov ecx,[edx+png_image.opaque]
|
|
mov ecx,[ecx+png_control.png_ptr]
|
|
mov [png_ptr],ecx
|
|
mov ecx,[ebx+png_image_write_control.first_row]
|
|
mov [input_row],ecx
|
|
mov ecx,[ebx+png_image_write_control.local_row]
|
|
mov [output_row],ecx
|
|
|
|
mov ecx,1
|
|
mov eax,[edx+png_image.format]
|
|
and eax,PNG_FORMAT_FLAG_COLOR
|
|
jz @f
|
|
mov ecx,3
|
|
@@:
|
|
mov [channels],ecx
|
|
mov eax,[edx+png_image.height]
|
|
mov [y],eax
|
|
|
|
mov eax,[edx+png_image.format]
|
|
and eax,PNG_FORMAT_FLAG_ALPHA
|
|
jz .end0 ;if (..!=0)
|
|
; bytep row_end;
|
|
; int aindex;
|
|
|
|
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
|
|
; if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
|
|
; {
|
|
; aindex = -1;
|
|
; ++input_row; /* To point to the first component */
|
|
; ++output_row;
|
|
; }
|
|
|
|
; else
|
|
end if
|
|
; aindex = channels;
|
|
|
|
; Use row_end in place of a loop counter:
|
|
; row_end = output_row + image->width * (channels+1);
|
|
|
|
; while (y-- > 0)
|
|
; {
|
|
; const_uint_16p in_ptr = input_row;
|
|
; bytep out_ptr = output_row;
|
|
|
|
; while (out_ptr < row_end)
|
|
; {
|
|
; uint_16 alpha = in_ptr[aindex];
|
|
; byte alphabyte = (byte)PNG_DIV257(alpha);
|
|
; uint_32 reciprocal = 0;
|
|
; int c;
|
|
|
|
; Scale and write the alpha channel.
|
|
; out_ptr[aindex] = alphabyte;
|
|
|
|
; if (alphabyte > 0 && alphabyte < 255)
|
|
; reciprocal = UNP_RECIPROCAL(alpha);
|
|
|
|
; c = channels;
|
|
; do /* always at least one channel */
|
|
; *out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal);
|
|
; while (--c > 0);
|
|
|
|
; Skip to next component (skip the intervening alpha channel)
|
|
; ++in_ptr;
|
|
; ++out_ptr;
|
|
; } /* while out_ptr < row_end */
|
|
|
|
; png_write_row(png_ptr, display->local_row);
|
|
; input_row += display->row_bytes/(sizeof (uint_16));
|
|
; } /* while y */
|
|
jmp .end1
|
|
.end0: ;else
|
|
; No alpha channel, so the row_end really is the end of the row and it
|
|
; is sufficient to loop over the components one by one.
|
|
|
|
mov ecx,[edx+png_image.width]
|
|
imul ecx,[channels]
|
|
add ecx,[output_row]
|
|
;ecx = row_end
|
|
|
|
.cycle2: ;while (y-- > 0)
|
|
cmp dword[y],0
|
|
jle .cycle2end
|
|
mov esi,[input_row]
|
|
mov edi,[output_row]
|
|
;esi = in_ptr
|
|
;edi = out_ptr
|
|
|
|
.cycle3: ;while (..<..)
|
|
cmp edi,ecx
|
|
jge .cycle3end
|
|
xor eax,eax
|
|
lodsw
|
|
|
|
imul eax,255
|
|
mov [component],eax
|
|
PNG_sRGB_FROM_LINEAR [component]
|
|
stosb
|
|
jmp .cycle3
|
|
align 4
|
|
.cycle3end:
|
|
|
|
stdcall png_write_row, [png_ptr], [output_row]
|
|
mov eax,[ebx+png_image_write_control.row_bytes]
|
|
shr eax,1 ;sizeof.uint_16
|
|
add [input_row],eax
|
|
dec dword[y]
|
|
jmp .cycle2
|
|
align 4
|
|
.cycle2end:
|
|
.end1:
|
|
|
|
xor eax,eax
|
|
inc eax
|
|
ret
|
|
endp
|
|
|
|
;void (png_image_write_control *display)
|
|
align 4
|
|
proc png_image_set_PLTE, display:dword
|
|
locals
|
|
image dd ? ;png_imagep ;= display->image
|
|
cmap dd ? ;void * ;= display->colormap
|
|
entries dd ? ;int
|
|
|
|
; NOTE: the caller must check for cmap != NULL and entries != 0
|
|
format dd ? ;uint_32 ;= image->format
|
|
channels dd ? ;int
|
|
afirst dd 0
|
|
bgr dd 0
|
|
num_trans dd 0
|
|
palette rb 256*sizeof.png_color
|
|
tRNS rb 256 ;byte[]
|
|
endl
|
|
pushad
|
|
mov edx,[display]
|
|
mov ebx,[edx+png_image_write_control.image]
|
|
mov [image],ebx
|
|
mov eax,[edx+png_image_write_control.colormap]
|
|
mov [cmap],eax
|
|
mov eax,[ebx+png_image.colormap_entries]
|
|
cmp eax,256
|
|
jle @f
|
|
mov eax,256
|
|
@@:
|
|
mov [entries],eax
|
|
mov ecx,[ebx+png_image.format]
|
|
mov [format],ecx
|
|
PNG_IMAGE_SAMPLE_CHANNELS ecx
|
|
mov [channels],eax
|
|
|
|
if (PNG_FORMAT_BGR_SUPPORTED eq 1) & (PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1)
|
|
mov eax,ecx
|
|
and eax,PNG_FORMAT_FLAG_AFIRST
|
|
jz @f
|
|
mov eax,ecx
|
|
and eax,PNG_FORMAT_FLAG_ALPHA
|
|
jz @f
|
|
mov dword[afirst],-1
|
|
@@:
|
|
end if
|
|
|
|
if PNG_FORMAT_BGR_SUPPORTED eq 1
|
|
mov eax,ecx
|
|
and eax,PNG_FORMAT_FLAG_BGR
|
|
jz @f
|
|
mov dword[bgr],2
|
|
@@:
|
|
end if
|
|
|
|
; int i;
|
|
|
|
xor eax,eax
|
|
mov ecx,(256*sizeof.png_color)/4
|
|
mov edi,ebp
|
|
sub edi,256+256*sizeof.png_color
|
|
rep stosd ;memset(palette, 0, ...
|
|
not eax
|
|
mov ecx,256/4
|
|
;;mov edi,ebp ;if 'tRNS' after 'palette' this code can be comment
|
|
;;sub edi,256
|
|
rep stosd ;memset(tRNS, 255, ...
|
|
|
|
|
|
; for (i=num_trans=0; i<entries; ++i)
|
|
; {
|
|
; This gets automatically converted to sRGB with reversal of the
|
|
; pre-multiplication if the color-map has an alpha channel.
|
|
|
|
; if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
|
|
; {
|
|
; png_const_uint_16p entry = cmap;
|
|
|
|
; entry += i * channels;
|
|
|
|
; if ((channels & 1) != 0) /* no alpha */
|
|
; {
|
|
; if (channels >= 3) /* RGB */
|
|
; {
|
|
; palette[i].blue = (byte)PNG_sRGB_FROM_LINEAR(255 *
|
|
; entry[(2 ^ bgr)]);
|
|
; palette[i].green = (byte)PNG_sRGB_FROM_LINEAR(255 *
|
|
; entry[1]);
|
|
; palette[i].red = (byte)PNG_sRGB_FROM_LINEAR(255 *
|
|
; entry[bgr]);
|
|
; }
|
|
|
|
; else /* Gray */
|
|
; palette[i].blue = palette[i].red = palette[i].green =
|
|
; (byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
|
|
; }
|
|
|
|
; else /* alpha */
|
|
; {
|
|
; uint_16 alpha = entry[afirst ? 0 : channels-1];
|
|
; byte alphabyte = (byte)PNG_DIV257(alpha);
|
|
; uint_32 reciprocal = 0;
|
|
|
|
; Calculate a reciprocal, as in the png_write_image_8bit code above
|
|
; this is designed to produce a value scaled to 255*65535 when
|
|
; divided by 128 (i.e. asr 7).
|
|
|
|
; if (alphabyte > 0 && alphabyte < 255)
|
|
; reciprocal = (((0xffff*0xff)<<7)+(alpha>>1))/alpha;
|
|
|
|
; tRNS[i] = alphabyte;
|
|
; if (alphabyte < 255)
|
|
; num_trans = i+1;
|
|
|
|
; if (channels >= 3) /* RGB */
|
|
; {
|
|
; palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
|
|
; alpha, reciprocal);
|
|
; palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
|
|
; reciprocal);
|
|
; palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
|
|
; reciprocal);
|
|
; }
|
|
|
|
; else /* gray */
|
|
; palette[i].blue = palette[i].red = palette[i].green =
|
|
; png_unpremultiply(entry[afirst], alpha, reciprocal);
|
|
; }
|
|
; }
|
|
|
|
; else /* Color-map has sRGB values */
|
|
; {
|
|
; bytep entry = cmap;
|
|
|
|
; entry += i * channels;
|
|
|
|
; switch (channels)
|
|
; {
|
|
; case 4:
|
|
; tRNS[i] = entry[afirst ? 0 : 3];
|
|
; if (tRNS[i] < 255)
|
|
; num_trans = i+1;
|
|
; /* FALL THROUGH */
|
|
; case 3:
|
|
; palette[i].blue = entry[afirst + (2 ^ bgr)];
|
|
; palette[i].green = entry[afirst + 1];
|
|
; palette[i].red = entry[afirst + bgr];
|
|
; break;
|
|
|
|
; case 2:
|
|
; tRNS[i] = entry[1 ^ afirst];
|
|
; if (tRNS[i] < 255)
|
|
; num_trans = i+1;
|
|
; /* FALL THROUGH */
|
|
; case 1:
|
|
; palette[i].blue = palette[i].red = palette[i].green =
|
|
; entry[afirst];
|
|
; break;
|
|
|
|
; default:
|
|
; break;
|
|
; }
|
|
; }
|
|
; }
|
|
|
|
mov ecx,[ebx+png_image.opaque]
|
|
mov eax,ebp
|
|
sub eax,256+256*sizeof.png_color
|
|
stdcall png_set_PLTE, [ecx+png_control.png_ptr], [ecx+png_control.info_ptr], eax, [entries]
|
|
|
|
cmp dword[num_trans],0
|
|
jle @f ;if (..>0)
|
|
mov eax,ebp
|
|
sub eax,256
|
|
stdcall png_set_tRNS, [ecx+png_control.png_ptr], [ecx+png_control.info_ptr], eax, [num_trans], 0
|
|
@@:
|
|
|
|
mov eax,[entries]
|
|
mov [ebx+png_image.colormap_entries],eax
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
;int (voidp argument)
|
|
align 4
|
|
proc png_image_write_main uses ebx ecx edx esi edi, argument:dword
|
|
locals
|
|
display dd ? ;= png_image_write_control * = argument
|
|
image dd ? ;= display->image
|
|
png_ptr dd ? ;= image->opaque->png_ptr
|
|
info_ptr dd ? ;= image->opaque->info_ptr
|
|
format dd ? ;= image->format
|
|
|
|
colormap dd ?
|
|
linear dd ?
|
|
alpha dd ?
|
|
write_16bit dd ? ;= linear && !colormap && (display->convert_to_8bit == 0)
|
|
endl
|
|
mov edx,[argument]
|
|
mov [display],edx
|
|
mov ebx,[edx+png_image_write_control.image]
|
|
mov [image],ebx
|
|
mov ecx,[ebx+png_image.format]
|
|
mov [format],ecx
|
|
mov eax,[ebx+png_image.opaque]
|
|
mov edi,[eax+png_control.png_ptr]
|
|
mov [png_ptr],edi
|
|
mov esi,[eax+png_control.info_ptr]
|
|
mov [info_ptr],esi
|
|
|
|
; The following four ints are actually booleans
|
|
and ecx,PNG_FORMAT_FLAG_COLORMAP
|
|
mov [colormap],ecx
|
|
not ecx
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_LINEAR
|
|
mov [linear],eax
|
|
mov eax,[format]
|
|
and eax,ecx
|
|
and eax,PNG_FORMAT_FLAG_ALPHA
|
|
and eax,ecx
|
|
mov [alpha],eax
|
|
xor eax,eax ;false
|
|
cmp dword[edx+png_image_write_control.convert_to_8bit],0
|
|
jne @f
|
|
not eax ;true
|
|
@@:
|
|
and eax,[linear]
|
|
and eax,ecx
|
|
mov [write_16bit],eax
|
|
|
|
if PNG_BENIGN_ERRORS_SUPPORTED eq 1
|
|
; Make sure we error out on any bad situation
|
|
stdcall png_set_benign_errors, edi, 0 ;error
|
|
end if
|
|
|
|
; Default the 'row_stride' parameter if required, also check the row stride
|
|
; and total image size to ensure that they are within the system limits.
|
|
|
|
PNG_IMAGE_PIXEL_CHANNELS [ebx+png_image.format]
|
|
;eax = channels
|
|
|
|
push edx
|
|
mov ecx,eax
|
|
mov eax,0x7FFFFFFF
|
|
xor edx,edx
|
|
div ecx
|
|
pop edx
|
|
cmp [ebx+png_image.width],eax
|
|
jg .end0 ;if (..<=..) ;no overflow
|
|
imul ecx,[ebx+png_image.width]
|
|
|
|
cmp dword[edx+png_image_write_control.row_stride],0
|
|
jne @f ;if (..==0)
|
|
mov [edx+png_image_write_control.row_stride],ecx
|
|
@@:
|
|
mov eax,[edx+png_image_write_control.row_stride]
|
|
cmp eax,0
|
|
jge .end2 ;if (..<0)
|
|
neg eax
|
|
inc eax
|
|
.end2:
|
|
|
|
cmp eax,ecx
|
|
jl .end3 ;if (..>=..)
|
|
; Now check for overflow of the image buffer calculation; this
|
|
; limits the whole image size to 32 bits for API compatibility with
|
|
; the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
|
|
|
|
push edx
|
|
mov eax,0xFFFFFFFF
|
|
xor edx,edx
|
|
div ecx
|
|
pop edx
|
|
cmp [ebx+png_image.height],eax
|
|
jle @f ;if (..>..)
|
|
mov eax,[ebx+png_image.opaque]
|
|
mov eax,[eax+png_control.png_ptr]
|
|
png_error eax, 'memory image too large'
|
|
@@:
|
|
jmp .end1
|
|
.end3: ;else
|
|
mov eax,[ebx+png_image.opaque]
|
|
mov eax,[eax+png_control.png_ptr]
|
|
png_error eax, 'supplied row stride too small'
|
|
jmp .end1
|
|
.end0: ;else
|
|
mov eax,[ebx+png_image.opaque]
|
|
mov eax,[eax+png_control.png_ptr]
|
|
png_error eax, 'image row stride too large'
|
|
.end1:
|
|
|
|
; Set the required transforms then write the rows in the correct order.
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_COLORMAP
|
|
jz .end4 ;if (..!=0)
|
|
cmp dword[edx+png_image_write_control.colormap],0
|
|
je .end6
|
|
mov eax,[ebx+png_image.colormap_entries]
|
|
cmp eax,0
|
|
jle .end6 ;if (..!=0 && ..>0)
|
|
;eax = entries
|
|
xor ecx,ecx
|
|
inc ecx ;=1
|
|
cmp eax,2
|
|
jle @f
|
|
shl ecx,1 ;=2
|
|
cmp eax,4
|
|
jle @f
|
|
shl ecx,1 ;=4
|
|
cmp eax,16
|
|
jle @f
|
|
shl ecx,1 ;=8
|
|
@@:
|
|
stdcall png_set_IHDR, edi, esi, [ebx+png_image.width], [ebx+png_image.height],\
|
|
ecx, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,\
|
|
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE
|
|
|
|
stdcall png_image_set_PLTE, edx
|
|
jmp .end5
|
|
.end6: ;else
|
|
mov eax,[ebx+png_image.opaque]
|
|
mov eax,[eax+png_control.png_ptr]
|
|
png_error eax, 'no color-map for color-mapped image'
|
|
jmp .end5
|
|
.end4: ;else
|
|
xor ecx,ecx
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_COLOR
|
|
jz @f
|
|
or ecx,PNG_COLOR_MASK_COLOR
|
|
@@:
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_ALPHA
|
|
jz @f
|
|
or ecx,PNG_COLOR_MASK_ALPHA
|
|
@@:
|
|
mov eax,8
|
|
cmp dword[write_16bit],0
|
|
je @f
|
|
mov eax,16
|
|
@@:
|
|
stdcall png_set_IHDR, edi, esi, [ebx+png_image.width], [ebx+png_image.height],\
|
|
eax, ecx, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE
|
|
.end5:
|
|
|
|
; Counter-intuitively the data transformations must be called *after*
|
|
; png_write_info, not before as in the read code, but the 'set' functions
|
|
; must still be called before. Just set the color space information, never
|
|
; write an interlaced image.
|
|
|
|
cmp dword[write_16bit],0
|
|
je @f ;if (..!=0)
|
|
; The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB.
|
|
stdcall png_set_gAMA_fixed, edi, esi, PNG_GAMMA_LINEAR
|
|
|
|
mov eax,[ebx+png_image.flags]
|
|
and eax,PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB
|
|
jnz @f ;if (..==0)
|
|
stdcall png_set_cHRM_fixed, edi, esi,\
|
|
31270, 32900,\ ;white
|
|
64000, 33000,\ ;red
|
|
30000, 60000,\ ;green
|
|
15000, 6000 ;blue
|
|
jmp .end7
|
|
@@:
|
|
mov eax,[ebx+png_image.flags]
|
|
and eax,PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB
|
|
jnz @f ;else if (..==0)
|
|
stdcall png_set_sRGB, edi, esi, PNG_sRGB_INTENT_PERCEPTUAL
|
|
jmp .end7
|
|
@@: ;else
|
|
; Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit
|
|
; space must still be gamma encoded.
|
|
stdcall png_set_gAMA_fixed, edi, esi, PNG_GAMMA_sRGB_INVERSE
|
|
.end7:
|
|
|
|
; Write the file header.
|
|
stdcall png_write_info, edi, esi
|
|
|
|
; Now set up the data transformations (*after* the header is written),
|
|
; remove the handled transformations from the 'format' flags for checking.
|
|
|
|
; First check for a little endian system if writing 16-bit files.
|
|
|
|
cmp dword[write_16bit],0
|
|
je @f ;if (..!=0)
|
|
; uint_16 le = 0x0001;
|
|
|
|
; if ((*(bytep) & le) != 0)
|
|
stdcall png_set_swap, edi
|
|
@@:
|
|
|
|
if PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED eq 1
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_BGR
|
|
jz .end12 ;if (..!=0)
|
|
cmp dword[colormap],0
|
|
jne @f
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_COLOR
|
|
jz @f ;if (..==0 && ..!=0)
|
|
stdcall png_set_bgr, edi
|
|
@@:
|
|
and dword[format], not PNG_FORMAT_FLAG_BGR
|
|
.end12:
|
|
end if
|
|
|
|
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_AFIRST
|
|
jz .end13 ;if (..!=0)
|
|
cmp dword[colormap],0
|
|
jne @f
|
|
mov eax,[format]
|
|
and eax,PNG_FORMAT_FLAG_ALPHA
|
|
jz @f ;if (..==0 && ..!=0)
|
|
stdcall png_set_swap_alpha, edi
|
|
@@:
|
|
and dword[format], not PNG_FORMAT_FLAG_AFIRST
|
|
.end13:
|
|
end if
|
|
|
|
; If there are 16 or fewer color-map entries we wrote a lower bit depth
|
|
; above, but the application data is still byte packed.
|
|
|
|
cmp dword[colormap],0
|
|
je @f
|
|
cmp dword[ebx+png_image.colormap_entries],16
|
|
jg @f ;if (..!=0 && ..<=16)
|
|
stdcall png_set_packing, edi
|
|
@@:
|
|
|
|
; That should have handled all (both) the transforms.
|
|
mov eax,[format]
|
|
and eax, not (PNG_FORMAT_FLAG_COLOR or PNG_FORMAT_FLAG_LINEAR or PNG_FORMAT_FLAG_ALPHA or PNG_FORMAT_FLAG_COLORMAP)
|
|
jz @f ;if (..!=0)
|
|
png_error edi, 'png_write_image: unsupported transformation'
|
|
@@:
|
|
|
|
push esi
|
|
;ecx - row ;bytep
|
|
;esi - row_bytes
|
|
mov ecx,[edx+png_image_write_control.buffer]
|
|
mov esi,[edx+png_image_write_control.row_stride]
|
|
|
|
cmp dword[linear],0
|
|
je @f ;if (..!=0)
|
|
shl esi,1 ;*= sizeof.uint_16
|
|
@@:
|
|
cmp esi,0
|
|
jge @f ;if (..<0)
|
|
mov eax,[ebx+png_image.height]
|
|
dec eax
|
|
imul eax,esi
|
|
sub ecx,eax
|
|
@@:
|
|
mov [edx+png_image_write_control.first_row],ecx
|
|
mov [edx+png_image_write_control.row_bytes],esi
|
|
pop esi
|
|
|
|
; Apply 'fast' options if the flag is set.
|
|
mov eax,[ebx+png_image.flags]
|
|
and eax,PNG_IMAGE_FLAG_FAST
|
|
jz @f ;if (..!=0)
|
|
stdcall png_set_filter, edi, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS
|
|
; NOTE: determined by experiment using pngstest, this reflects some
|
|
; balance between the time to write the image once and the time to read
|
|
; it about 50 times. The speed-up in pngstest was about 10-20% of the
|
|
; total (user) time on a heavily loaded system.
|
|
|
|
if PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED eq 1
|
|
stdcall png_set_compression_level, edi, 3
|
|
end if
|
|
@@:
|
|
|
|
; Check for the cases that currently require a pre-transform on the row
|
|
; before it is written. This only applies when the input is 16-bit and
|
|
; either there is an alpha channel or it is converted to 8-bit.
|
|
|
|
cmp dword[linear],0
|
|
je @f
|
|
cmp dword[alpha],0
|
|
je @f
|
|
jmp .end10
|
|
@@:
|
|
cmp dword[colormap],0
|
|
jne .end9
|
|
cmp dword[edx+png_image_write_control.convert_to_8bit],0
|
|
je .end9
|
|
.end10: ;if ((..!=0 && ..!=0 ) || (..==0 && ..!=0))
|
|
stdcall png_get_rowbytes, edi, esi
|
|
stdcall png_malloc, edi, eax
|
|
mov ecx,eax ;ecx = row
|
|
|
|
mov [edx+png_image_write_control.local_row],ecx
|
|
cmp dword[write_16bit],0
|
|
je @f ;if (..!=0)
|
|
stdcall png_safe_execute, ebx, png_write_image_16bit, edx
|
|
jmp .end11
|
|
@@: ;else
|
|
stdcall png_safe_execute, ebx, png_write_image_8bit, edx
|
|
.end11:
|
|
mov dword[edx+png_image_write_control.local_row],0
|
|
|
|
stdcall png_free, edi, ecx
|
|
|
|
; Skip the 'write_end' on error:
|
|
cmp eax,0
|
|
je .end_f ;if (..==0) return 0
|
|
jmp .end8
|
|
|
|
; Otherwise this is the case where the input is in a format currently
|
|
; supported by the rest of the libpng write code; call it directly.
|
|
|
|
.end9: ;else
|
|
if 1 ;;; IDAT compress all
|
|
mov ecx,[edx+png_image_write_control.row_bytes]
|
|
inc ecx
|
|
imul ecx,[ebx+png_image.height]
|
|
cmp ecx,1
|
|
jl .end8
|
|
stdcall create_compress_IDAT, edi, [edx+png_image_write_control.first_row], ecx, [ebx+png_image.width], [ebx+png_image.height]
|
|
else ;;; not work, IDAT compress by lines
|
|
mov ecx,[ebx+png_image.height]
|
|
cmp ecx,1
|
|
jl .end8
|
|
mov eax,[edx+png_image_write_control.first_row]
|
|
mov ebx,[edx+png_image_write_control.row_bytes]
|
|
@@:
|
|
stdcall png_write_row, edi, eax
|
|
add eax, ebx
|
|
loop @b
|
|
end if
|
|
.end8:
|
|
|
|
stdcall png_write_end, edi, esi
|
|
xor eax,eax
|
|
inc eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
align 16
|
|
proc create_compress_IDAT, png_ptr:dword, buf:dword, len:dword, width:dword, height:dword
|
|
locals
|
|
m1 dd ? ;memory for compress IDAT
|
|
buf_f dd ? ;memory for IDAT
|
|
mins dd ? ;minimum sum
|
|
endl
|
|
pushad
|
|
mov edi,[png_ptr]
|
|
png_debug 1, 'IDAT compress all'
|
|
|
|
;create buffer with filters
|
|
stdcall png_zalloc, edi, 1, [len]
|
|
cmp eax,0
|
|
je .end_f
|
|
mov [buf_f],eax
|
|
|
|
mov eax,ZLIB_IO_MAX
|
|
cmp eax,[len]
|
|
jge @f
|
|
mov eax,[len]
|
|
@@:
|
|
stdcall png_zalloc, edi, 1, eax
|
|
cmp eax,0
|
|
je .end0
|
|
mov [m1],eax
|
|
|
|
;init buffer with filters
|
|
mov ebx,[width]
|
|
mov edx,[height]
|
|
mov edi,[buf_f]
|
|
mov esi,[buf]
|
|
.cycle0:
|
|
cmp edx,1
|
|
jl .cycle0end
|
|
mov ecx,ebx
|
|
xor al,al
|
|
stosb ;insert filter (0 - none)
|
|
align 4
|
|
.cycle1:
|
|
lodsb ;1
|
|
inc edi ;
|
|
movsb ;2
|
|
stosb ;3
|
|
lodsb ;
|
|
mov [edi-3],al
|
|
loop .cycle1
|
|
dec edx
|
|
jmp .cycle0
|
|
.cycle0end:
|
|
|
|
;make filters
|
|
mov edx,[height]
|
|
mov esi,[width]
|
|
imul esi,3 ;esi - rowbytes
|
|
|
|
inc esi
|
|
mov edi,[png_ptr]
|
|
cmp dword[edi+png_struct.try_row],0
|
|
jne @f ;if (..==0)
|
|
stdcall png_malloc, edi, esi
|
|
mov [edi+png_struct.try_row],eax
|
|
@@:
|
|
cmp dword[edi+png_struct.tst_row],0
|
|
jne @f ;if (..==0)
|
|
stdcall png_malloc, edi, esi
|
|
mov [edi+png_struct.tst_row],eax
|
|
@@:
|
|
dec esi
|
|
|
|
mov edi,[buf_f]
|
|
add edi,[len]
|
|
.cycle3:
|
|
dec edx
|
|
cmp edx,1
|
|
jl .cycle3end
|
|
sub edi,esi
|
|
dec edi ;move in perv row
|
|
|
|
;init pointers for function png_setup_up_row
|
|
mov ebx,[png_ptr]
|
|
mov [ebx+png_struct.row_buf],edi
|
|
mov [ebx+png_struct.prev_row],edi
|
|
sub [ebx+png_struct.prev_row],esi
|
|
dec dword[ebx+png_struct.prev_row]
|
|
|
|
;calculate start minimum sum
|
|
push esi
|
|
xor eax,eax
|
|
xor ebx,ebx
|
|
mov ecx,esi
|
|
mov esi,edi
|
|
inc esi
|
|
.cycle2:
|
|
lodsb
|
|
png_setup_abs ebx
|
|
loop .cycle2
|
|
pop esi
|
|
mov [mins],ebx
|
|
|
|
push edx
|
|
mov edx,[png_ptr]
|
|
mov eax,[edx+png_struct.tst_row]
|
|
mov byte[eax],0 ;not filter
|
|
|
|
; Up filter
|
|
stdcall png_setup_up_row, edx, esi, [mins]
|
|
cmp eax,[mins]
|
|
jge @f ;if (..<..)
|
|
mov [mins],eax
|
|
stdcall copy_row_mins, [edx+png_struct.tst_row], [edx+png_struct.try_row]
|
|
@@:
|
|
|
|
; Find out how many bytes offset each pixel is
|
|
movzx ebx,byte[edx+png_struct.pixel_depth]
|
|
add ebx,7
|
|
shr ebx,3
|
|
|
|
; Sub filter
|
|
stdcall png_setup_sub_row, edx, ebx, esi, [mins]
|
|
cmp eax,[mins]
|
|
jge @f ;if (..<..)
|
|
mov [mins],eax
|
|
stdcall copy_row_mins, [edx+png_struct.tst_row], [edx+png_struct.try_row]
|
|
@@:
|
|
|
|
; Avg filter
|
|
stdcall png_setup_avg_row, edx, ebx, esi, [mins]
|
|
cmp eax,[mins]
|
|
jge @f ;if (..<..)
|
|
mov [mins],eax
|
|
stdcall copy_row_mins, [edx+png_struct.tst_row], [edx+png_struct.try_row]
|
|
@@:
|
|
|
|
; Copy best row
|
|
mov eax,[edx+png_struct.tst_row]
|
|
cmp byte[eax],0
|
|
je @f
|
|
stdcall copy_row_mins, edi, [edx+png_struct.tst_row]
|
|
@@:
|
|
pop edx
|
|
jmp .cycle3
|
|
.cycle3end:
|
|
|
|
mov edi,[png_ptr]
|
|
mov esi,edi
|
|
add esi,png_struct.zstream
|
|
stdcall [deflateInit2], esi,\
|
|
-1, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY
|
|
|
|
mov eax,[buf_f]
|
|
mov [edi+png_struct.zstream.next_in],eax
|
|
mov eax,[len]
|
|
mov [edi+png_struct.zstream.avail_in],eax
|
|
mov eax,[m1]
|
|
mov [edi+png_struct.zstream.next_out],eax
|
|
xor ecx,ecx
|
|
align 4
|
|
.cycle4:
|
|
mov dword[edi+png_struct.zstream.avail_out],16*1024
|
|
|
|
stdcall [deflate], esi, Z_FINISH ;Z_NO_FLUSH
|
|
cmp eax,Z_STREAM_ERROR
|
|
je .end1
|
|
|
|
add ecx,16*1024
|
|
sub ecx,[edi+png_struct.zstream.avail_out]
|
|
cmp dword[edi+png_struct.zstream.avail_out],0
|
|
je .cycle4 ;while (strm.avail_out == 0)
|
|
if 0
|
|
mov dword[edi+png_struct.zstream.avail_out],16*1024
|
|
stdcall [deflate], esi, Z_FINISH
|
|
cmp eax,Z_STREAM_ERROR
|
|
je .end1
|
|
end if
|
|
stdcall [deflateEnd], esi
|
|
|
|
if PNG_WRITE_OPTIMIZE_CMF_SUPPORTED eq 1
|
|
mov eax,[edi+png_struct.mode]
|
|
and eax,PNG_HAVE_IDAT
|
|
jnz @f
|
|
cmp byte[edi+png_struct.compression_type],PNG_COMPRESSION_TYPE_BASE
|
|
jne @f ;if (..==0 && ..==..)
|
|
stdcall png_image_size, edi
|
|
stdcall optimize_cmf, [m1], eax
|
|
@@:
|
|
end if
|
|
stdcall png_write_complete_chunk, edi, png_IDAT, [m1], ecx
|
|
or dword[edi+png_struct.mode],PNG_HAVE_IDAT
|
|
|
|
jmp @f
|
|
.end1:
|
|
png_debug 1, 'Z_STREAM_ERROR'
|
|
@@:
|
|
|
|
;free memory
|
|
cmp dword[edi+png_struct.try_row],0
|
|
je @f ;if (..!=0)
|
|
stdcall png_free, edi, [edi+png_struct.try_row]
|
|
mov dword[edi+png_struct.try_row],0
|
|
@@:
|
|
cmp dword[edi+png_struct.tst_row],0
|
|
je @f ;if (..!=0)
|
|
stdcall png_free, edi, [edi+png_struct.tst_row]
|
|
mov dword[edi+png_struct.tst_row],0
|
|
@@:
|
|
stdcall png_free, edi, [m1]
|
|
.end0:
|
|
stdcall png_free, edi, [buf_f]
|
|
.end_f:
|
|
popad
|
|
ret
|
|
endp
|
|
|
|
;input:
|
|
; esi - rowbytes
|
|
align 4
|
|
proc copy_row_mins uses edi esi, dest:dword, sour:dword
|
|
mov ecx,esi
|
|
inc ecx
|
|
mov edi,[dest]
|
|
mov esi,[sour]
|
|
rep movsb
|
|
ret
|
|
endp
|
|
|
|
;void (png_structp png_ptr, bytep/*const*/ data, png_size_t size)
|
|
align 4
|
|
proc image_memory_write uses eax ebx ecx edi esi, png_ptr:dword, p2data:dword, size:dword
|
|
mov edi,[png_ptr]
|
|
mov esi,[edi+png_struct.io_ptr] ;esi = png_image_write_control *display
|
|
mov ebx,[esi+png_image_write_control.output_bytes] ;ebx = ob
|
|
|
|
; Check for overflow; this should never happen:
|
|
mov eax,PNG_SIZE_MAX
|
|
sub eax,ebx
|
|
mov ecx,[size]
|
|
cmp ecx,eax
|
|
jg .end1 ;if (..<=..)
|
|
; I don't think libpng ever does this, but just in case:
|
|
cmp ecx,0
|
|
jle .end0 ;if (..>0)
|
|
mov eax,ebx
|
|
add eax,ecx
|
|
cmp [esi+png_image_write_control.memory_bytes],eax
|
|
jl @f ;if (..>=..) ;writing
|
|
push esi
|
|
mov edi,[esi+png_image_write_control.memory]
|
|
add edi,ebx
|
|
mov esi,[p2data]
|
|
rep movsb ;memcpy(...
|
|
pop esi
|
|
@@:
|
|
|
|
; Always update the size:
|
|
add ebx,[size]
|
|
mov [esi+png_image_write_control.output_bytes],ebx
|
|
.end0:
|
|
jmp .end2
|
|
.end1: ;else
|
|
png_error edi, 'png_image_write_to_memory: PNG too big'
|
|
.end2:
|
|
ret
|
|
endp
|
|
|
|
;void (png_structp png_ptr)
|
|
align 4
|
|
proc image_memory_flush, png_ptr:dword
|
|
ret
|
|
endp
|
|
|
|
;int (voidp argument)
|
|
align 4
|
|
proc png_image_write_memory uses ebx, argument:dword
|
|
; The rest of the memory-specific init and write_main in an error protected
|
|
; environment. This case needs to use callbacks for the write operations
|
|
; since libpng has no built in support for writing to memory.
|
|
|
|
mov eax,[argument]
|
|
mov ebx,[eax+png_image_write_control.image]
|
|
mov ebx,[ebx+png_image.opaque]
|
|
stdcall png_set_write_fn, [ebx+png_control.png_ptr], eax, image_memory_write, image_memory_flush
|
|
|
|
stdcall png_image_write_main, [argument]
|
|
ret
|
|
endp
|
|
|
|
;int (png_imagep image, void *memory,
|
|
; png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit,
|
|
; const void *buffer, int_32 row_stride, const void *colormap)
|
|
align 4
|
|
proc png_image_write_to_memory uses ebx ecx edx edi esi, image:dword, memory:dword,\
|
|
memory_bytes:dword, convert_to_8bit:dword, buffer:dword, row_stride:dword, colormap:dword
|
|
locals
|
|
display png_image_write_control ;local struct
|
|
endl
|
|
;edi - display png_image_write_control
|
|
|
|
; Write the image to the given buffer, or count the bytes if it is NULL
|
|
mov ebx,[image]
|
|
cmp ebx,0
|
|
je .end0
|
|
cmp dword[ebx+png_image.version],PNG_IMAGE_VERSION
|
|
jne .end0 ;if (..!=0 && ..==..)
|
|
cmp dword[memory_bytes],0
|
|
je .end2
|
|
cmp dword[buffer],0
|
|
je .end2 ;if (..!=0 && ..!=0)
|
|
; This is to give the caller an easier error detection in the NULL
|
|
; case and guard against uninitialized variable problems:
|
|
|
|
cmp dword[memory],0
|
|
jne @f ;if(..==0)
|
|
mov eax,[memory_bytes]
|
|
mov dword[eax],0
|
|
@@:
|
|
|
|
stdcall png_image_write_init, ebx
|
|
cmp eax,0
|
|
je .end3 ;if (..!=0)
|
|
mov ecx,sizeof.png_image_write_control
|
|
mov edi,ebp
|
|
sub edi,ecx
|
|
xor eax,eax
|
|
rep stosb ;memset(&display, 0, sizeof.display))
|
|
sub edi,sizeof.png_image_write_control
|
|
mov [edi+png_image_write_control.image],ebx
|
|
mov eax,[buffer]
|
|
mov [edi+png_image_write_control.buffer],eax
|
|
mov eax,[row_stride]
|
|
mov [edi+png_image_write_control.row_stride],eax
|
|
mov eax,[colormap]
|
|
mov [edi+png_image_write_control.colormap],eax
|
|
mov eax,[convert_to_8bit]
|
|
mov [edi+png_image_write_control.convert_to_8bit],eax
|
|
mov eax,[memory]
|
|
mov [edi+png_image_write_control.memory],eax
|
|
mov eax,[memory_bytes]
|
|
mov eax,[eax]
|
|
mov [edi+png_image_write_control.memory_bytes],eax
|
|
mov dword[edi+png_image_write_control.output_bytes], 0
|
|
|
|
stdcall png_safe_execute, ebx, png_image_write_memory, edi
|
|
mov ecx,eax ;ecx = result
|
|
stdcall png_image_free, ebx
|
|
|
|
; write_memory returns true even if we ran out of buffer.
|
|
cmp ecx,0 ;if (..)
|
|
je .end4
|
|
; On out-of-buffer this function returns '0' but still updates
|
|
; memory_bytes:
|
|
|
|
mov edx,[edi+png_image_write_control.output_bytes]
|
|
mov eax,[memory_bytes]
|
|
cmp dword[memory],0
|
|
je @f ;if (..!=0 && ..>..)
|
|
cmp edx,[eax]
|
|
jle @f
|
|
xor ecx,ecx
|
|
@@:
|
|
mov [eax],edx
|
|
.end4:
|
|
|
|
mov eax,ecx
|
|
jmp .end_f
|
|
.end3: ;else
|
|
xor eax,eax
|
|
jmp .end_f
|
|
.end2: ;else
|
|
std_png_image_error ebx, 'png_image_write_to_memory: invalid argument'
|
|
jmp .end_f
|
|
.end0:
|
|
cmp ebx,0
|
|
je .end1 ;else if (..!=0)
|
|
std_png_image_error ebx, 'png_image_write_to_memory: incorrect PNG_IMAGE_VERSION'
|
|
jmp .end_f
|
|
.end1: ;else
|
|
xor eax,eax
|
|
.end_f:
|
|
ret
|
|
endp
|
|
|
|
;int (png_imagep image, FILE *file, int convert_to_8bit,
|
|
; const void *buffer, int_32 row_stride, const void *colormap)
|
|
align 4
|
|
proc png_image_write_to_stdio, image:dword, file:dword, convert_to_8bit:dword, buffer:dword, row_stride:dword, colormap:dword
|
|
; Write the image to the given (FILE*).
|
|
; if (image != NULL && image->version == PNG_IMAGE_VERSION)
|
|
; {
|
|
; if (file != NULL && buffer != NULL)
|
|
; {
|
|
; if (png_image_write_init(image) != 0)
|
|
; {
|
|
; png_image_write_control display;
|
|
; int result;
|
|
|
|
; This is slightly evil, but png_init_io doesn't do anything other
|
|
; than this and we haven't changed the standard IO functions so
|
|
; this saves a 'safe' function.
|
|
|
|
; image->opaque->png_ptr->io_ptr = file;
|
|
|
|
; memset(&display, 0, (sizeof display));
|
|
; display.image = image;
|
|
; display.buffer = buffer;
|
|
; display.row_stride = row_stride;
|
|
; display.colormap = colormap;
|
|
; display.convert_to_8bit = convert_to_8bit;
|
|
|
|
; result = png_safe_execute(image, png_image_write_main, &display);
|
|
; png_image_free(image);
|
|
; return result;
|
|
; }
|
|
|
|
; else
|
|
; return 0;
|
|
; }
|
|
|
|
; else
|
|
; return png_image_error(image,
|
|
; "png_image_write_to_stdio: invalid argument");
|
|
; }
|
|
|
|
; else if (image != NULL)
|
|
; return png_image_error(image,
|
|
; "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
|
|
|
|
; else
|
|
; return 0;
|
|
ret
|
|
endp
|
|
|
|
;int (png_imagep image, const char *file_name,
|
|
; int convert_to_8bit, const void *buffer, int_32 row_stride,
|
|
; const void *colormap)
|
|
align 4
|
|
proc png_image_write_to_file, image:dword, file_name:dword, convert_to_8bit:dword, buffer:dword, row_stride:dword, colormap:dword
|
|
; Write the image to the named file.
|
|
; if (image != NULL && image->version == PNG_IMAGE_VERSION)
|
|
; {
|
|
; if (file_name != NULL && buffer != NULL)
|
|
; {
|
|
; FILE *fp = fopen(file_name, "wb");
|
|
|
|
; if (fp != NULL)
|
|
; {
|
|
; if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
|
|
; row_stride, colormap) != 0)
|
|
; {
|
|
; int error; /* from fflush/fclose */
|
|
|
|
; Make sure the file is flushed correctly.
|
|
; if (fflush(fp) == 0 && ferror(fp) == 0)
|
|
; {
|
|
; if (fclose(fp) == 0)
|
|
; return 1;
|
|
|
|
; error = errno; /* from fclose */
|
|
; }
|
|
|
|
; else
|
|
; {
|
|
; error = errno; /* from fflush or ferror */
|
|
; (void)fclose(fp);
|
|
; }
|
|
|
|
; (void)remove(file_name);
|
|
; The image has already been cleaned up; this is just used to
|
|
; set the error (because the original write succeeded).
|
|
|
|
; return png_image_error(image, strerror(error));
|
|
; }
|
|
|
|
; else
|
|
; {
|
|
; Clean up: just the opened file.
|
|
; (void)fclose(fp);
|
|
; (void)remove(file_name);
|
|
; return 0;
|
|
; }
|
|
; }
|
|
|
|
; else
|
|
; return png_image_error(image, strerror(errno));
|
|
; }
|
|
|
|
; else
|
|
; return png_image_error(image,
|
|
; "png_image_write_to_file: invalid argument");
|
|
; }
|
|
|
|
; else if (image != NULL)
|
|
; return png_image_error(image,
|
|
; "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
|
|
|
|
; else
|
|
; return 0;
|
|
ret
|
|
endp
|
|
end if ;SIMPLIFIED_WRITE
|