NAME

get_gAMA

    my $gamma = $png->get_gAMA ();

Get the gamma value or gAMA chunk. The return value is a floating-point number.

This function corresponds to png_get_gAMA in libpng

set_gAMA

    $png->set_gAMA (0.2);

Set the gamma value or gAMA chunk.

This function corresponds to png_set_gAMA in libpng

hIST

get_hIST

    my $hist = $png->get_hIST ();

If the PNG file contains a histogram, the return value is array reference, otherwise it is the undefined value. The number of entries in the array reference is the same as in the palette.

This function corresponds to png_get_hIST in libpng

set_hIST

    $png->set_hIST (\@hist);

Set the histogram of frequencies of the colors of a paletted ("PLTE") image. The entries of the histogram are 16 bit unsigned integers, so the maximum value that can be entered is 65535 = 2^16 - 1. Larger numbers and floating point numbers will cause a warning to be printed and the value to be set to zero. The histogram must have exactly the same number of entries as the palette or the call will fail with a warning. A histogram cannot be added to an image without a palette. A call to set_hIST for an image without a palette will cause a warning and return without setting the value.

(I'm not sure of the best form of error handling for this function so it may change in future versions to have errors for a bad histogram rather than warnings.)

This function corresponds to png_set_hIST in libpng

iCCP

get_iCCP

    my $iccp = $png->get_iCCP ();

The return value is a hash with two keys,

name: The name of the profile.
profile: The color profile.

The compression_type value, which is always 0, is not returned. See "Unused arguments omitted".

This function corresponds to png_get_iCCP in libpng.

set_iCCP

    $png->set_iCCP ({name => 'name', profile => 'profile'});

This function corresponds to png_set_iCCP in libpng. For details of the arguments, see "get_iCCP". A compression_type argument, which must always be 0 anyway, is ignored. See "Unused arguments omitted".

oFFs

This is an extension to the PNG specification. See http://www.libpng.org/pub/png/spec/1.1/pngext-1.1.0-pdg.html#C.oFFs.

get_oFFs

    my $phys = $png->get_oFFs ();

Get oFFs chunk. Return value is a hash reference

This function corresponds to png_get_oFFs in libpng

set_oFFs

    $png->set_oFFs ({x_offset => 1, y_offset => 1, unit_type => 0});

Set oFFs chunk. See the specification linked above for the meanings of the parameters. If unit_type is not 0 or 1, a warning is produced.

This function corresponds to png_set_oFFs in libpng

pCAL

pCAL is an extension of the PNG specification which allows one to associate pixels in the PNG image with non-image data such as a heat map. See http://www.libpng.org/pub/png/spec/1.1/pngext-1.1.0-pdg.html#C.pCAL.

To test whether your version of libpng supports the pCAL extension, use "libpng_supports" with argument '"pCAL"':

    if (libpng_supports ('pCAL')) {
        # do something
    }

get_pCAL

    my $pcal = $png->get_pCAL ();

The return value is a hash reference with the following keys:

params: If this exists, its value is a reference to an array containing the parameter list of the pCAL chunk, which are floating point numbers. Within the PNG file chunk, these parameters are stored as strings representing floating point numbers, but you can pass in Perl floating point numbers rather than strings. The number of parameters you should set is fixed by the type parameter. Refer to the PNG specification for full details.
purpose: The purpose string of the pCAL chunk.
type: The equation type as a number, from 0 to 3. See the PNG specification for the meanings. Other numbers cause an error.
units: The units as a string. See the PNG specification for details.
x0: The zero value for the equation, an integer.
x1: The max value for the equation, an integer.

This function corresponds to png_get_pCAL in libpng

set_pCAL

    $png->set_pCAL (\%values);

See "get_pCAL" for the parameters of %values.

This function corresponds to png_set_pCAL in libpng

pHYs

get_pHYs

    my $phys = $png->get_pHYs ();

The return value is a hash reference with the keys

res_x
res_y
unit_type: Is either 0 or 1.

This function corresponds to png_get_pHYs in libpng

set_pHYs

    $png->set_pHYs ({res_x => 1, res_y => 1, unit_type => 1});

This function corresponds to png_set_pHYs in libpng

PLTE

See this subsection of "The PNG specification" for information on the PNG standards for the palette chunk.

get_palette_max

    my $pmax = $png->get_palette_max ();

If your libpng supports it, this will return the maximum palette index found in the image, or "-1" if the palette was not checked, or "0" if no palette was found.

To test whether your version of libpng supports get_palette_max, use "libpng_supports" with argument '"GET_PALETTE_MAX"':

    if (libpng_supports ('GET_PALETTE_MAX')) {
        # do something
    }

⛐🤪⚠ This function is implemented but so far it is not very clear to me what it does, since, for example, it returns zero for the test image t/tantei-san.png which is an image with a fully-used 256-color palette. I've asked about it on the libpng mailing list, but so far nobody has responded.

get_PLTE

     my $colors = $png->get_PLTE ();
     # Get the green value of the twentieth entry in the palette.
     my $green = $colors->[20]->{green};

This function gets the palette from the PNG. The return value is an array reference containing the palette. This array contains hash references with the values "green", "blue" and "red" for the color of each pixel in the palette. If the PNG has no palette, it returns an undefined value.

A PNG image may or may not contain a palette. To check whether the image contains a palette, use something of the following form:

     use Image::PNG::Const ':all';
     my $color_type = $png->get_color_type ();
     if ($color_type == PNG_COLOR_TYPE_PALETTE) {
         # The PNG uses a palette.
     }

A PNG image may also contain a palette even when the "color_type" does not indicate that. To check for that case, use "get_valid".

This function corresponds to png_get_PLTE in libpng.

set_PLTE

    $png->set_PLTE ($palette);

Set the palette of $png. The argument is an array reference containing hash references. There is one hash reference for each palette entry. The hash references contain three fields, red, green, and blue, corresponding to the pixel value for that palette entry. Other values in the hash references are ignored. For example,

    $png->set_PLTE ([{red => 1, green => 99, blue => 0x10},
                     {red => 0xFF, green => 0xFF, blue => 0xFF}]);

creates a palette with two entries in $png.

This function corresponds to png_set_PLTE in libpng.

sBIT

get_sBIT

    my $sbit = $png->get_sBIT ();

The return value is a hash reference containing integer values for the keys red, blue, green, gray and alpha, depending on the color_type of $png.

⛐🤪⚠ Prior to version 0.50 of this module, get_sBIT wrote values of 0 for all of the keys, regardless of the color_type, causing errors in some circumstances. From version 0.50, hash keys are not entered if the color_type of the image makes them invalid.

This function corresponds to png_get_sBIT in libpng

set_sBIT

    $png->set_sBIT ({red => 1, blue => 2, green => 3});

The argument is a hash reference containing integer values for the keys red, blue, green, gray, and alpha, as required by the color_type of $png.

This function corresponds to png_set_sBIT in libpng

sCAL

This is an extension to the PNG specification. See http://www.libpng.org/pub/png/spec/1.1/pngext-1.1.0-pdg.html#C.sCAL.

To test whether your version of libpng supports the sCAL chunk, use "libpng_supports" with argument '"sCAL"':

    if (libpng_supports ('sCAL')) {
        # do something
    }

get_sCAL

    my $scal = $png->get_sCAL ();

The returned hash value contains the following keys:

unit: The unit type, which is either PNG_SCALE_UNKNOWN, PNG_SCALE_METER, or PNG_SCALE_RADIAN.
width: The width, as a string.
height: The height, as a string.

This function corresponds to png_get_sCAL_s in libpng. Note that this uses the sCAL_s function rather than the get_sCAL and the returned values are the strings themselves rather than parsed numbers.

set_sCAL

    $png->set_sCAL ($scal);

$scal is a hash reference containing the keys described in "get_sCAL".

This function corresponds to png_set_sCAL_s in libpng. Note that this uses the set_sCAL_s function rather than set_sCAL and the input values are the strings themselves rather than numbers.

sPLT

get_sPLT

⛐🤪⚠ Provisional. See "set_sPLT" for documentation, the return value is like the input of that.

set_sPLT

    $png->set_sPLT ([{ name => 'palette', depth => 8, entries => [{red => 1, blue => 2},]}]);

Set suggested palettes. The input is an array reference containing hash references with the following fields:

name

The name of the suggested palette.

depth

The depth of the suggested palette.

entries

The entries of the palette. This is an array reference containing hash references with keys as follows:

red
blue
green
frequency
alpha

The field nentries which is returned by "get_sPLT" does not need to be specified, it is calculated from the length of entries.

sRGB

get_sRGB

    my $sRGB = $png->get_sRGB ();

The return value is an integer number corresponding to one of the following:

PNG_sRGB_INTENT_SATURATION
PNG_sRGB_INTENT_PERCEPTUAL
PNG_sRGB_INTENT_ABSOLUTE
PNG_sRGB_INTENT_RELATIVE

This function corresponds to png_get_sRGB in libpng

set_sRGB

    $png->set_sRGB ($srgb);

$srgb is one of the values described in "get_sRGB".

This function corresponds to png_set_sRGB in libpng

tIME

See this subsection of "The PNG specification" for information on the PNG standards for time stamp information.

get_tIME

    my $time = $png->get_tIME ();
    if ($time && $time->{year} < 2005) {
        warn "Your PNG is now getting old. Don't forget to oil it to prevent rust.";
    }

The return value is either the undefined value, if no tIME chunk exists in the PNG, or a hash reference containing fields year, month, day, hour, minute and second. month and day start from 1 rather than 0.

The "modification time value" of the PNG image is a chunk written into the PNG file itself, and may not have the same value as the operating system's modification time for the file. The tIME chunk is not a compulsory requirement for PNG files, and most PNG image files do not contain this chunk. PNG tIME chunks do not contain a time zone. According to this subsection of "The PNG specification", "Universal Time (UTC) should be specified rather than local time."

This function corresponds to png_get_tIME in libpng, with a Perl hash reference substituted for the C struct png_timep used in libpng.

set_tIME

    # Set the time to "now"
    $png->set_tIME ();
    # Set the time
    $png->set_tIME ({year => 1999, month => 12});

Set the modification time of the PNG to the values given by the argument, a hash reference containing the fields year, month, day for the day of the month, hour, minute, and second. The numbering for month and day is from 1, not 0. If any of year, hour, minute or second is omitted from the hash reference, these are set to zero. If month or day are omitted, these are set to 1. PNG tIME chunks do not contain a time zone. According to this subsection of "The PNG specification", "Universal Time (UTC) should be specified rather than local time." If the entire argument is omitted or contains an invalid value, the time is set to the current time.

This function corresponds to png_set_tIME in libpng, with a Perl hash reference substituted for the C struct png_timep used in libpng.

tRNS

Original image, licence statement and copyright notice here.

get_tRNS

    my $trns = $png->get_tRNS ();

Get the tRNS chunk. If the image is a palette type, this is an array reference. If the image is a non-palette type, this is a hash containing values for the keys red, green, blue, and gray.

set_tRNS

    $png->set_tRNS ($trns);

Set the tRNS chunk. If the image is a palette type, $trns is a reference to an array of positive or zero values between 0 and 255 of the same size as the palette. It must not contain more than 256 values. If the image is not a palette type, $trns is a hash reference containing values for the keys red, green, blue and gray.

Libpng transformations

set_bgr

    $png->set_bgr ();

⛐🤪⚠ Untested. Flips RGB to BGR. See the libpng manual for details.

To test whether your version of libpng supports set_bgr, for a read object, use "libpng_supports" with argument '"READ_BGR"'.

    if (libpng_supports ('READ_BGR')) {
        # do something
    }

For a write object, use argument '"WRITE_BGR"'.

This function corresponds to png_set_bgr in libpng

set_expand

    $png->set_expand ();

Set transformation in $png such that paletted images are expanded to RGB, grayscale images of bit-depth less than 8 are expanded to 8-bit images, and tRNS chunks are expanded to alpha channels.

To test whether your version of libpng supports set_expand, use "libpng_supports" with argument '"READ_EXPAND"':

    if (libpng_supports ('READ_EXPAND')) {
        # do something
    }

This function corresponds to png_set_expand in libpng

set_expand_16

    $png->set_expand_16 ();

⛐🤪⚠ Untested.

To test whether your version of libpng supports set_expand_16, use "libpng_supports" with argument '"READ_EXPAND_16"':

    if (libpng_supports ('READ_EXPAND_16')) {
        # do something
    }

This function corresponds to png_set_expand_16 in libpng

set_expand_gray_1_2_4_to_8

    $png->set_expand_gray_1_2_4_to_8 ();

⛐🤪⚠ Untested.

To test whether your version of libpng supports set_expand_gray_1_2_4_to_8, use "libpng_supports" with argument '"READ_EXPAND"':

    if (libpng_supports ('READ_EXPAND')) {
        # do something
    }

This function corresponds to png_set_expand_gray_1_2_4_to_8 in libpng

set_gray_to_rgb

    $png->set_gray_to_rgb ();

Convert a grayscale PNG file to RGB format on reading.

To test whether your version of libpng supports set_gray_to_rgb, use "libpng_supports" with argument '"READ_GRAY_TO_RGB"':

    if (libpng_supports ('READ_GRAY_TO_RGB')) {
        # do something
    }

This function corresponds to png_set_gray_to_rgb in libpng

set_invert_alpha

    $png->set_invert_alpha ();

⛐🤪⚠ Untested. See the libpng manual for details.

To test whether your version of libpng supports set_invert_alpha, use "libpng_supports" with argument '"READ_INVERT_ALPHA"':

    if (libpng_supports ('READ_INVERT_ALPHA')) {
        # do something
    }

This function corresponds to png_set_invert_alpha in libpng

set_invert_mono

    $png->set_invert_mono ();

Invert monochrome images. See the libpng manual for details.

To test whether your version of libpng supports set_invert_mono, use "libpng_supports" with argument '"READ_INVERT"':

    if (libpng_supports ('READ_INVERT')) {
        # do something
    }

This function corresponds to png_set_invert_mono in libpng

set_packing

    $png->set_packing ();

When reading a PNG, expand the image to 1 pixel per byte for bit-depths 1, 2 and 4 without changing the order of the pixels. If this is not called, the pixels of bit_depths 1, 2 and 4 are packed into bytes as small as possible, for example, 8 pixels per byte for 1-bit files. See the libpng manual for details. See also "set_packswap".

To test whether your version of libpng supports set_packing, for a read object, use "libpng_supports" with argument '"READ_PACK"'.

    if (libpng_supports ('READ_PACK')) {
        # do something
    }

For a write object, use argument '"WRITE_PACK"'.

This function corresponds to png_set_packing in libpng

set_packswap

    $png->set_packswap ();

Swaps the bits of 1, 2, or 4 bits/pixel images. The default for PNG image is to put the left pixel into the highest part of the byte, so for example if the bit depth is 1, the pixels from left to right go into a byte as values 128 for the leftmost, 64, 32, 16, 8, 4, 2, then 1 for the rightmost pixel. This call reverses that behavior so that the pixels in a byte go 1 for the leftmost, 2, ..., then 128 for the rightmost. See the libpng manual for details.

To test whether your version of libpng supports set_packswap, for a read object, use "libpng_supports" with argument '"READ_PACKSWAP"'.

    if (libpng_supports ('READ_PACKSWAP')) {
        # do something
    }

For a write object, use argument '"WRITE_PACKSWAP"'.

This function corresponds to png_set_packswap in libpng

set_palette_to_rgb

    $png->set_palette_to_rgb ();

⛐🤪⚠ Untested. See the libpng manual for details.

To test whether your version of libpng supports set_palette_to_rgb, use "libpng_supports" with argument '"READ_EXPAND"':

    if (libpng_supports ('READ_EXPAND')) {
        # do something
    }

This function corresponds to png_set_palette_to_rgb in libpng

set_scale_16

    $png->set_scale_16 ()

⛐🤪⚠ Untested.

To test whether your version of libpng supports set_scale_16, use "libpng_supports" with argument '"READ_SCALE_16_TO_8"':

    if (libpng_supports ('READ_SCALE_16_TO_8')) {
        # do something
    }

This function corresponds to png_set_scale_16 in libpng

set_strip_16

    $png->set_strip_16 ();

Strip the pixels of a PNG stream with 16 bits per channel to 8 bits per channel.

To test whether your version of libpng supports set_strip_16, use "libpng_supports" with argument '"READ_STRIP_16_TO_8"':

    if (libpng_supports ('READ_STRIP_16_TO_8')) {
        # do something
    }

This function corresponds to png_set_strip_16 in libpng

set_strip_alpha

    $png->set_strip_alpha ();

Strip the alpha channel of a PNG stream.

To test whether your version of libpng supports set_strip_alpha, use "libpng_supports" with argument '"READ_STRIP_ALPHA"':

    if (libpng_supports ('READ_STRIP_ALPHA')) {
        # do something
    }

This function corresponds to png_set_strip_alpha in libpng

set_swap

    $png->set_swap ();

⛐🤪⚠ Untested. Swaps around the bytes of 16 bits/pixel images. See the libpng manual for details.

To test whether your version of libpng supports set_swap, use "libpng_supports" with argument '"READ_SWAP"':

    if (libpng_supports ('READ_SWAP')) {
        # do something
    }

This function corresponds to png_set_swap in libpng

set_swap_alpha

    $png->set_swap_alpha ();

⛐🤪⚠ Untested. See the libpng manual for details.

To test whether your version of libpng supports set_swap_alpha, use "libpng_supports" with argument '"READ_SWAP_ALPHA"':

    if (libpng_supports ('READ_SWAP_ALPHA')) {
        # do something
    }

This function corresponds to png_set_swap_alpha in libpng

set_tRNS_to_alpha

    $png->set_tRNS_to_alpha

⛐🤪⚠ Untested. See the libpng manual for details.

To test whether your version of libpng supports set_tRNS_to_alpha, use "libpng_supports" with argument '"READ_EXPAND"':

    if (libpng_supports ('READ_EXPAND')) {
        # do something
    }

This function corresponds to png_set_tRNS_to_alpha in libpng

Other libpng functions

get_chunk_cache_max

    my $max = $png->get_chunk_cache_max ();

Get the maximum number of ancilliary chunks allowed. See also "set_chunk_cache_max".

To test whether your version of libpng supports get_chunk_cache_max, use "libpng_supports" with argument '"CHUNK_CACHE_MAX"':

    if (libpng_supports ('CHUNK_CACHE_MAX')) {
        # do something
    }

This function corresponds to png_png_get_chunk_cache_max in libpng

get_rgb_to_gray_status

    my $badpixels = $png->get_rgb_to_gray_status ();

Returns a true value if there were some non-gray pixels in an RGB image after calling "set_rgb_to_gray".

Saving bandwidth

Try this one weird old get_rgb_to_gray_status trick to check whether an image marked as RGB is really monochrome or not.

    use utf8;
    use FindBin '$Bin';
    use Image::PNG::Libpng ':all';
    use Image::PNG::Const ':all';
    
    my $file = 'life.png';
    print "Size before: ", -s $file, "\n";
    my $png = create_reader ($file);
    $png->read_info ();
    $png->set_rgb_to_gray ();
    if ($png->get_rgb_to_gray_status ()) {
        print "The image contained non-gray pixels.\n";
    }
    else {
        print "The image was grayscale already.\n";
    }
    $png->read_image ();
    $png->read_end ();
    my $wpng = $png->copy_png ();
    my $ihdr = $wpng->get_IHDR ();
    $ihdr->{color_type}  = PNG_COLOR_TYPE_GRAY;
    $wpng->set_IHDR ($ihdr);
    my $after = "life-gray.png";
    $wpng->write_png_file ($after);
    print "Size after: ", -s $after, "\n";
    
    if (! png_compare ($file, $after)) {
        print "The two files contain exactly the same image data.\n";
    }
    else {
        print "The two files contain different image data.\n";
    }

(This example is included as examples/xkcd.pl in the distribution.)

The output looks like this:

    Size before: 97299
    The image was grayscale already.
    Size after: 46956
    The two files contain exactly the same image data.

examples/life-gray.png is included in the distribution.

The resulting image looks like this:

examples/life-gray.png

Correct use of Image::PNG::Libpng could have spared as many as 50,000 bytes from the indignity of being sent around the internet.

This also illustrates the use of "png_compare".

get_user_height_max

    $png->get_user_height_max ();

Get the maximum height allowed for a PNG file. The default is 1 million pixels. These values can be changed by "set_user_limits".

This function corresponds to png_get_user_height_max in libpng

get_user_width_max

    $png->get_user_width_max ();

Get the maximum width allowed for a PNG file. The default is 1 million pixels. These values can be changed by "set_user_limits".

This function corresponds to png_get_user_width_max in libpng

permit_mng_features

    $png->permit_mng_features ($mask);

⛐🤪⚠ Untested. $mask is an integer containing flags. See the libpng manual for details.

(MNG, 'Multiple-image Network Graphics', is an image animation format related to PNG. It has not been widely adopted.)

To test whether your version of libpng supports permit_mng_features, use "libpng_supports" with argument '"MNG_FEATURES"':

    if (libpng_supports ('MNG_FEATURES')) {
        # do something
    }

This function corresponds to png_permit_mng_features in libpng

set_add_alpha

    $png->set_add_alpha ($filler, $filler_loc);

⛐🤪⚠ Untested. Change $png to add an alpha channel. This only works for grayscale or RGB images with bit depth of 8 or 16. $filler contains the alpha value to assign to each pixel, and $filler_loc is either PNG_FILLER_BEFORE or PNG_FILLER_AFTER. The function of set_add_alpha is "set_filler" and a change of the color type to add an alpha channel. See the libpng manual for details.

To test whether your version of libpng supports set_add_alpha, use "libpng_supports" with argument '"READ_FILLER"':

    if (libpng_supports ('READ_FILLER')) {
        # do something
    }

This function corresponds to png_set_add_alpha in libpng

set_alpha_mode

    $png->set_alpha_mode ($mode, $screen_gamma);

⛐🤪⚠ Untested. $mode is an integer, one of the PNG_ALPHA_* constants. $screen_gamma is a floating point number. See the libpng manual for details.

To test whether your version of libpng supports set_alpha_mode, use "libpng_supports" with argument '"READ_ALPHA_MODE"':

    if (libpng_supports ('READ_ALPHA_MODE')) {
        # do something
    }

This function corresponds to png_set_alpha_mode in libpng

set_background

    $png->set_background (\%color, $bkgd_gamma_code, $need_expand, $gamma);

set_background sets the background of an image with an alpha channel or simple transparency (a "tRNS" chunk) with the color specified by %color. If $bkgd_gamma_code is set to PNG_BACKGROUND_GAMMA_SCREEN, it indicates that the supplied background color is in the gamma space of the display, else if it is set to PNG_BACKGROUND_GAMMA_FILE, the color is in the gamma space of the file. If $bkgd_gamma_code is set to PNG_BACKGROUND_GAMMA_UNIQUE, the value of $gamma is used, otherwise $gamma appears to be ignored and can be omitted. (This is not documented in the libpng manual or elsewhere. See https://github.com/glennrp/libpng/issues/358.)

If the background color is supplied at the original bit-depth for a grayscale image that is expanded to truecolor or to a higher bit-depth, $need_expand must be set to a true value, but if the background color is supplied at the expanded bit-depth, $need_expand must be set to a false value. Similarly for paletted images, if %color is supplied as a palette index ($color{index}), $need_expand must be set to a true value, but if %color is an RGB triplet, $need_expand must be set to a false value.

See "Setting the background" for an example.

To test whether your version of libpng supports set_background, use "libpng_supports" with argument '"READ_BACKGROUND"':

    if (libpng_supports ('READ_BACKGROUND')) {
        # do something
    }

set_chunk_cache_max

    $png->set_chunk_cache_max (42);

Set the maximum number of ancilliary chunks allowed. The default is 1000. See also "get_chunk_cache_max".

To test whether your version of libpng supports set_chunk_cache_max, use "libpng_supports" with argument '"CHUNK_CACHE_MAX"':

    if (libpng_supports ('CHUNK_CACHE_MAX')) {
        # do something
    }

This function corresponds to png_png_set_chunk_cache_max in libpng

set_filler

    $png->set_filler ($filler, $flags);

Set transformations in $png such that a filler byte $filler is added when an 8-bit grayscale image or 24-bit RGB image is read, and a filler byte is deleted when an 8-bit grayscale image or 24-bit RGB image is written. $flags may be PNG_FILLER_BEFORE or PNG_FILLER_AFTER. An error is produced if $png has bit depth less than 8.

This does not change the color type of the image. See the related function "set_add_alpha" if you want to add an alpha channel.

To test whether your version of libpng supports set_filler, use "libpng_supports" with argument '"READ_FILLER"':

    if (libpng_supports ('READ_FILLER')) {
        # do something
    }

This function corresponds to png_set_filler in libpng

set_gamma

    $png->set_gamma ($screen_gamma, $output_gamma);

⛐🤪⚠ Untested. $screen_gamma and $output_gamma should contain floating-point arguments. See the libpng manual for details.

To test whether your version of libpng supports set_gamma, use "libpng_supports" with argument '"READ_GAMMA"':

    if (libpng_supports ('READ_GAMMA')) {
        # do something
    }

This function corresponds to png_set_gamma in libpng

set_quantize

    $png->set_quantize (\@palette, $ncolors, \@histogram, $full_quantize);

The @palette part must be set to a palette similar to "set_PLTE". $ncolors must be the length of @palette or shorter. @histogram can be an empty array or if not it needs to be an array of integers of exactly the same length as @palette. The integers represent the frequency of the colors in @palette. These integers can range from 0 to 65355. Larger values or negative values cause an error. The final argument, $full_quantize, should be 1 for RGB images or 0 for paletted images.

Experiments in quantization

This example program experiments with two ways to quantize a PNG image, first of all using a completely random palette, and second using colors picked from the image at random:

    use utf8;
    use FindBin '$Bin';
    use Image::PNG::Libpng ':all';
    my $file = "wave.png";
    my $ncolors = 40;
    my $palette = randompalette ($ncolors);
    write_with_palette ($file, $palette, $ncolors, [], "random");
    my $picked = points ($file, $ncolors);
    my @hist = (1) x $ncolors;
    write_with_palette ($file, $picked, $ncolors, \@hist, "picked");
    exit;
    
    sub write_with_palette
    {
        my ($file, $palette, $ncolors, $hist, $name) = @_;
        my $rpng = create_reader ($file);
        $rpng->set_quantize ($palette, $ncolors, $hist, 1);
        $rpng->read_png ();
        my $wpng = copy_png ($rpng);
        $wpng->set_PLTE ($palette);
        $wpng->write_png_file ("$name-$file");
    }
    
    sub points
    {
        my ($pngfile, $ncolors) = @_;
        my $png = read_png_file ($pngfile);
        my $rows = $png->get_rows ();
        my $h = $png->height ();
        my $w = $png->width ();
        my $ch = $png->get_channels ();
        my @p;
        for (0..$ncolors-1) {
            my $x = int (rand ($w));
            my $y = int (rand ($h));
            my $row = $rows->[$y];
            my @pix = split ('', substr ($row, $x*$ch, $ch));
            push @p, {
                red => ord ($pix[0]),
                green => ord ($pix[1]),
                blue => ord ($pix[2]),
            };
        }
        return \@p;
    }
    
    sub randompalette
    {
        my ($n) = @_;
        my @p;
        for (0..$n-1) {
            my %color;
            for my $c (qw!red green blue!) {
                $color{$c} = int (rand (256))
            }
            push @p, \%color;
        }
        return \@p;
    }

(This example is included as examples/q.pl in the distribution.)

examples/wave.png is included in the distribution.

The input image is this:

examples/wave.png

examples/random-wave.png is included in the distribution.

Completely random colors gives this kind of output:

examples/random-wave.png

examples/picked-wave.png is included in the distribution.

Picked colors gives this kind of output:

examples/picked-wave.png

set_rgb_to_gray

    $png->set_rgb_to_gray ();

    $png->set_rgb_to_gray ($error_action, $red_weight, $green_weight);

Convert a PNG image from RGB (colored) to gray. See the libpng manual for details.

Without arguments, the libpng default values are used for $red_weight and $green_weight, and an error action of "none" is chosen. If the error action is set to a value of PNG_ERROR_ACTION_WARN or PNG_ERROR_ACTION_ERROR, pixels in the RGB image where the R, G and B values are not equal will cause a warning or error respectively. To get the default values for $red_weight or $green_weight, use any negative value. See the libpng manual for details.

If you choose PNG_ERROR_ACTION_NONE you can find out whether there were non-RGB pixels in your image using "get_rgb_to_gray_status".

This function corresponds to png_png_set_rgb_to_gray in libpng with $error_action having a default value of PNG_ERROR_ACTION_NONE, and $red_weight and $green_weight both set to negative values.

Convert a colored image to gray

    use utf8;
    use FindBin '$Bin';
    use Image::PNG::Libpng ':all';
    use Image::PNG::Const ':all';
    
    my $png = create_reader ("$Bin/luv.png");
    $png->read_info ();
    $png->set_rgb_to_gray ();
    $png->read_image ();
    $png->read_end ();
    my $wpng = $png->copy_png ();
    my $ihdr = $wpng->get_IHDR ();
    $ihdr->{color_type}  = PNG_COLOR_TYPE_GRAY_ALPHA;
    $wpng->set_IHDR ($ihdr);
    $wpng->write_png_file ("$Bin/grayface.png");

(This example is included as examples/rgb-to-gray.pl in the distribution.)

examples/grayface.png is included in the distribution.

This is the output:

examples/grayface.png

set_user_limits

    $png->set_user_limits ($width, $height);

This enables a user to override libpng's restrictions to one million pixels in width and one million pixels in height for a PNG image.

This function corresponds to png_set_user_limits in libpng

Other functions

This section contains other functions which don't correspond to anything in libpng itself, but which have been added to the module for utility.

color_type_channels

    my $channels = color_type_channels ('PNG_COLOR_TYPE_RGB_ALPHA');

Returns the number of channels (the number of components of one pixel) of the specified color type.

copy_row_pointers

    $png->copy_row_pointers ($row_pointers);

This allows XS routines to directly set the value of the row pointers for the PNG image. The memory is copied, so whatever is in the row pointers can be freed immediately after calling this. However, the image data it points to is not copied, so this needs to be valid until the PNG is written.

The Perl scalar $row_pointers should be set up something like the following (where rp is the C pointer):

    RETVAL = newSViv (PTR2IV (rp));

It's extracted from the Perl scalar using

    rp = INT2PTR (png_byte **, SvIV (row_pointers));

where row_pointers is the SV * corresponding to $row_pointers in the Perl script. See also "set_row_pointers" which does the same thing but takes ownership of the memory.

get_chunk

    my $timechunk = $png->get_chunk ('tIME');

Get the specified chunk. This produces a fatal error if asked for the IDAT (image data) chunk, use "get_rows" instead. Returns undef if asked for an unknown chunk name.

This is used by pnginspect to get the valid chunks. See also "set_chunk".

get_internals

    my ($png_struct, $png_info) = get_internals ($png);

This function returns the png_structp and png_infop contained in $png. The return value is a list containing the png_structp as the first argument and the png_infop as the second argument, wrapped up as references to objects of type Image::PNG::Libpng::png_struct and Image::PNG::Libpng::png_info.

To access the values of the pointers, use something like this:

    void access_png_internals (png, info)
        SV * png;
        SV * info;
    PREINIT:
        png_struct * cpng;
        png_info * cinfo;
    CODE:
        cpng = INT2PTR (png_struct *, SvIV (png));
        cinfo = INT2PTR (png_info *, SvIV (info));

An example exists in Image::PNG::Cairo.

get_tRNS_palette

    $png->get_tRNS_palette ();

This is not a libpng-equivalent function.

image_data_diff

    my $diff = image_data_diff ('a.png', 'b.png');

This returns the undefined value if the image data in a.png is the same as the image data in b.png. If the image data is different, it returns a readable text message describing the first difference found, for example the height is different, or row 0 of the image data is different, etc.

This function is used in testing this module. See also "png_compare".

libpng_supports

    if (libpng_supports ('iTXt')) {
        print "Your libpng supports international text.\n";
    }

This function returns true or false depending on whether the version of libpng which this was compiled with supports or does not support a particular facility. For the most part, these are taken directly from the C macros of libpng.

The possible arguments to libpng_supports are:

16BIT

ALIGNED_MEMORY

ARM_NEON_API

BENIGN_ERRORS

BENIGN_READ_ERRORS

BENIGN_WRITE_ERRORS

bKGD

Does the libpng support the "bKGD" chunk?

BUILD_GRAYSCALE_PALETTE

BUILTIN_BSWAP16

CHECK_FOR_INVALID_INDEX

cHRM

Does the libpng support the "cHRM" chunk?

cHRM_XYZ

This is local to Image::PNG::Libpng and not a part of libpng itself.

It was necessary to extend libpng because the conditional compilation macro for "set_cHRM_XYZ" and "get_cHRM_XYZ", PNG_cHRM_SUPPORTED is defined (true) for old libpngs which do not actually contain these functions.

CHUNK_CACHE_MAX

This is local to Image::PNG::Libpng and not a part of libpng itself.

It was necessary to extend libpng because the conditional compilation macro for "set_chunk_cache_max" and "get_chunk_cache_max", PNG_USER_LIMITS_SUPPORTED is defined (true) for old libpngs which do not actually contain these functions.

CHUNK_MALLOC_MAX

This is local to Image::PNG::Libpng and not a part of libpng itself.

The reasons for this are identical to those for "CHUNK_CACHE_MAX".

COLORSPACE

CONSOLE_IO

CONVERT_tIME

This is related to two deprecated functions, "png_convert_from_time_t" and "png_convert_from_struct_tm".

CONVERT_tIME

EASY_ACCESS

ERROR_NUMBERS

ERROR_TEXT

eXIf

Does the libpng support the "eXIf" chunk?

FIXED_POINT

FIXED_POINT_MACRO

FLOATING_ARITHMETIC

FLOATING_POINT

FORMAT_AFIRST

FORMAT_BGR

gAMA

Does the libpng support the "gAMA" chunk?

GAMMA

GET_PALETTE_MAX

Does your libpng support "get_palette_max"?

HANDLE_AS_UNKNOWN

hIST

Does the libpng support the "hIST" chunk?

iCCP

Does the libpng support the "iCCP" chunk?

INCH_CONVERSIONS

INFO_IMAGE

IO_STATE

iTXt

Does the libpng support international text?

MIPS_MSA_API

MNG_FEATURES

oFFs

Does the libpng support the "oFFs" chunk?

pCAL

Does the libpng support the "pCAL" extension?

PEDANTIC_WARNINGS

pHYs

Does the libpng support the "pHYs" chunk?

POINTER_INDEXING

POWERPC_VSX_API

PROGRESSIVE_READ

READ

Can libpng read PNGs?

READ_16_TO_8

READ_ALPHA_MODE

See "set_alpha_mode".

READ_BACKGROUND

See "set_background".

READ_BGR

See "set_bgr".

READ_COMPOSITE_NODIV

READ_COMPRESSED_TEXT

READ_EXPAND

READ_EXPAND_16

READ_FILLER

READ_GAMMA

See "set_gamma".

READ_GRAY_TO_RGB

READ_INTERLACING

READ_INT_FUNCTIONS

READ_INVERT

READ_INVERT_ALPHA

READ_OPT_PLTE

READ_PACK

READ_PACKSWAP

READ_QUANTIZE

READ_RGB_TO_GRAY

READ_SCALE_16_TO_8

READ_SHIFT

READ_STRIP_16_TO_8

READ_STRIP_ALPHA

READ_SWAP

READ_SWAP_ALPHA

READ_tEXt

READ_TRANSFORMS

READ_USER_TRANSFORM

READ_zTXt

SAVE_INT_32

SAVE_UNKNOWN_CHUNKS

sBIT

Does the libpng support the "sBIT" chunk?

sCAL

Does the libpng support the "sCAL" extension? This actually tests for the presence of the get_sCAL_s/set_sCAL_s functions, so its behaviour is dependent on other factors for versions 1.2 and 1.4 of libpng.

SEQUENTIAL_READ

SETJMP

SET_OPTION

SET_UNKNOWN_CHUNKS

SET_USER_LIMITS

SIMPLIFIED_READ

SIMPLIFIED_READ_AFIRST

SIMPLIFIED_WRITE

SIMPLIFIED_WRITE_AFIRST

SIMPLIFIED_WRITE_BGR

SIMPLIFIED_WRITE_STDIO

sPLT

Does the libpng support "sPLT" chunks?

sRGB

Does the libpng support the "sRGB" chunk?

STDIO

STORE_UNKNOWN_CHUNKS

TEXT

Does the libpng support text?

tEXt

Does the libpng support tEXt chunks?

tIME

Does the libpng support the "tIME" chunk?

TIME_RFC1123

tRNS

Does the libpng support the "tRNS" chunk?

UNKNOWN_CHUNKS

Does the libpng support unknown chunks (see "Private chunks")?

USER_CHUNKS

USER_LIMITS

Does the libpng support "set_user_limits" and the related functions "get_user_width_max", and "get_user_height_max"?

USER_LIMITS

USER_MEM

USER_TRANSFORM_INFO

USER_TRANSFORM_PTR

WARNINGS

WRITE

Can libpng write pngs?

WRITE_BGR

WRITE_COMPRESSED_TEXT

WRITE_CUSTOMIZE_COMPRESSION

Does the libpng support "set_compression_level" and similar functions?

⛐🤪⚠ It's not very clear that this returns a useful value, since "set_compression_level" seems to be in libpngs from at least as far back as 1.5.1, and yet this macro was only added to libpng in version 1.6.13.

WRITE_CUSTOMIZE_ZTXT_COMPRESSION

Does the libpng support "set_text_compression_level" and similar functions?

WRITE_FILLER

WRITE_FILTER

WRITE_FLUSH

WRITE_FLUSH_AFTER_IEND

WRITE_INTERLACING

WRITE_INT_FUNCTIONS

WRITE_INVERT

WRITE_INVERT_ALPHA

WRITE_OPTIMIZE_CMF

WRITE_PACK

WRITE_PACKSWAP

WRITE_SHIFT

WRITE_SWAP

WRITE_SWAP_ALPHA

WRITE_TRANSFORMS

WRITE_USER_TRANSFORM

WRITE_WEIGHTED_FILTER

zTXt

Does the libpng support zTXt chunks?

png_compare

    if (png_compare ('a.png', 'b.png') == 0) {
        print "The PNGs are the same.\n";
    }

This compares the image data in two PNGs and returns 0 if they contain exactly the same image data, or 1 if they contain different image data. For a more detailed comparison, see "image_data_diff". This does not compare to see if the PNG files "look like" each other, but whether each pixel contains exactly the same values. Please see Image::Similar for a looser comparison of images.

This uses the "expand" transform of libpng to read both the images, so it is able to compare images of different color types. It compares the alpha values as well as the color pixels. See "Saving bandwidth" for an example of comparing an RGB and a grayscale image.

read_struct

    if ($png->read_struct ()) {
         warn "Can't write this, use copy_png to copy it";
    }

This returns a true value if $png was created with "create_read_struct" or allied functions like "read_from_scalar", and a false value if $png was created with "create_write_struct" or allied functions like "copy_png".

set_chunk

    $png->set_chunk ('tIME', $timechunk);

Set the specified chunk. This produces a fatal error if given an IDAT (image data) chunk, use "set_rows" instead. This produces a fatal error if given an unknown chunk name.

The first argument is the chunk name and then the second argument is a scalar containing whatever the chunk requires, for example a hash reference for the tIME chunk as described under "set_tIME" and "get_tIME".

This is essentially a convenience function for the benefit of "copy_png" which, together with "get_valid", enables the PNG chunks to be copied in a loop rather than one-by-one.

set_image_data

    $png->set_image_data ($image_data);

Set the internal image data pointer to $image_data. $image_data should contain a pointer to memory stored as an SvIV allocated with Newx or a similar function. This transfers ownership of the memory to $png, which will free it with Safefree when $png is destroyed. Calling this function with any value does not actually change the content of the PNG image itself.

set_row_pointers

    $png->set_row_pointers ($row_pointers);

This sets the rows of the PNG image to $row_pointers using png_set_rows. $row_pointers must contain a pointer to memory stored as an SvIV allocated with a Perl memory allocator like Newx or a similar function. This also transfers ownership of the memory to $png, which will free it with Safefree when $png is destroyed. See also "copy_row_pointers", which does the same thing except for the freeing of the memory.

split_alpha

    my $split = $png->split_alpha ();
    my $alpha = $split->{alpha};
    my $color = $split->{data};

Split the alpha channel away from the other data. This only works for images with color types PNG_COLOR_TYPE_RGB_ALPHA and PNG_COLOR_TYPE_GRAY_ALPHA. This is not part of the libpng API. This function was added to this module to assist the author of PDF::Builder due to problems with very slow access to PNG images using Perl.

To remove the alpha channel from an image, use "set_background". See "Setting the background" for an example. You can also use the transform PNG_TRANSFORM_STRIP_ALPHA in "read_png_file", or "set_strip_alpha", but this may leave spurious pixel values in transparent parts of the image.

EXPORTS

Nothing is exported by default, but all the functions in this module, including the object methods, can be exported on request. The export tag 'all' exports everything in the module:

    use Image::PNG::Libpng ':all';

This includes all the methods, which can then be used with the $png argument as the first argument.

Differences from libpng

The functions in Image::PNG::Libpng are closely based on those of libpng, with the following differences.

No info structure

This module does not use the "info" structure of libpng. Almost all libpng functions require two initial arguments, a png_structp and a png_infop. However, in Image::PNG::Libpng, both the "png" and the "info" are contained in the object. People who need access to the internals of an Image::PNG::Libpng object (C programmers or XS programmers) can use "get_internals" to access them.

This module does not support the "end info" structure of PNGs when writing, although these are handled when reading.

Unused arguments omitted

This module eliminates unevaluated arguments of libpng. For example, libpng requires the user to pass a pointer to a png_struct to call the libpng version number function, (see "get_libpng_ver"), but it actually ignores this structure. There are many similar instances of unevaluated arguments, which have all been eliminated from this module.

If you are interested in exactly which libpng arguments are omitted, you can find each instance in the file perl-libpng.c in the top directory of the distribution in the macro UNUSED_ZERO_ARG.

Useless functions omitted

The functions from libpng which don't do anything have been omitted from this module.

Function return values are used to return values

libpng is very inconsistent in its calling conventions. Some functions return results using references, and some return results using the function's return value. For example png_get_rows (see "get_rows") uses the return value of the function to return an array of pointers, but png_get_PLTE (see "get_PLTE") uses a pointer reference to return an array of pointers, and the return value to indicate errors.

Image::PNG::Libpng uses only the return value. Errors and non-existence are indicated by a return value of the undefined value.

Further to this, libpng's error handling is also very inconsistent. Some functions use the return value to indicate errors, and some of the functions don't indicate errors at all, but just fail silently. Even more inconsistently, some of the functions which use the return value to indicate an error use a non-zero value, and some use a zero value, to indicate an error.

No destructors

Freeing the memory allocated by "create_read_struct" and "create_write_struct" is automatically handled by Perl.

Older versions of this module (pre-0.18) had functions called destroy_read_struct and destroy_write_struct corresponding to the functions with similar names in libpng. From version 0.18, these functions still exist, but they no longer do anything. The memory freeing is now handled by Perl automatically.

Other unimplemented parts of libpng

Memory management functions

The management of memory for libpng objects is handled automatically by this module, and so it does not offer an interface to png_malloc and png_free or other libpng memory handling functions.

Error handling functions

This module does not offer an interface to png_error and png_get_error_ptr or any of the other error handling functions of libpng. It redirects the error and warning handlers to Perl's error stream.

Input and output manipulation functions

This module does not offer a direct interface to png_set_write_fn and png_set_read_fn. However, it is possible to use their functionality to access Perl data via "read_from_scalar" and "write_to_scalar".

Fixed point functions

There is currently no support for the PNG fixed point functions in this Perl module, the functions with suffix _fixed.

List of unsupported functions

The following functions from the libpng API are unsupported by this module.

png_benign_error

png_build_grayscale_palette

⛐🤪⚠ Undocumented function, but it is part of the public API. See https://github.com/glennrp/libpng/issues/353.

This function builds an evenly-spaced grayscale palette at a specified bit depth into a user-supplied array. It is not used elsewhere in libpng.

png_chunk_benign_error

png_chunk_warning

png_convert_from_struct_tm

👎 Deprecated in libpng. This function related to the tIME chunk is deprecated in libpng 1.7.

png_convert_from_time_t

👎 Deprecated in libpng. This function related to the tIME chunk is deprecated in libpng 1.7.

png_convert_to_rfc1123

👎 Deprecated in libpng. This function related to the tIME chunk is deprecated in libpng 1.7.

png_convert_to_rfc1123_buffer

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

This function is related to the tIME chunk; it seems fairly superfluous with the many other ways to manipulate time strings already in Perl.

png_data_freer

png_free

png_free_data

png_get_cHRM_XYZ_fixed

🍓 See "Fixed point functions".

png_get_cHRM_fixed

🍓 See "Fixed point functions".

png_get_compression_type

🙃🤡 See "Useless functions omitted". Useless function which returns 0 since there is only one type of compression.

png_get_copyright

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

This function gives you the copyright string for libpng.

png_get_current_pass_number

png_get_current_row_number

png_get_error_ptr

png_get_filter_type

🙃🤡 See "Useless functions omitted". This function returns the value of the unused field filter_type in the PNG header, which is always 0. See "Unused arguments omitted".

png_get_gAMA_fixed

🍓 See "Fixed point functions".

png_get_header_ver

This function was omitted from this module because it merely duplicates another function.

Identical to "get_libpng_ver".

png_get_header_version

This function was omitted from this module because it merely duplicates another function.

Identical to "get_libpng_ver".

png_get_io_chunk_type

png_get_io_ptr

png_get_io_state

png_get_mem_ptr

png_get_pHYs_dpi

png_get_pixel_aspect_ratio

png_get_pixel_aspect_ratio_fixed

🍓 See "Fixed point functions".

png_get_pixels_per_inch

png_get_pixels_per_meter

png_get_progressive_ptr

Incremental reading of PNGs is not handled yet.

png_get_sCAL_fixed

🍓 See "Fixed point functions".

png_get_signature

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

Returns the PNG signature of a PNG you read in.

png_get_uint_31

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

This produces an error if the unsigned integer argument is too big for a 31 bit number.

png_get_user_chunk_ptr

png_get_user_height_max

png_get_user_transform_ptr

png_get_x_offset_inches

png_get_x_offset_inches_fixed

🍓 See "Fixed point functions".

png_get_x_offset_microns

png_get_x_offset_pixels

Duplicates "get_oFFs".

png_get_x_pixels_per_inch

png_get_x_pixels_per_meter

Duplicates "get_oFFs".

png_get_y_offset_inches

png_get_y_offset_inches_fixed

🍓 See "Fixed point functions".

png_get_y_offset_microns

png_get_y_offset_pixels

Duplicates "get_oFFs".

png_get_y_pixels_per_inch

png_get_y_pixels_per_meter

Duplicates "get_oFFs".

png_handle_as_unknown

png_image_begin_read_from_file

png_image_begin_read_from_stdio

png_image_finish_read

png_image_free

png_image_write_to_file

png_image_write_to_memory

png_image_write_to_stdio

png_process_data

png_process_data_pause

png_process_data_skip

png_progressive_combine_row

png_read_row

png_read_rows

png_reset_zstream

👎 Deprecated in libpng. Resets the zstream of the zlib instance used for the image data.

png_save_int_32

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

Writes a 32 bit signed number into an octet buffer. Perl programmers will probably use pack for this.

png_save_uint_16

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

Writes a 16 bit number into an octet buffer. Perl programmers will probably use pack for this.

png_save_uint_32

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

Writes a 32 bit unsigned number into an octet buffer. Perl programmers will probably use pack for this.

png_set_alpha_mode_fixed

🍓 See "Fixed point functions".

png_set_background_fixed

🍓 See "Fixed point functions".

png_set_benign_errors

png_set_cHRM_XYZ_fixed

🍓 See "Fixed point functions".

png_set_cHRM_fixed

🍓 See "Fixed point functions".

png_set_check_for_invalid_index

png_set_compression_method

🙃🤡 See "Useless functions omitted". This function in libpng corresponds to the unused method parameter of zlib functions like deflateInit2. See "zlib documentation". The libpng function just produces a warning if the user sets the value to anything but 8, the value of the macro Z_DEFLATED, and then lets zlib produce an error.

png_set_crc_action

png_set_error_fn

png_set_filter_heuristics

👎 Deprecated in libpng.

png_set_filter_heuristics_fixed

🍓 See "Fixed point functions".

png_set_flush

png_set_gAMA_fixed

🍓 See "Fixed point functions".

png_set_gamma_fixed

🍓 See "Fixed point functions".

png_set_interlace_handling

Incremental writing is not handled.

png_set_invalid

png_set_longjmp_fn

⛐🤪⚠ Undocumented function, but it is part of the public API.

png_set_mem_fn

png_set_option

png_set_progressive_read_fn

png_set_read_status_fn

png_set_read_user_chunk_fn

png_set_read_user_transform_fn

png_set_sCAL_fixed

🍓 See "Fixed point functions".

png_set_sRGB_gAMA_and_cHRM

png_set_shift

png_set_sig_bytes

👎🐪 This function was deliberately omitted from this module because it doesn't seem useful for Perl programmers.

png_set_strip_error_numbers

🙃🤡 See "Useless functions omitted". According to the libpng manual, "we never got around to actually numbering the error messages", so I assume this is not very useful.

png_set_text_compression_method

🙃🤡 See "Useless functions omitted". Unsupported for the same reasons as "png_set_compression_method".

png_set_unknown_chunk_location

This is related to some kind of bug in version 1.5 and previous of libpng.

png_set_user_transform_info

png_set_write_status_fn