Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6778 → Rev 6779

/programs/develop/libraries/libs-dev/libimg/png/libpng/png.asm
173,8 → 173,7
@@: ;else ;critical
mov eax,[edi+png_struct.flags]
and eax,PNG_FLAG_CRC_CRITICAL_IGNORE
cmp eax,0
je .end0 ;if (..!=0)
jz .end0 ;if (..!=0)
mov dword[need_crc],0
.end0:
 
552,8 → 551,7
mov eax,[mask]
and eax,PNG_FREE_TRNS
and eax,[esi+png_info_def.free_me]
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
and dword[esi+png_info_def.valid], not PNG_INFO_tRNS
stdcall png_free, edi, [esi+png_info_def.trans_alpha]
mov dword[esi+png_info_def.trans_alpha],0
566,8 → 564,7
mov eax,[mask]
and eax,PNG_FREE_SCAL
and eax,[esi+png_info_def.free_me]
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_free, edi, [esi+png_info_def.scal_s_width]
stdcall png_free, edi, [esi+png_info_def.scal_s_height]
mov dword[esi+png_info_def.scal_s_width],0
604,8 → 601,7
mov eax,[mask]
and eax,PNG_FREE_ICCP
and eax,[esi+png_info_def.free_me]
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_free, edi, [esi+png_info_def.iccp_name]
stdcall png_free, edi, [esi+png_info_def.iccp_profile]
mov dword[esi+png_info_def.iccp_name],0
674,8 → 670,7
mov eax,[mask]
and eax,PNG_FREE_HIST
and eax,[esi+png_info_def.free_me]
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_free, edi, [esi+png_info_def.hist]
mov dword[esi+png_info_def.hist],0
and dword[esi+png_info_def.valid], not PNG_INFO_hIST
686,8 → 681,7
mov eax,[mask]
and eax,PNG_FREE_PLTE
and eax,[esi+png_info_def.free_me]
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_free, edi, [esi+png_info_def.palette]
mov dword[esi+png_info_def.palette],0
and dword[esi+png_info_def.valid],not PNG_INFO_PLTE
/programs/develop/libraries/libs-dev/libimg/png/libpng/png.inc
808,41 → 808,6
end if
}
 
; Allocate and initialize png_ptr struct for reading, and any other memory.
;PNG_EXPORTA(4, png_structp, png_create_read_struct,
; (charp user_png_ver, voidp error_ptr,
; png_error_ptr error_fn, png_error_ptr warn_fn),
; PNG_ALLOCATED);
 
; Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
; match up.
 
; Read the information before the actual image data.
PNG_EXPORT 22, void, png_read_info, '(png_structrp png_ptr, png_inforp info_ptr)'
 
; Convert to a US string format: there is no localization support in this
; routine. The original implementation used a 29 character buffer in
; png_struct, this will be removed in future versions.
 
;#if PNG_LIBPNG_VER < 10700
; To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h)
;PNG_EXPORTA(23, charp, png_convert_to_rfc1123, (png_structrp png_ptr,
; png_const_timep ptime),PNG_DEPRECATED);
;end if
 
; Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available.
PNG_EXPORT 26, void, png_set_expand, '(png_structrp png_ptr)'
PNG_EXPORT 27, void, png_set_expand_gray_1_2_4_to_8, '(png_structrp png_ptr)'
PNG_EXPORT 28, void, png_set_palette_to_rgb, '(png_structrp png_ptr)'
PNG_EXPORT 29, void, png_set_tRNS_to_alpha, '(png_structrp png_ptr)'
 
; Expand to 16-bit channels, forces conversion of palette to RGB and expansion
; of a tRNS chunk if present.
PNG_EXPORT 221, void, png_set_expand_16, '(png_structrp png_ptr)'
 
; Expand the grayscale to 24-bit RGB if necessary.
PNG_EXPORT 31, void, png_set_gray_to_rgb, '(png_structrp png_ptr)'
 
; Reduce RGB to grayscale.
PNG_ERROR_ACTION_NONE equ 1
PNG_ERROR_ACTION_WARN equ 2
849,13 → 814,6
PNG_ERROR_ACTION_ERROR equ 3
PNG_RGB_TO_GRAY_DEFAULT equ (-1) ;for red/green coefficients
 
PNG_EXPORT 32, void, png_set_rgb_to_gray, '(png_structrp png_ptr, int error_action, double red, double green)'
PNG_EXPORT 33, void, png_set_rgb_to_gray_fixed, '(png_structrp png_ptr, int error_action, png_fixed_point red, png_fixed_point green)'
 
PNG_EXPORT 34, byte, png_get_rgb_to_gray_status, '(png_const_structrp png_ptr)'
 
PNG_EXPORT 35, void, png_build_grayscale_palette, '(int bit_depth, png_colorp palette)'
 
; How the alpha channel is interpreted - this affects how the color channels
; of a PNG file are returned to the calling application when an alpha channel,
; or a tRNS chunk in a palette file, is present.
897,9 → 855,6
PNG_ALPHA_OPTIMIZED equ 2 ;'PNG' for opaque pixels, else 'STANDARD'
PNG_ALPHA_BROKEN equ 3 ;the alpha channel is gamma encoded
 
PNG_EXPORT 227, void, png_set_alpha_mode, '(png_structrp png_ptr, int mode, double output_gamma)'
PNG_EXPORT 228, void, png_set_alpha_mode_fixed, '(png_structrp png_ptr, int mode, png_fixed_point output_gamma)'
 
if (PNG_GAMMA_SUPPORTED eq 1) | (PNG_READ_ALPHA_MODE_SUPPORTED eq 1)
; The output_gamma value is a screen gamma in libpng terminology: it expresses
; how to decode the output values, not how they are encoded.
910,83 → 865,6
PNG_GAMMA_LINEAR equ PNG_FP_1 ;Linear
end if
 
; The following are examples of calls to png_set_alpha_mode to achieve the
; required overall gamma correction and, where necessary, alpha
; premultiplication.
 
; png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
; This is the default libpng handling of the alpha channel - it is not
; pre-multiplied into the color components. In addition the call states
; that the output is for a sRGB system and causes all PNG files without gAMA
; chunks to be assumed to be encoded using sRGB.
 
; png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
; In this case the output is assumed to be something like an sRGB conformant
; display preceeded by a power-law lookup table of power 1.45. This is how
; early Mac systems behaved.
 
; png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
; This is the classic Jim Blinn approach and will work in academic
; environments where everything is done by the book. It has the shortcoming
; of assuming that input PNG data with no gamma information is linear - this
; is unlikely to be correct unless the PNG files where generated locally.
; Most of the time the output precision will be so low as to show
; significant banding in dark areas of the image.
 
; png_set_expand_16(pp);
; png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
; This is a somewhat more realistic Jim Blinn inspired approach. PNG files
; are assumed to have the sRGB encoding if not marked with a gamma value and
; the output is always 16 bits per component. This permits accurate scaling
; and processing of the data. If you know that your input PNG files were
; generated locally you might need to replace PNG_DEFAULT_sRGB with the
; correct value for your system.
 
; png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
; If you just need to composite the PNG image onto an existing background
; and if you control the code that does this you can use the optimization
; setting. In this case you just copy completely opaque pixels to the
; output. For pixels that are not completely transparent (you just skip
; those) you do the composition math using png_composite or png_composite_16
; below then encode the resultant 8-bit or 16-bit values to match the output
; encoding.
 
; Other cases
; If neither the PNG nor the standard linear encoding work for you because
; of the software or hardware you use then you have a big problem. The PNG
; case will probably result in halos around the image. The linear encoding
; will probably result in a washed out, too bright, image (it's actually too
; contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably
; substantially reduce the halos. Alternatively try:
 
; png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);
; This option will also reduce the halos, but there will be slight dark
; halos round the opaque parts of the image where the background is light.
; In the OPTIMIZED mode the halos will be light halos where the background
; is dark. Take your pick - the halos are unavoidable unless you can get
; your hardware/software fixed! (The OPTIMIZED approach is slightly
; faster.)
 
; When the default gamma of PNG files doesn't match the output gamma.
; If you have PNG files with no gamma information png_set_alpha_mode allows
; you to provide a default gamma, but it also sets the ouput gamma to the
; matching value. If you know your PNG files have a gamma that doesn't
; match the output you can take advantage of the fact that
; png_set_alpha_mode always sets the output gamma but only sets the PNG
; default if it is not already set:
 
; png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
; png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
; The first call sets both the default and the output gamma values, the
; second call overrides the output gamma without changing the default. This
; is easier than achieving the same effect with png_set_gamma. You must use
; PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will
; fire if more than one call to png_set_alpha_mode and png_set_background is
; made in the same read operation, however multiple calls with PNG_ALPHA_PNG
; are ignored.
 
PNG_EXPORT 36, void, png_set_strip_alpha, '(png_structrp png_ptr)'
 
; The values of the PNG_FILLER_ defines should NOT be changed
PNG_FILLER_BEFORE equ 0
PNG_FILLER_AFTER equ 1
998,9 → 876,6
; read. Doing so will result in unexpected behavior and possible warnings or
; errors if the PNG file contains a bKGD chunk.
 
PNG_EXPORT 47, void, png_set_background, '(png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, double background_gamma)'
PNG_EXPORT 215, void, png_set_background_fixed, '(png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, png_fixed_point background_gamma)'
 
if PNG_READ_BACKGROUND_SUPPORTED eq 1
PNG_BACKGROUND_GAMMA_UNKNOWN equ 0
PNG_BACKGROUND_GAMMA_SCREEN equ 1
1008,22 → 883,12
PNG_BACKGROUND_GAMMA_UNIQUE equ 3
end if
 
; Scale a 16-bit depth file down to 8-bit, accurately.
PNG_EXPORT 229, void, png_set_scale_16, '(png_structrp png_ptr)'
;PNG_READ_16_TO_8_SUPPORTED equ 1 ;Name prior to 1.5.4
 
;#define PNG_READ_16_TO_8_SUPPORTED /* Name prior to 1.5.4 */
; Strip the second byte of information from a 16-bit depth file.
PNG_EXPORT 48, void, png_set_strip_16, '(png_structrp png_ptr)'
 
; Turn on quantizing, and reduce the palette to the number of colors
; available.
 
PNG_EXPORT 49, void, png_set_quantize, '(png_structrp png_ptr, png_colorp palette, int num_palette, int maximum_colors, png_const_uint_16p histogram, int full_quantize)'
 
; The threshold on gamma processing is configurable but hard-wired into the
; library. The following is the floating point variant.
 
;#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)
PNG_GAMMA_THRESHOLD equ (PNG_GAMMA_THRESHOLD_FIXED*.00001)
 
; Handle gamma correction. Screen_gamma=(display_exponent).
; NOTE: this API simply sets the screen and file gamma values. It will
1031,38 → 896,7
; the file header has been read - use with care - call before reading the PNG
; file for best results!
 
; These routines accept the same gamma values as png_set_alpha_mode (described
; above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either
; API (floating point or fixed.) Notice, however, that the 'file_gamma' value
; is the inverse of a 'screen gamma' value.
 
PNG_EXPORT 50, void, png_set_gamma, '(png_structrp png_ptr, double screen_gamma, double override_file_gamma)'
PNG_EXPORT 208, void, png_set_gamma_fixed, '(png_structrp png_ptr, png_fixed_point screen_gamma, png_fixed_point override_file_gamma)'
 
; Optional update palette with requested transformations
PNG_EXPORT 53, void, png_start_read_image, '(png_structrp png_ptr)'
 
; Optional call to update the users info structure
PNG_EXPORT 54, void, png_read_update_info, '(png_structrp png_ptr, png_inforp info_ptr)'
 
; Read one or more rows of image data.
PNG_EXPORT 55, void, png_read_rows, '(png_structrp png_ptr, bytepp row, bytepp display_row, uint_32 num_rows)'
 
; Read a row of data.
PNG_EXPORT 56, void, png_read_row, '(png_structrp png_ptr, bytep row, bytep display_row)'
 
; Read the whole image into memory at once.
PNG_EXPORT 57, void, png_read_image, '(png_structrp png_ptr, bytepp image)'
 
; Read the end of the PNG file.
PNG_EXPORT 62, void, png_read_end, '(png_structrp png_ptr, png_inforp info_ptr)'
 
; Free any memory associated with the png_struct and the png_info_structs
PNG_EXPORT 64, void, png_destroy_read_struct, '(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)'
 
; Set the libpng method of handling chunk CRC errors
PNG_EXPORT 66, void, png_set_crc_action, '(png_structrp png_ptr, int crit_action, int ancil_action)'
 
; Values for png_set_crc_action() say how to handle CRC errors in
; ancillary and critical chunks, and whether to use the data contained
; therein. Note that it is impossible to "discard" data in a critical
1121,47 → 955,7
; Replace the default data input function with a user supplied one.
PNG_EXPORT 78, void, png_set_read_fn, '(png_structrp png_ptr, voidp io_ptr, png_rw_ptr read_data_fn)'
 
PNG_EXPORT 80, void, png_set_read_status_fn, '(png_structrp png_ptr, png_read_status_ptr read_row_fn)'
 
PNG_EXPORT 84, void, png_set_read_user_transform_fn, '(png_structrp png_ptr, png_user_transform_ptr read_user_transform_fn)'
 
if PNG_PROGRESSIVE_READ_SUPPORTED eq 1
; Sets the function callbacks for the push reader, and a pointer to a
; user-defined structure available to the callback functions.
 
PNG_EXPORT 90, void, png_set_progressive_read_fn, '(png_structrp png_ptr, voidp progressive_ptr, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)'
 
; Returns the user pointer associated with the push read functions
PNG_EXPORT 91, voidp, png_get_progressive_ptr, '(png_const_structrp png_ptr)'
 
; Function to be called when data becomes available
PNG_EXPORT 92, void, png_process_data, '(png_structrp png_ptr, png_inforp info_ptr, bytep buffer, png_size_t buffer_size)'
 
; A function which may be called *only* within png_process_data to stop the
; processing of any more data. The function returns the number of bytes
; remaining, excluding any that libpng has cached internally. A subsequent
; call to png_process_data must supply these bytes again. If the argument
; 'save' is set to true the routine will first save all the pending data and
; will always return 0.
 
PNG_EXPORT 219, png_size_t, png_process_data_pause, '(png_structrp, int save)'
 
; A function which may be called *only* outside (after) a call to
; png_process_data. It returns the number of bytes of data to skip in the
; input. Normally it will return 0, but if it returns a non-zero value the
; application must skip than number of bytes of input data and pass the
; following data to the next call to png_process_data.
 
PNG_EXPORT 220, uint_32, png_process_data_skip, '(png_structrp)'
 
; Function that combines rows. 'new_row' is a flag that should come from
; the callback and be non-NULL if anything needs to be done; the library
; stores its own version of the new data internally and ignores the passed
; in value.
 
PNG_EXPORT 93, void, png_progressive_combine_row, '(png_const_structrp png_ptr, bytep old_row, bytep new_row)'
end if ;PROGRESSIVE_READ
 
; Reassign responsibility for freeing existing data, whether allocated
; by libpng or by the application; this works on the png_info structure passed
; in, it does not change the state for other png_info structures.
1228,62 → 1022,7
;# endif
;end if
 
; Returns number of color channels in image.
PNG_EXPORT 114, byte, png_get_channels, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
 
; Returns pixel aspect ratio, computed from pHYs chunk data.
PNG_EXPORT 125, float, png_get_pixel_aspect_ratio, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
PNG_EXPORT 210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
 
; Returns image x, y offset in pixels or microns, from oFFs chunk data.
PNG_EXPORT 126, int_32, png_get_x_offset_pixels, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
PNG_EXPORT 127, int_32, png_get_y_offset_pixels, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
PNG_EXPORT 128, int_32, png_get_x_offset_microns, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
PNG_EXPORT 129, int_32, png_get_y_offset_microns, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
 
; Returns pointer to signature string read from PNG header
PNG_EXPORT 130, bytep, png_get_signature, '(png_const_structrp png_ptr, png_const_inforp info_ptr)'
 
PNG_EXPORT 131, uint_32, png_get_bKGD, '(png_const_structrp png_ptr, png_inforp info_ptr, png_color_16p *background)'
 
PNG_EXPORT 133, uint_32, png_get_cHRM, '(png_const_structrp png_ptr, png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, double *red_y, double *green_x, double *green_y, double *blue_x, double *blue_y)'
PNG_EXPORT 230, uint_32, png_get_cHRM_XYZ, '(png_const_structrp png_ptr, png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z, double *green_X, double *green_Y, double *green_Z, double *blue_X, double *blue_Y, double *blue_Z)'
PNG_EXPORT 134, uint_32, png_get_cHRM_fixed, '(png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point *int_white_x, png_fixed_point *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)'
 
PNG_EXPORT 137, uint_32, png_get_gAMA, '(png_const_structrp png_ptr, png_const_inforp info_ptr, double *file_gamma)'
PNG_EXPORT 138, uint_32, png_get_gAMA_fixed, '(png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point *int_file_gamma)'
 
PNG_EXPORT 145, uint_32, png_get_oFFs, '(png_const_structrp png_ptr, png_const_inforp info_ptr, int_32 *offset_x, int_32 *offset_y, int *unit_type)'
 
PNG_EXPORT 147, uint_32, png_get_pCAL, '(png_const_structrp png_ptr, png_inforp info_ptr, charp *purpose, int_32 *X0, int_32 *X1, int *type, int *nparams, charp *units, charpp *params)'
 
PNG_EXPORT 149, uint_32, png_get_pHYs, '(png_const_structrp png_ptr, png_const_inforp info_ptr, uint_32 *res_x, uint_32 *res_y, int *unit_type)'
 
PNG_EXPORT 151, uint_32, png_get_PLTE, '(png_const_structrp png_ptr, png_inforp info_ptr, png_colorp *palette, int *num_palette)'
 
PNG_EXPORT 153, uint_32, png_get_sBIT, '(png_const_structrp png_ptr, png_inforp info_ptr, png_color_8p *sig_bit)'
 
PNG_EXPORT 155, uint_32, png_get_sRGB, '(png_const_structrp png_ptr, png_const_inforp info_ptr, int *file_srgb_intent)'
 
; png_get_text also returns the number of text chunks in *num_text
PNG_EXPORT 162, int, png_get_text, '(png_const_structrp png_ptr, png_inforp info_ptr, png_textp *text_ptr, int *num_text)'
 
PNG_EXPORT 164, uint_32, png_get_tIME, '(png_const_structrp png_ptr, png_inforp info_ptr, png_timep *mod_time)'
 
PNG_EXPORT 166, uint_32, png_get_tRNS, '(png_const_structrp png_ptr, png_inforp info_ptr, bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)'
 
PNG_EXPORT 168, uint_32, png_get_sCAL, '(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, double *width, double *height)'
 
; NOTE: this API is currently implemented using floating point arithmetic,
; consequently it can only be used on systems with floating point support.
; In any case the range of values supported by png_fixed_point is small and it
; is highly recommended that png_get_sCAL_s be used instead.
 
PNG_EXPORT 214, uint_32, png_get_sCAL_fixed, '(png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, png_fixed_point *width, png_fixed_point *height)'
 
PNG_EXPORT 170, void, png_set_sCAL, '(png_const_structrp png_ptr, png_inforp info_ptr, int unit, double width, double height)'
PNG_EXPORT 171, void, png_set_sCAL_s, '(png_const_structrp png_ptr, png_inforp info_ptr, int unit, charp swidth, charp sheight)'
 
; Provide the default handling for all unknown chunks or, optionally, for
; specific unknown chunks.
 
1383,9 → 1122,6
; be processed by libpng.
 
 
; The "params" pointer is currently not used and is for future expansion.
PNG_EXPORT 178, void, png_read_png, '(png_structrp png_ptr, png_inforp info_ptr, int transforms, voidp params)'
 
; For use in png_set_keep_unknown, added to version 1.2.6
PNG_HANDLE_CHUNK_AS_DEFAULT equ 0
PNG_HANDLE_CHUNK_NEVER equ 1
1413,7 → 1149,7
; libpng interlace handling is turned off the macros may be used to handle
; interlaced images within the application.
 
;#define PNG_INTERLACE_ADAM7_PASSES 7
PNG_INTERLACE_ADAM7_PASSES equ 7
 
; Two macros to return the first row and first column of the original,
; full, image which appears in a given pass. 'pass' is in the range 0
1423,8 → 1159,8
{
push ebx ecx
mov eax,pass
mov ebx,eax
not eax
mov ebx,pass
and eax,1
shr ebx,1
mov ecx,3
1437,7 → 1173,7
{
push ebx ecx
mov eax,pass
mov ebx,pass
mov ebx,eax
and eax,1
inc ebx
shr ebx,1
1597,14 → 1333,7
; 32767) / 65535))
;end if /* READ_COMPOSITE_NODIV */
 
PNG_EXPORT 201, uint_32, png_get_uint_32, '(bytep buf)'
PNG_EXPORT 202, uint_16, png_get_uint_16, '(bytep buf)'
PNG_EXPORT 203, int_32, png_get_int_32, '(bytep buf)'
 
PNG_EXPORT 204, uint_32, png_get_uint_31, '(png_const_structrp png_ptr, bytep buf)'
; No png_get_int_16 -- may be added if there's a real need for it.
 
;if PNG_USE_READ_MACROS
if PNG_USE_READ_MACROS eq 1
; Inline macros to do direct reads of bytes from the input buffer.
; The png_get_int_32() routine assumes we are using two's complement
; format for negative values, which is almost certainly true.
1627,24 → 1356,8
; ((int_32)((*(buf) & 0x80) \
; ? -((int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \
; : (int_32)png_get_uint_32(buf)))
end if
 
; If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
; but defining a macro name prefixed with PNG_PREFIX.
 
;# ifndef PNG_PREFIX
;# define png_get_uint_32(buf) PNG_get_uint_32(buf)
;# define png_get_uint_16(buf) PNG_get_uint_16(buf)
;# define png_get_int_32(buf) PNG_get_int_32(buf)
;# endif
;#else
;# ifdef PNG_PREFIX
; No macros; revert to the (redefined) function
;# define PNG_get_uint_32 (png_get_uint_32)
;# define PNG_get_uint_16 (png_get_uint_16)
;# define PNG_get_int_32 (png_get_int_32)
;# endif
;end if
 
;/*******************************************************************************
; Section 5: SIMPLIFIED API
; *******************************************************************************
1804,13 → 1517,9
PNG_FORMAT_FLAG_LINEAR equ 0x04 ;2-byte channels else 1-byte
PNG_FORMAT_FLAG_COLORMAP equ 0x08 ;image data is color-mapped
 
;if PNG_FORMAT_BGR_SUPPORTED
PNG_FORMAT_FLAG_BGR equ 0x10 ;BGR colors, else order is RGB
;end if
 
;if PNG_FORMAT_AFIRST_SUPPORTED
PNG_FORMAT_FLAG_AFIRST equ 0x20 ;alpha channel comes first
;end if
 
; Commonly used formats have predefined macros.
 
2007,63 → 1716,8
; NOTE: the flag can only be set after the png_image_begin_read_ call,
; because that call initializes the 'flags' field.
 
 
;if PNG_SIMPLIFIED_READ_SUPPORTED
; READ APIs
; ---------
 
; The png_image passed to the read APIs must have been initialized by setting
; the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.)
 
if PNG_STDIO_SUPPORTED eq 1
PNG_EXPORT 234, int, png_image_begin_read_from_file, '(png_imagep image, const char *file_name)'
; The named file is opened for read and the image header is filled in
; from the PNG header in the file.
 
PNG_EXPORT 235, int, png_image_begin_read_from_stdio, '(png_imagep image, FILE* file)'
; The PNG header is read from the stdio FILE object.
end if ;STDIO
 
PNG_EXPORT 236, int, png_image_begin_read_from_memory, '(png_imagep image, png_const_voidp memory, png_size_t size)'
; The PNG header is read from the given memory buffer.
 
PNG_EXPORT 237, int, png_image_finish_read, '(png_imagep image, png_const_colorp background, void *buffer, int_32 row_stride, void *colormap)'
; Finish reading the image into the supplied buffer and clean up the
; png_image structure.
 
; row_stride is the step, in byte or 2-byte units as appropriate,
; between adjacent rows. A positive stride indicates that the top-most row
; is first in the buffer - the normal top-down arrangement. A negative
; stride indicates that the bottom-most row is first in the buffer.
 
; background need only be supplied if an alpha channel must be removed from
; a byte format and the removal is to be done by compositing on a solid
; color; otherwise it may be NULL and any composition will be done directly
; onto the buffer. The value is an sRGB color to use for the background,
; for grayscale output the green channel is used.
 
; background must be supplied when an alpha channel must be removed from a
; single byte color-mapped output format, in other words if:
 
; 1) The original format from png_image_begin_read_from_* had
; PNG_FORMAT_FLAG_ALPHA set.
; 2) The format set by the application does not.
; 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and
; PNG_FORMAT_FLAG_LINEAR *not* set.
 
; For linear output removing the alpha channel is always done by compositing
; on black and background is ignored.
 
; colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must
; be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE.
; image->colormap_entries will be updated to the actual number of entries
; written to the colormap; this may be less than the original value.
 
 
;end if /* SIMPLIFIED_READ */
 
;if PNG_SIMPLIFIED_WRITE_SUPPORTED
;/* WRITE APIS
if PNG_SIMPLIFIED_WRITE_SUPPORTED eq 1
; WRITE APIS
; ----------
; For write you must initialize a png_image structure to describe the image to
; be written. To do this use memset to set the whole structure to 0 then
2140,8 → 1794,8
 
;#define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\
; PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image))
; /* An upper bound on the size of the data in the PNG IDAT chunks. */
;
; An upper bound on the size of the data in the PNG IDAT chunks.
 
;#define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\
; ((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\
; (((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\
2149,12 → 1803,12
; (((image).format&PNG_FORMAT_FLAG_ALPHA)?\
; 12U/*tRNS*/+(image).colormap_entries:0U):0U)+\
; 12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size))
; /* A helper for the following macro; if your compiler cannot handle the
 
; A helper for the following macro; if your compiler cannot handle the
; following macro use this one with the result of
; PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most
; compilers should handle this just fine.)
 
 
;#define PNG_IMAGE_PNG_SIZE_MAX(image)\
; PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image))
; An upper bound on the total length of the PNG data stream for 'image'.
2162,7 → 1816,7
; overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will
; run out of buffer space but return a corrected size which should work.
 
;end if /* SIMPLIFIED_WRITE */
end if ;SIMPLIFIED_WRITE
;/*******************************************************************************
; END OF SIMPLIFIED API
; ******************************************************************************/
/programs/develop/libraries/libs-dev/libimg/png/libpng/pngset.asm
16,20 → 16,28
; info struct and allows us to change the structure in the future.
 
 
;void (png_structrp png_ptr, png_inforp info_ptr, png_const_color_16p background)
;void (png_structrp png_ptr, png_inforp info_ptr, png_color_16p background)
align 4
proc png_set_bKGD, png_ptr:dword, info_ptr:dword, background:dword
proc png_set_bKGD uses ecx edi esi, png_ptr:dword, info_ptr:dword, background:dword
png_debug1 1, 'in %s storage function', 'bKGD'
 
; if (png_ptr == NULL || info_ptr == NULL || background == NULL)
; return;
cmp dword[png_ptr],0
je .end_f
mov edi,[info_ptr]
cmp edi,0
je .end_f
mov esi,[background]
cmp esi,0
je .end_f ;if (..==0 || ..==0 || ..==0) return
 
; info_ptr->background = *background;
; info_ptr->valid |= PNG_INFO_bKGD;
or dword[edi+png_info_def.valid],PNG_INFO_bKGD
add edi,png_info_def.background
mov ecx,sizeof.png_color_16
rep movsb
.end_f:
ret
endp
 
;if PNG_cHRM_SUPPORTED
;void (png_structrp png_ptr, png_inforp info_ptr,
; png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,
; png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,
99,7 → 107,7
; &XYZ, 2) != 0)
; info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
 
stdcall png_colorspace_sync_info, edi, esi;
stdcall png_colorspace_sync_info, edi, esi
.end_f:
ret
endp
141,8 → 149,6
ret
endp
 
;end if /* cHRM */
 
;void (png_structrp png_ptr, png_inforp info_ptr, png_fixed_point file_gamma)
align 4
proc png_set_gAMA_fixed uses eax edi esi, png_ptr:dword, info_ptr:dword, file_gamma:dword
172,8 → 178,7
ret
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr,
; png_const_uint_16p hist)
;void (png_structrp png_ptr, png_inforp info_ptr, png_uint_16p hist)
align 4
proc png_set_hIST uses edi esi, png_ptr:dword, info_ptr:dword, hist:dword
; int i;
352,17 → 357,15
cmp dword[type],0
jl @f
cmp dword[type],3
jg @f ;if (..<0 || ..>3)
jmp .end0
jle .end0 ;if (..<0 || ..>3)
@@:
png_error edi, 'Invalid pCAL equation type'
.end0:
 
cmp dword[type],0
cmp dword[nparams],0
jl @f
cmp dword[type],255
jg @f ;if (..<0 || ..>255)
jmp .end1
cmp dword[nparams],255
jle .end1 ;if (..<0 || ..>255)
@@:
png_error edi, 'Invalid pCAL parameter count'
.end1:
588,8 → 591,7
ret
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr,
; png_const_colorp palette, int num_palette)
;void (png_structrp png_ptr, png_inforp info_ptr, png_colorp palette, int num_palette)
align 4
proc png_set_PLTE uses eax edi esi, png_ptr:dword, info_ptr:dword, palette:dword, num_palette:dword
; uint_32 max_palette_length;
657,8 → 659,7
ret
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr,
; png_const_color_8p sig_bit)
;void (png_structrp png_ptr, png_inforp info_ptr, png_color_8p sig_bit)
align 4
proc png_set_sBIT, png_ptr:dword, info_ptr:dword, sig_bit:dword
png_debug1 1, 'in %s storage function', 'sBIT'
783,8 → 784,7
ret
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr,
; png_const_textp text_ptr, int num_text)
;void (png_structrp png_ptr, png_inforp info_ptr, png_textp text_ptr, int num_text)
align 4
proc png_set_text uses eax edi, png_ptr:dword, info_ptr:dword, text_ptr:dword, num_text:dword
mov edi,[png_ptr]
798,7 → 798,7
endp
 
;int (png_structrp png_ptr, png_inforp info_ptr,
; png_const_textp text_ptr, int num_text)
; png_textp text_ptr, int num_text)
align 4
proc png_set_text_2, png_ptr:dword, info_ptr:dword, text_ptr:dword, num_text:dword
; int i;
991,7 → 991,7
ret
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr, png_const_timep mod_time)
;void (png_structrp png_ptr, png_inforp info_ptr, png_timep mod_time)
align 4
proc png_set_tIME uses eax ebx ecx edi esi, png_ptr:dword, info_ptr:dword, mod_time:dword
png_debug1 1, 'in %s storage function', 'tIME'
1040,7 → 1040,7
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr,
; bytep trans_alpha, int num_trans, png_const_color_16p trans_color)
; bytep trans_alpha, int num_trans, png_color_16p trans_color)
align 4
proc png_set_tRNS, png_ptr:dword, info_ptr:dword, trans_alpha:dword, num_trans:dword, trans_color:dword
png_debug1 1, 'in %s storage function', 'tRNS'
1106,7 → 1106,7
 
;if PNG_sPLT_SUPPORTED
;void (png_structrp png_ptr,
; png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)
; png_inforp info_ptr, png_sPLT_tp entries, int nentries)
 
; entries - array of png_sPLT_t structures
; to be added to the list of palettes
1190,7 → 1190,7
; memcpy(np->entries, entries->entries,
; entries->nentries * sizeof (png_sPLT_entry));
 
; /* Note that 'continue' skips the advance of the out pointer and out
; Note that 'continue' skips the advance of the out pointer and out
; count, so an invalid entry is not added.
 
; info_ptr->valid |= PNG_INFO_sPLT;
1211,7 → 1211,7
proc check_location, png_ptr:dword, location:dword
; location &= (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT);
 
; /* New in 1.6.0; copy the location and check it. This is an API
; New in 1.6.0; copy the location and check it. This is an API
; change; previously the app had to use the
; png_set_unknown_chunk_location API below for each chunk.
 
1225,13 → 1225,13
; (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT));
; }
 
; /* This need not be an internal error - if the app calls
; This need not be an internal error - if the app calls
; png_set_unknown_chunks on a read pointer it must get the location right.
 
; if (location == 0)
; png_error(png_ptr, "invalid location in png_set_unknown_chunks");
 
; /* Now reduce the location to the top-most set bit by removing each least
; Now reduce the location to the top-most set bit by removing each least
; significant bit in turn.
 
; while (location != (location & -location))
1245,7 → 1245,7
endp
 
;void (png_structrp png_ptr,
; png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)
; png_inforp info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
align 4
proc png_set_unknown_chunks uses edi esi, png_ptr:dword, info_ptr:dword, unknowns:dword, num_unknowns:dword
; png_unknown_chunkp np;
1657,7 → 1657,7
; }
 
;#ifndef __COVERITY__
; /* Some compilers complain that this is always false. However, it
; Some compilers complain that this is always false. However, it
; can be true when integer overflow happens.
 
; if (size > ZLIB_IO_MAX)
1834,7 → 1834,7
; bad_character = 32;
; }
 
; /* Terminate the keyword */
; Terminate the keyword
; *new_key = 0;
 
; if (key_len == 0)
/programs/develop/libraries/libs-dev/libimg/png/libpng/pngtrans.asm
822,7 → 822,7
cmp eax,0
je @f ;if (..!=0 && ..!=0)
cStr ,'info change after png_start_read_image or png_read_update_info'
stdcall png_app_error edi, eax
stdcall png_app_error, edi, eax
jmp .end_f
@@:
end if
/programs/develop/libraries/libs-dev/libimg/png/libpng/pngwrite.asm
32,8 → 32,7
jge .end_f
movzx eax,byte[ecx+png_unknown_chunk.location]
and eax,[where]
cmp eax,0
je .end0 ;if (..!=0)
jz .end0 ;if (..!=0)
; If per-chunk unknown chunk handling is enabled use it, otherwise
; just write the chunks the application has set.
 
108,8 → 107,7
 
mov eax,[edi+png_struct.mode]
and eax,PNG_WROTE_INFO_BEFORE_PLTE
cmp eax,0
jne .end_f ;if (..==0)
jnz .end_f ;if (..==0)
 
; Write PNG signature
stdcall png_write_sig, edi
117,8 → 115,7
if PNG_MNG_FEATURES_SUPPORTED eq 1
mov eax,[edi+png_struct.mode]
and eax,PNG_HAVE_PNG_SIGNATURE
cmp eax,0
je @f
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'
161,16 → 158,13
if PNG_WRITE_gAMA_SUPPORTED eq 1
movzx eax,word[esi+png_info_def.colorspace.flags]
and eax,PNG_COLORSPACE_INVALID
cmp eax,0
jne @f
jnz @f
movzx eax,word[esi+png_info_def.colorspace.flags]
and eax,PNG_COLORSPACE_FROM_gAMA
cmp eax,0
je @f
jz @f
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_gAMA
cmp eax,0
je @f ;if (..==0 && ..!=0 && ..!=0)
jz @f ;if (..==0 && ..!=0 && ..!=0)
stdcall png_write_gAMA_fixed, edi, [esi+png_info_def.colorspace.gamma]
@@:
end if
183,17 → 177,14
if PNG_WRITE_iCCP_SUPPORTED eq 1
movzx eax,word[esi+png_info_def.colorspace.flags]
and eax,PNG_COLORSPACE_INVALID
cmp eax,0
jne .end0
jnz .end0
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_iCCP
cmp eax,0
je .end0 ;if (..==0 && ..!=0)
jz .end0 ;if (..==0 && ..!=0)
if PNG_WRITE_sRGB_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_sRGB
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
png_app_warning edi, 'profile matches sRGB but writing iCCP instead'
@@:
end if
208,12 → 199,10
if PNG_WRITE_sRGB_SUPPORTED eq 1
movzx eax,word[esi+png_info_def.colorspace.flags]
and eax,PNG_COLORSPACE_INVALID
cmp eax,0
jne .end1
jnz .end1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_sRGB
cmp eax,0
je .end1 ;if (..==0 && ..!=0)
jz .end1 ;if (..==0 && ..!=0)
movzx eax,word[esi+png_info_def.colorspace.rendering_intent]
stdcall png_write_sRGB, edi, eax
.end1:
223,8 → 212,7
if PNG_WRITE_sBIT_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_sBIT
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
movzx eax,byte[esi+png_info_def.color_type]
push eax
mov eax,esi
237,16 → 225,13
if PNG_WRITE_cHRM_SUPPORTED eq 1
movzx eax,word[esi+png_info_def.colorspace.flags]
and eax,PNG_COLORSPACE_INVALID
cmp eax,0
jne @f
jnz @f
movzx eax,word[esi+png_info_def.colorspace.flags]
and eax,PNG_COLORSPACE_FROM_cHRM
cmp eax,0
je @f
jz @f
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_cHRM
cmp eax,0
je @f ;if (..==0 && ..!=0 && ..!=0)
jz @f ;if (..==0 && ..!=0 && ..!=0)
stdcall png_write_cHRM_fixed, edi, [esi+png_info_def.colorspace.end_points_xy]
@@:
end if
281,8 → 266,7
 
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_PLTE
cmp eax,0
je @f ;if (..!=0)
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
296,8 → 280,7
if PNG_WRITE_tRNS_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_tRNS
cmp eax,0
je .end_1 ;if (..!=0)
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 &&
324,8 → 307,7
if PNG_WRITE_bKGD_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_bKGD
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,esi
add eax,png_info_def.background
movzx ebx,byte[esi+png_info_def.color_type]
336,8 → 318,7
if PNG_WRITE_hIST_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_hIST
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
movzx ebx,word[esi+png_info_def.num_palette]
stdcall png_write_hIST, edi, [esi+png_info_def.hist], ebx
@@:
346,8 → 327,7
if PNG_WRITE_oFFs_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_oFFs
cmp eax,0
je @f ;if (..!=0)
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
@@:
356,8 → 336,7
if PNG_WRITE_pCAL_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_pCAL
cmp eax,0
je @f ;if (..!=0)
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]
367,8 → 346,7
if PNG_WRITE_sCAL_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_sCAL
cmp eax,0
je @f ;if (..!=0)
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]
@@:
377,8 → 355,7
if PNG_WRITE_pHYs_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_pHYs
cmp eax,0
je @f ;if (..!=0)
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
@@:
387,8 → 364,7
if PNG_WRITE_tIME_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_tIME
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,esi
add eax,png_info_def.mod_time
stdcall png_write_tIME, edi, eax
399,8 → 375,7
if PNG_WRITE_sPLT_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_sPLT
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,[esi+png_info_def.splt_palettes]
mov ecx,[esi+png_info_def.splt_palettes_num]
cmp ecx,1
495,8 → 470,7
 
mov eax,[edi+png_struct.mode]
and eax,PNG_HAVE_IDAT
cmp eax,0
jne @f ;if (..==0)
jnz @f ;if (..==0)
png_error edi, 'No IDATs written into file'
@@:
 
519,12 → 493,10
; Check to see if user has supplied a time chunk
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_tIME
cmp eax,0
je @f
jz @f
mov eax,[edi+png_struct.mode]
and eax,PNG_WROTE_tIME
cmp eax,0
jne @f ;if (..!=0 && ..==0)
jnz @f ;if (..!=0 && ..==0)
mov eax,esi
add eax,png_info_def.mod_time
stdcall png_write_tIME, edi, eax
652,8 → 624,7
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)
;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
801,8 → 772,7
mov ebx,[row_info]
movzx eax,byte[ebx+png_row_info.color_type]
and eax,PNG_COLOR_MASK_COLOR
cmp eax,0
je .end_f ;if (..!=0)
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)
904,8 → 874,7
; Make sure we wrote the header info
mov eax,[edi+png_struct.mode]
and eax,PNG_WROTE_INFO_BEFORE_PLTE
cmp eax,0
jne @f ;if(..==0)
jnz @f ;if(..==0)
png_error edi, 'png_write_info was never called before png_write_row'
@@:
 
913,8 → 882,7
if (PNG_WRITE_INVERT_SUPPORTED eq 0) & (PNG_READ_INVERT_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_INVERT_MONO
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_INVERT_SUPPORTED is not defined'
@@:
end if
922,8 → 890,7
if (PNG_WRITE_FILLER_SUPPORTED eq 0) & (PNG_READ_FILLER_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_FILLER
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_FILLER_SUPPORTED is not defined'
@@:
end if
931,8 → 898,7
if (PNG_WRITE_PACKSWAP_SUPPORTED eq 0) & (PNG_READ_PACKSWAP_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_PACKSWAP
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_PACKSWAP_SUPPORTED is not defined'
@@:
end if
940,8 → 906,7
if (PNG_WRITE_PACK_SUPPORTED eq 0) & (PNG_READ_PACK_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_PACK
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_PACK_SUPPORTED is not defined'
@@:
end if
949,8 → 914,7
if (PNG_WRITE_SHIFT_SUPPORTED eq 0) & (PNG_READ_SHIFT_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_SHIFT
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_SHIFT_SUPPORTED is not defined'
@@:
end if
958,8 → 922,7
if (PNG_WRITE_BGR_SUPPORTED eq 0) & (PNG_READ_BGR_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_BGR
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_BGR_SUPPORTED is not defined'
@@:
end if
967,8 → 930,7
if (PNG_WRITE_SWAP_SUPPORTED eq 0) & (PNG_READ_SWAP_SUPPORTED eq 1)
mov eax,[edi+png_struct.transformations]
and eax,PNG_SWAP_BYTES
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
png_warning edi, 'PNG_WRITE_SWAP_SUPPORTED is not defined'
@@:
end if
982,14 → 944,12
je .end1
mov eax,[edi+png_struct.transformations]
and eax,PNG_INTERLACE
cmp eax,0
je .end1 ;if(..!=0 && ..!=0)
jz .end1 ;if(..!=0 && ..!=0)
cmp byte[edi+png_struct.pass],0
jne @f
mov eax,[edi+png_struct.row_number]
and eax,0x07
cmp eax,0
je .end1 ;if (..!=0)
jz .end1 ;if (..!=0)
stdcall png_write_finish_row, edi
jmp .end_f
@@:
997,8 → 957,7
jne @f
mov eax,[edi+png_struct.row_number]
and eax,0x07
cmp eax,0
jne .end2
jnz .end2
cmp dword[edi+png_struct.width],5
jge .end1 ;if (..!=0 || ..<..)
.end2:
1018,8 → 977,7
jne @f
mov eax,[edi+png_struct.row_number]
and eax,0x03
cmp eax,0
jne .end3
jnz .end3
cmp dword[edi+png_struct.width],3
jge .end1 ;if (..!=0 || ..<..)
.end3:
1039,8 → 997,7
jne @f
mov eax,[edi+png_struct.row_number]
and eax,0x01
cmp eax,0
jne .end4
jnz .end4
cmp dword[edi+png_struct.width],2
jge .end1 ;if (..!=0 || ..<..)
.end4:
1051,8 → 1008,7
jne .end1
mov eax,[edi+png_struct.row_number]
and eax,0x01
cmp eax,0
jne .end1 ;if (..==0)
jnz .end1 ;if (..==0)
stdcall png_write_finish_row, edi
jmp .end_f
.end1:
1104,8 → 1060,7
jge @f
mov eax,[edi+png_struct.transformations]
and eax,PNG_INTERLACE
cmp eax,0
je @f ;if (.. && ..<.. && ..!=0)
jz @f ;if (.. && ..<.. && ..!=0)
movzx eax,byte[edi+png_struct.pass]
push eax
mov eax,[edi+png_struct.row_buf]
1151,8 → 1106,7
 
mov eax,[edi+png_struct.mng_features_permitted]
and eax,PNG_FLAG_MNG_FILTER_64
cmp eax,0
je @f
jz @f
cmp byte[edi+png_struct.filter_type],PNG_INTRAPIXEL_DIFFERENCING
jne @f ;if (..!=0 && ..==..)
; Intrapixel differencing
1240,8 → 1194,7
mov edi,[png_ptr]
mov eax,[edi+png_struct.flags]
and eax,PNG_FLAG_ZSTREAM_INITIALIZED
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,edi
add eax,png_struct.zstream
stdcall [deflateEnd], eax
1408,8 → 1361,7
@@:
mov eax,[filters]
and eax,PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH
cmp eax,0
je @f
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
1423,26 → 1375,22
 
mov eax,[filters]
and eax,PNG_FILTER_SUB
cmp eax,0
je @f ;if (..)
jz @f ;if (..)
inc ebx
@@:
mov eax,[filters]
and eax,PNG_FILTER_UP
cmp eax,0
je @f ;if (..)
jz @f ;if (..)
inc ebx
@@:
mov eax,[filters]
and eax,PNG_FILTER_AVG
cmp eax,0
je @f ;if (..)
jz @f ;if (..)
inc ebx
@@:
mov eax,[filters]
and eax,PNG_FILTER_PAETH
cmp eax,0
je @f ;if (..)
jz @f ;if (..)
inc ebx
@@:
; Allocate needed row buffers if they have not already been
1741,8 → 1689,7
; Invert monochrome pixels
mov eax,[transforms]
and eax,PNG_TRANSFORM_INVERT_MONO
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_INVERT_SUPPORTED eq 1
stdcall png_set_invert_mono,edi
else
1756,13 → 1703,11
 
mov eax,[transforms]
and eax,PNG_TRANSFORM_SHIFT
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_SHIFT_SUPPORTED eq 1
mov eax,[esi+png_info_def.valid]
and eax,PNG_INFO_sBIT
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
mov eax,esi
add eax,png_info_def.sig_bit
stdcall png_set_shift, edi, eax
1775,8 → 1720,7
; Pack pixels into bytes
mov eax,[transforms]
and eax,PNG_TRANSFORM_PACKING
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_PACK_SUPPORTED eq 1
stdcall png_set_packing, edi
else
1788,8 → 1732,7
; Swap location of alpha bytes from ARGB to RGBA
mov eax,[transforms]
and eax,PNG_TRANSFORM_SWAP_ALPHA
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_SWAP_ALPHA_SUPPORTED eq 1
stdcall png_set_swap_alpha, edi
else
1804,16 → 1747,13
 
mov eax,[transforms]
and eax,PNG_TRANSFORM_STRIP_FILLER_AFTER or PNG_TRANSFORM_STRIP_FILLER_BEFORE
cmp eax,0
je .end_0 ;if(..!=0)
jz .end_0 ;if(..!=0)
if PNG_WRITE_FILLER_SUPPORTED eq 1
and eax,PNG_TRANSFORM_STRIP_FILLER_AFTER
cmp eax,0
je .end_1 ;if(..!=0)
jz .end_1 ;if(..!=0)
mov eax,[transforms]
and eax,PNG_TRANSFORM_STRIP_FILLER_BEFORE
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
cStr ,'PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported'
stdcall png_app_error edi, eax
@@:
1832,8 → 1772,7
; Flip BGR pixels to RGB
mov eax,[transforms]
and eax,PNG_TRANSFORM_BGR
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_BGR_SUPPORTED eq 1
stdcall png_set_bgr, edi
else
1845,8 → 1784,7
; Swap bytes of 16-bit files to most significant byte first
mov eax,[transforms]
and eax,PNG_TRANSFORM_SWAP_ENDIAN
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_SWAP_SUPPORTED eq 1
stdcall png_set_swap, edi
else
1858,8 → 1796,7
; Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats
mov eax,[transforms]
and eax,PNG_TRANSFORM_PACKSWAP
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_PACKSWAP_SUPPORTED eq 1
stdcall png_set_packswap, edi
else
1871,8 → 1808,7
; Invert the alpha channel from opacity to transparency
mov eax,[transforms]
and eax,PNG_TRANSFORM_INVERT_ALPHA
cmp eax,0
je @f ;if(..!=0)
jz @f ;if(..!=0)
if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
stdcall png_set_invert_alpha, edi
else
2001,11 → 1937,10
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
mov ecx,1
cmp eax,0
je @f
jz @f
mov ecx,3
@@:
mov [channels],ecx
2014,13 → 1949,11
 
mov eax,[edx+png_image.format]
and eax,PNG_FORMAT_FLAG_ALPHA
cmp eax,0
je .end0 ;if (..!=0)
jz .end0 ;if (..!=0)
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
mov eax,[edx+png_image.format]
and eax,PNG_FORMAT_FLAG_AFIRST
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov dword[aindex],-1
inc dword[input_row] ;To point to the first component
inc dword[output_row]
2197,11 → 2130,10
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
mov ecx,1
cmp eax,0
je @f
jz @f
mov ecx,3
@@:
mov [channels],ecx
2210,8 → 2142,7
 
mov eax,[edx+png_image.format]
and eax,PNG_FORMAT_FLAG_ALPHA
cmp eax,0
je .end0 ;if (..!=0)
jz .end0 ;if (..!=0)
; bytep row_end;
; int aindex;
 
2345,12 → 2276,10
if (PNG_FORMAT_BGR_SUPPORTED eq 1) & (PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1)
mov eax,ecx
and eax,PNG_FORMAT_FLAG_AFIRST
cmp eax,0
je @f
jz @f
mov eax,ecx
and eax,PNG_FORMAT_FLAG_ALPHA
cmp eax,0
je @f
jz @f
mov dword[afirst],-1
@@:
end if
2358,8 → 2287,7
if PNG_FORMAT_BGR_SUPPORTED eq 1
mov eax,ecx
and eax,PNG_FORMAT_FLAG_BGR
cmp eax,0
je @f
jz @f
mov dword[bgr],2
@@:
end if
2604,8 → 2532,7
; Set the required transforms then write the rows in the correct order.
mov eax,[format]
and eax,PNG_FORMAT_FLAG_COLORMAP
cmp eax,0
je .end4 ;if (..!=0)
jz .end4 ;if (..!=0)
cmp dword[edx+png_image_write_control.colormap],0
je .end6
mov eax,[ebx+png_image.colormap_entries]
2639,14 → 2566,12
xor ecx,ecx
mov eax,[format]
and eax,PNG_FORMAT_FLAG_COLOR
cmp eax,0
je @f
jz @f
or ecx,PNG_COLOR_MASK_COLOR
@@:
mov eax,[format]
and eax,PNG_FORMAT_FLAG_ALPHA
cmp eax,0
je @f
jz @f
or ecx,PNG_COLOR_MASK_ALPHA
@@:
mov eax,8
2670,8 → 2595,7
 
mov eax,[ebx+png_image.flags]
and eax,PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB
cmp eax,0
jne @f ;if (..==0)
jnz @f ;if (..==0)
stdcall png_set_cHRM_fixed, edi, esi,\
31270, 32900,\ ;white
64000, 33000,\ ;red
2681,8 → 2605,7
@@:
mov eax,[ebx+png_image.flags]
and eax,PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB
cmp eax,0
jne @f ;else if (..==0)
jnz @f ;else if (..==0)
stdcall png_set_sRGB, edi, esi, PNG_sRGB_INTENT_PERCEPTUAL
jmp .end7
@@: ;else
2710,14 → 2633,12
if PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED eq 1
mov eax,[format]
and eax,PNG_FORMAT_FLAG_BGR
cmp eax,0
je .end12 ;if (..!=0)
jz .end12 ;if (..!=0)
cmp dword[colormap],0
jne @f
mov eax,[format]
and eax,PNG_FORMAT_FLAG_COLOR
cmp eax,0
je @f ;if (..==0 && ..!=0)
jz @f ;if (..==0 && ..!=0)
stdcall png_set_bgr, edi
@@:
and dword[format], not PNG_FORMAT_FLAG_BGR
2727,14 → 2648,12
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
mov eax,[format]
and eax,PNG_FORMAT_FLAG_AFIRST
cmp eax,0
je .end13 ;if (..!=0)
jz .end13 ;if (..!=0)
cmp dword[colormap],0
jne @f
mov eax,[format]
and eax,PNG_FORMAT_FLAG_ALPHA
cmp eax,0
je @f ;if (..==0 && ..!=0)
jz @f ;if (..==0 && ..!=0)
stdcall png_set_swap_alpha, edi
@@:
and dword[format], not PNG_FORMAT_FLAG_AFIRST
2754,8 → 2673,7
; 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)
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
png_error edi, 'png_write_image: unsupported transformation'
@@:
 
2783,8 → 2701,7
; Apply 'fast' options if the flag is set.
mov eax,[ebx+png_image.flags]
and eax,PNG_IMAGE_FLAG_FAST
cmp eax,0
je @f ;if (..!=0)
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
2919,6 → 2836,7
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)
2925,6 → 2843,12
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]
2956,22 → 2880,47
pop esi
mov [mins],ebx
 
push edx edi esi
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 .end2 ;if (..<..)
;png_debug 3, '(Up)'
mov eax,[edx+png_struct.try_row]
cmp eax,0
je .end2 ;if (..!=0)
mov ecx,esi
inc ecx
mov esi,eax
rep movsb ;copy row
.end2:
pop esi edi edx
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:
3011,8 → 2960,7
if PNG_WRITE_OPTIMIZE_CMF_SUPPORTED eq 1
mov eax,[edi+png_struct.mode]
and eax,PNG_HAVE_IDAT
cmp eax,0
jne @f
jnz @f
cmp byte[edi+png_struct.compression_type],PNG_COMPRESSION_TYPE_BASE
jne @f ;if (..==0 && ..==..)
stdcall png_image_size, edi
3034,6 → 2982,11
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]
3042,6 → 2995,18
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
/programs/develop/libraries/libs-dev/libimg/png/libpng/pngwtran.asm
501,11 → 501,10
if PNG_WRITE_USER_TRANSFORM_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_USER_TRANSFORM
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,[edi+png_struct.write_user_transform_fn]
cmp eax,0
je @f ;if (..!=0)
test eax,eax
jz @f ;if (..!=0)
stdcall eax, edi, esi, ebx ;User write transform function
; row_info:
; uint_32 width ;width of row
520,8 → 519,7
if PNG_WRITE_FILLER_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_FILLER
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,[edi+png_struct.flags]
and eax,PNG_FLAG_FILLER_AFTER
not eax
532,8 → 530,7
if PNG_WRITE_PACKSWAP_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_PACKSWAP
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_do_packswap, esi, ebx
@@:
end if
541,8 → 538,7
if PNG_WRITE_PACK_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_PACK
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
movzx eax,byte[edi+png_struct.bit_depth]
stdcall png_do_pack, esi, ebx, eax
@@:
552,8 → 548,7
if PNG_16BIT_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_SWAP_BYTES
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_do_swap, esi, ebx
@@:
end if
562,8 → 557,7
if PNG_WRITE_SHIFT_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_SHIFT
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
mov eax,edi
add eax,png_struct.shift
stdcall png_do_shift, esi, ebx, eax
573,8 → 567,7
if PNG_WRITE_SWAP_ALPHA_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_SWAP_ALPHA
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_do_write_swap_alpha, esi, ebx
@@:
end if
582,8 → 575,7
if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_INVERT_ALPHA
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_do_write_invert_alpha, esi, ebx
@@:
end if
591,8 → 583,7
if PNG_WRITE_BGR_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_BGR
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_do_bgr, esi, ebx
@@:
end if
600,8 → 591,7
if PNG_WRITE_INVERT_SUPPORTED eq 1
mov eax,[edi+png_struct.transformations]
and eax,PNG_INVERT_MONO
cmp eax,0
je @f ;if (..!=0)
jz @f ;if (..!=0)
stdcall png_do_invert, esi, ebx
@@:
end if
/programs/develop/libraries/libs-dev/libimg/png/libpng/pngwutil.asm
2887,12 → 2887,15
inc edx
.cycle1:
lodsb
mov ah,byte[ebx]
shr ah,1
shl eax,24
movzx ax,byte[ebx]
add al,byte[edx]
jnc @f
mov ah,1
@@:
shr ax,1
rol eax,8
sub al,ah
mov ah,byte[edx]
shr ah,1
sub al,ah
stosb
png_setup_abs [sum]
mov eax,[sum]