NAME

Image::PNG::Libpng - Perl interface to the C library "libpng".

WARNING

This version of the module is solely for evaluation and testing. This module is currently incomplete and untested, and contains errors, bugs, and inconsistencies, including unresolved memory corruption errors which can crash Perl. The documentation below refers to functions which may or may not exist in the completed module and contains links to things which do not exist and may never exist.

SYNOPSIS

use Image::PNG::Libpng;
my $png = Image::PNG::Libpng::create_read_struct ();
open my $file, '<:raw', 'nice.png';
Image::PNG::Libpng::init_io ($png, $file);
Image::PNG::Libpng::read_png ($png);
close $file;
Image::PNG::Libpng::destroy_read_struct ($png);

Image::PNG::Libpng enables Perl to use the "libpng" library for reading and writing files in the PNG (Portable Network Graphics) format.

Image::PNG::Libpng consists of Perl subroutines which mirror the C functions in libpng, plus helper subroutines to make it easier to read and write PNG data in Perl.

For an easy way to access PNG files, try the companion module Image::PNG, which offers a simplified interface to the functions in this module.

For those who are familiar with libpng, to know what the differences between this module and libpng are, please go to the section "Differences from libpng".

FUNCTIONS

create_read_struct

my $png = create_read_struct ();

Create a structure for reading a PNG.

Correspondence to libpng

This function corresponds to png_create_read_struct plus create_info_struct (see "No info structure") with the error and warning handler variables set up to use Perl's error reporting.

create_write_struct

my $png = create_write_struct ();

Create a structure for writing a PNG.

Correspondence to libpng

This function corresponds to png_create_write_struct plus create_info_struct (see "No info structure") with the error and warning handler variables set up to use Perl's error reporting.

destroy_read_struct

destroy_read_struct ($png);

This frees the memory associated with $png.

Correspondence to libpng

This function corresponds to png_destroy_read_struct, without the info and end_info arguments. See "No info structure".

destroy_write_struct

destroy_write_struct ($png);

This frees the memory associated with $png.

Correspondence to libpng

This function corresponds to png_destroy_write_struct.

Input and output

init_io

open my $file, "<", 'nice.png';
init_io ($png, $file);

Set the file which $png reads or writes to $file. $file must be an already-opened Perl file handle. If $png was created with create_write_struct, $file must be opened for writing. If $png was created with create_read_struct, $file must be open for reading.

Since PNG files are binary files, it's safest to specify the "raw" pragma or use "binmode" with the file in order to override any default text file encoding which Perl might be using:

open my $file, ">:raw", 'output.png';

open my $file, ">", 'output.png';
binmode $file;

Correspondence to libpng

This function corresponds to png_init_io, with a Perl file handle substituting for the C FILE *.

read_from_scalar

my $png = create_read_struct ();
read_from_scalar ($png, $string);

This subroutine sets the image data of $png to be the contents of a Perl scalar variable $string. The first argument, $png, is a PNG structure created with "create_read_struct". It reads in all the data from the structure on being called.

This is useful when image data is stored in a Perl scalar. For example

use LWP::Simple;
my $image_data = get 'http://www.example.com/example.png';
# Now $image_data contains the PNG file
my $png = create_read_struct ();
read_from_scalar ($png, $image_data);
# Now $png contains the PNG information from the image.

Correspondence to libpng

This uses png_set_read_fn to set the reading function of $png to a routine which reads data from Perl scalars. It then uses png_read_png to read all the data.

The C function which does this is called perl_png_scalar_read, in the file perl-libpng.c in the top directory of the distribution.

write_to_scalar

my $image_data = write_to_scalar ($png);

This writes the PNG image data in $png into a Perl scalar. So, for example,

my $img = write_to_scalar ($png);
open my $output, ">:raw", "test-write-scalar.png";
print $output $img;
close $output;

creates a PNG file called test-write-scalar.png from the PNG data in $png.

The first argument, $png, is a writeable PNG structure created with "create_write_struct". The return value of the subroutine is the Perl scalar containing the image data.

Correspondence to libpng

This subroutine doesn't correspond directly to anything in libpng. It uses png_set_write_fn to set the writing function of $png to be its own function, which writes data to the Perl scalar.

The C function which does this is called perl_png_scalar_write, in the file perl-libpng.c in the top directory of the distribution.

read_png

read_png ($png);

Read the entire PNG file. You can provide a second argument containing transformations to apply to the image:

use Image::PNG::Const qw/PNG_TRANSFORM_STRIP_ALPHA/;
read_png ($png, PNG_TRANSFORM_STRIP_ALPHA);

In the absence of any third argument, the default value of PNG_TRANSFORM_IDENTITY is applied. The possible transformations which can be applied are

PNG_TRANSFORM_IDENTITY: No transformation
PNG_TRANSFORM_STRIP_16: Strip 16-bit samples to 8 bits
PNG_TRANSFORM_STRIP_ALPHA: Discard the alpha channel
PNG_TRANSFORM_PACKING: Expand 1, 2 and 4-bit samples to bytes
PNG_TRANSFORM_PACKSWAP: Change order of packed pixels to LSB first
PNG_TRANSFORM_EXPAND: Expand paletted images to RGB, grayscale to 8-bit images and tRNS chunks to alpha channels
PNG_TRANSFORM_INVERT_MONO: Invert monochrome images
PNG_TRANSFORM_SHIFT: Normalize pixels to the sBIT depth
PNG_TRANSFORM_BGR: Flip RGB to BGR, RGBA to BGRA
PNG_TRANSFORM_SWAP_ALPHA: Flip RGBA to ARGB or GA to AG
PNG_TRANSFORM_INVERT_ALPHA: Change alpha from opacity to transparency
PNG_TRANSFORM_SWAP_ENDIAN: Byte-swap 16-bit samples

Correspondence to libpng

This function corresponds to png_read_png with a default value for the third argument. The fourth, unused, argument to png_read_png does not need to be supplied. See "Unused arguments omitted".

It does not take a second "info" argument. No info structure

write_png

write_png ($png);

This writes the PNG to the file stream. Before using this, open a file for writing and set it up with "init_io". For example,

open my $output, ">:raw", 'out.png';
init_io ($png, $output);
write_png ($png);
close $output;

There is an optional second argument consisting of transformations to apply to the PNG image before writing it:

use Image::PNG::Const qw/PNG_TRANSFORM_STRIP_ALPHA/;
write_png ($png, PNG_TRANSFORM_STRIP_ALPHA);

The transformations which can be applied are as follows:

PNG_TRANSFORM_IDENTITY: No transformation
PNG_TRANSFORM_STRIP_16: Strip 16-bit samples to 8 bits
PNG_TRANSFORM_STRIP_ALPHA: Discard the alpha channel
PNG_TRANSFORM_PACKING: Expand 1, 2 and 4-bit samples to bytes
PNG_TRANSFORM_PACKSWAP: Change order of packed pixels to LSB first
PNG_TRANSFORM_EXPAND: Expand paletted images to RGB, grayscale to 8-bit images and tRNS chunks to alpha channels
PNG_TRANSFORM_INVERT_MONO: Invert monochrome images
PNG_TRANSFORM_SHIFT: Normalize pixels to the sBIT depth
PNG_TRANSFORM_BGR: Flip RGB to BGR, RGBA to BGRA
PNG_TRANSFORM_SWAP_ALPHA: Flip RGBA to ARGB or GA to AG
PNG_TRANSFORM_INVERT_ALPHA: Change alpha from opacity to transparency
PNG_TRANSFORM_SWAP_ENDIAN: Byte-swap 16-bit samples

(NOTE: this list might be wrong, it is just copied from the linux lib pages & the linux lib pages have different transformations for the read and write png functions.)

Correspondence to libpng

This function corresponds to png_write_png.

The image header

See http://www.w3.org/TR/PNG/#11IHDR for information on the PNG standards for the image header.

sig_cmp

if (sig_cmp ($should_be_png)) {
    print "Your data does not have a PNG signature.\n";
}

This subroutine looks at $should_be_png and checks whether its first bytes correspond to a valid PNG signature. It returns a true value if they do not. It can also take two further arguments consisting of a byte offset and a number of bytes to check respectively:

sig_cmp ($should_be_png, 0, 8);

If these arguments are not supplied, the byte offset is assumed to be zero, and the number of bytes to check is assumed to be eight.

Correspondence to libpng

This function corresponds to png_sig_cmp, with default arguments of 0 and 8 if second and third arguments are not supplied.

get_valid

my $valid = get_valid ($png);
if ($valid->{oFFs}) {
    print "The PNG has valid screen offsets.\n";
}

This function returns a hash with a key for each possible chunk which may or may not be valid. The chunks which you can test for are

bKGD
cHRM
gAMA
hIST
iCCP
IDAT
IHDR
iTXt
oFFs
pCAL
pHYs
PLTE
sBIT
sCAL
sPLT
sRGB
tEXt
tIME
tRNS
zTXt

The first argument, $png, is a PNG structure created with "create_read_struct".

Correspondence to libpng

This function corresponds to png_get_valid, with the difference being that the return value is a hash containing a key for each possible chunk.

get_IHDR

my $IHDR = get_IHDR ($png);

Read the IHDR information from the PNG file. The return value is a reference to a hash.

The hash reference contains the following fields:

width: The width of the image in pixels.
height: The height of the image in pixels.
bit_depth: The bit depth of the image (the number of bits used for each colour in a pixel). This can take the values 1, 2, 4, 8, 16.
color_type: The colour type. This can take the values PNG_COLOR_TYPE_GRAY, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, PNG_COLOR_TYPE_RGB_ALPHA.
interlace_method: The method of interlacing. This can take the values PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7.

So, for example, to get the width and height of an image,

my $ihdr = get_IHDR ($png);
printf "Your image is %d x %d\n", $ihdr->{width}, $ihdr->{height};

Correspondence to libpng

This function corresponds to png_get_IHDR, with a single Perl hash reference used instead of the several pointers to integers used in libpng.

set_IHDR

my $ihdr = { width => 10, height => 10, bit_depth => 8,
             color_type => PNG_COLOR_TYPE_RGB };
set_IHDR ($png, $ihdr);

Set the IHDR chunk (the image header) of the PNG image.

The first argument, $png, is a writeable PNG structure created with "create_write_struct". The second argument is a hash with the following values:

width: The width of the image in pixels.
height: The height of the image in pixels.
bit_depth: The bit depth of the image (the number of bits used for each colour in a pixel). This can have the values 1, 2, 4, 8, 16.
color_type: The colour type. This can have the values PNG_COLOR_TYPE_GRAY, PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, PNG_COLOR_TYPE_RGB_ALPHA.
interlace_method: The method of interlacing. This can have the values PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7.

Other fields in the hash are ignored.

Correspondence to libpng

This function corresponds to png_set_IHDR, with a single Perl hash reference used instead of the seven integers. The variables compression_method, filter_method, in png_set_IHDR can only take one possible value, so the routine ignores them. See "Unused arguments omitted".

get_color_type

my $color_type;
Image::PNG::Libpng::get_color_type ($png, \$color_type);

This returns an integer value. If you want to get a name for the colour type, use "color_type_name".

Correspondence to libpng

This function corresponds to png_get_color_type.

PNG timestamps

See http://www.w3.org/TR/PNG/#11timestampinfo for information on the PNG standards for time stamp information.

get_tIME

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

This subroutine gets the modification time value of the PNG image and puts it into fields labelled "year", "month", "day", "hour", "minute" and "second" of the hash reference given as the third argument. If there is no modification time it returns an undefined value.

Correspondence to libpng

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

set_tIME

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

Set the modification time of the PNG to the hash value given by the second argument. If the second argument is omitted, the time is set to the current time. If any of year, month, day, hour, minute or second is omitted, these are set to zero.

Correspondence to libpng

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

Text chunks

See http://www.w3.org/TR/PNG/#11textinfo for information on the PNG standards for text information.

get_text

my $text_chunks = Image::PNG::Libpng::get_text ($png);

This subroutine gets all the text chunks in the PNG image and returns them as an array reference. Each element of the array represents one text chunk. The element representing one chunk is a hash reference with the text fields such as "key", "lang_key", "compression" taken from the PNG's information.

The text data is uncompressed by libpng. If it is international text, Image::PNG::Libpng automatically puts it into Perl's internal Unicode encoding (UTF-8).

Note that PNG international text is required to be in the UTF-8 encoding, and non-international text is required to contain whitespace and printable ASCII characters only. See "The PNG specification" for more on the requirements of a PNG text section.

Correspondence to libpng

This function corresponds to png_get_text, with a Perl array of hash references substituted for the C array of structs used in libpng.

set_text

set_text ($png, $text_chunks);

This sets the text chunks in an array reference $text_chunks. . If you call it more than once, the chunks are appended to the existing ones rather than replacing them.

set_text ($png, [{compression => PNG_TEXT_COMPRESSION_NONE,
                  keyword => "Copyright",
                  text => "Copyright (C) 1997 The Dukes of Hazzard",
          }]);

Correspondence to libpng

This function corresponds to png_set_text.

Private chunks

set_keep_unknown_chunks

use Image::PNG::Const 'PNG_HANDLE_CHUNK_ALWAYS';
set_keep_unknown_chunks ($png, PNG_HANDLE_CHUNK_ALWAYS);

Tell libpng not to discard unknown chunks when reading the file.

get_unknown_chunks

my $private_chunks = get_unknown_chunks ($png);
# Get some data from a private chunk
my $chunk_three_data = $private_chunks->[3]->{data};
# Get the size of the data
print length $chunk_three_data;

This gets all of the private chunks from the image. You need to call "set_keep_unknown_chunks" with an appropriate value before reading the file, otherwise libpng discards unknown chunks when reading the file.

The return value is an array reference containing hash references. If there are no private chunks, this returns an undefined value. There is one element of the array for each chunk member.

Each member hash reference has the following keys:

name: The name of the unknown chunk, in the PNG chunk format (four bytes).
location: The location of the unknown chunk.
data: The data of the unknown chunk

The "size" field of the PNG structure is not stored, because the "data" member of the hash contains information on its length.

Correspondence to libpng

This function corresponds to png_get_unknown_chunks

set_unknown_chunks

set_unknown_chunks ($png, $private_chunks);

Correspondence to libpng

This function corresponds to png_set_unknown_chunks

Helper functions

These helper functions assist the programmer in the transition from libpng, which uses C conventions such as upper case macros standing for numerical constants and C structures, to Perl's string-based conventions.

color_type_name

my $name = Image::PNG::Libpng::color_type_name ($color_type);

Given a numerical colour type in $color_type, return the equivalent name. The name is in upper case, with words separated by underscores, as in RGB_ALPHA.

Correspondence to libpng

This function does not correspond to anything in libpng. The names of the colour types are taken from those defined in the libpng header file, png.h.

text_compression_name

my $name = Image::PNG::Libpng::text_compression_name ($text->{compression});

Given a numerical text compression type, return the equivalent name. The name is in upper case. The possible return values are

TEXT_NONE
TEXT_zTXt
ITXT_NONE
ITXT_zTXt
an empty string: if the compression method is unknown.

For some reason the compression field is also used to store the information about whether the text is "international text" in UTF-8 or not.

Correspondence to libpng

This function does not correspond to anything in libpng. The names of the text compression types are based on those in png.h, but without the word "COMPRESSION", so for example the libpng constant PNG_ITXT_COMPRESSION_zTXt corresponds to a return value of ITXT_zTXt.

Library version functions

get_libpng_ver

my $libpng_version = Image::PNG::Libpng::get_libpng_ver ();

This function returns the version of the libpng library which the module is using.

Correspondence to libpng

This function corresponds to png_get_libpng_ver. However, it doesn't require the png_structp argument of the C function. See "About libpng".

access_version_number

my $libpng_version_number = Image::PNG::Libpng::access_version_number ();

This function returns the version of the libpng library which the module is using as an integer number.

Correspondence to libpng

This function corresponds to png_access_version_number.

Palettes

See http://www.w3.org/TR/PNG/#11PLTE for information on the PNG standards for the palette chunk.

get_PLTE

my $colours = Image::PNG::Libpng::get_PLTE ($png);
# Get the green value of the twentieth entry in the palette.
my $green = $colours->[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 colour 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 = Image::PNG::Libpng::get_color_type ($png);
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".

Correspondence to libpng

This function corresponds to png_get_PLTE.

set_PLTE

set_PLTE ($png, $palette);

Set the palette of $png. The first argument, $png, is a writeable PNG structure created with "create_write_struct". The second 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,

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

creates a palette with two entries in $png.

Correspondence to libpng

This function corresponds to png_set_PLTE.

Image data

get_rows

my $rows = Image::PNG::Libpng::get_rows ($png);
my $pixel = substr ($rows->[10], 20, 1);

This returns the rows of the PNG image, after uncompressing and unfiltering, as binary data. The return value, $rows in the example, is an array reference with a number of rows equal to the height of the PNG image. Each row consists of the actual binary data, which you will need to cut out using a routine like substr or unpack to access pixel values. This binary data is likely to contain bytes equal to zero.

You can get the number of bytes in each row using "get_rowbytes".

Each row is a Perl string. Perl terminates each row of data with an extra zero byte at the end.

Correspondence to libpng

This function corresponds to png_get_rows.

set_rows

set_rows ($png, \@rows);

Set the rows of data to be written in to the PNG to @rows. @rows needs to contain at least the same number of rows of data as the height of the PNG image, and the length of each entry needs to be at least the width of the entry times the number of bytes required for each pixel.

Please also note that this is a bit unreliable. See "set_rows is unreliable". I recommend that you only use this immediately before calling "write_png" in order to prevent problems occuring.

Correspondence to libpng

This function corresponds to png_set_rows.

get_rowbytes

my $bytes_in_a_row = get_rowbytes ($png);

Correspondence to libpng

This function corresponds to png_get_rowbytes.

Compression and filtering

set_filter

use Image::PNG::Const 'PNG_FILTER_NONE';
set_filter ($png, PNG_FILTER_NONE);

This sets the filters which are allowed to be used for writing a PNG image. The possible values are

PNG_NO_FILTERS
PNG_FILTER_NONE
PNG_FILTER_SUB
PNG_FILTER_UP
PNG_FILTER_AVG
PNG_FILTER_PAETH
PNG_ALL_FILTERS

These can be combined using | (logical or):

use Image::PNG::Const ':all';
set_filter ($png, PNG_FILTER_UP | PNG_FILTER_AVG);

Please see http://www.w3.org/TR/PNG/#9Filter-types for the meanings of these filter types.

Correspondence to libpng

This function corresponds to png_set_filter with the second (unused) argument omitted. See "Unused arguments omitted".

EXPORTS

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

use Image::PNG::Libpng ':all';
# Now everything in the module has been imported

Differences from libpng

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

No info structure

This module, Image::PNG::Libpng 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 first argument to each function.

Unused arguments omitted

This module eliminates all the unevaluated arguments of libpng. For example, libpng requires the user to pass a pointer to a png_struct before calling the library to ask for its version number (see "get_libpng_ver"), but the library ignores the this structure anyway, so this module does not duplicate this. 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.

Function return values are used to return values

In libpng, 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. You can also choose to raise errors or print errors using the "raise_error" and "print_error" options.

In libpng, some functions use the return value to indicate errors, and some of the functions don't indicate errors but fail silently. Some of the functions which use the return value to indicate an error use a non-zero value to indicate an error, and some of them use a zero value to indicate an error.

Other unimplemented parts of libpng

Memory management functions

This module does not offer an interface to png_malloc and png_free.

Error handling functions

This module does not offer an interface to png_error and png_get_error_ptr. It redirects the error and warning handlers to Perl's error stream.

Input/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".

Partial read/write functions

This module does not yet offer an interface to the partial read and write functions of libpng. The reason is because I don't know enough about Perl's internal structures to be able to create a memory-safe interface to these functions. The partial read/write functions would rely on preserving pointers to data structures within the Perl program's data area between calls. So this module doesn't deal with png_write_chunk, png_write_end, png_write_info, png_write_row, or png_write_rows.

DIAGNOSTICS

The module may produce the following error or warning messages.

libpng error: %s\n: (F) An error from libpng sent via Perl's warning handler.
libpng warning: %s\n: (W) A warning from libpng sent via Perl's warning handler.
%s:%d: Call to calloc for %d '%s' failed: out of memory: (F) A request for more memory was refused. The first two parameters are the file name and line number of where this happened.
Memory leak detected: there are %d allocated pieces of memory which have not been freed.\n: (W) The module's internal check for memory errors was tripped somehow. This probably indicates a bug in the module.
Attempt to destroy an object of unknown type: (F) There was an attempt to free some corrupted memory.
According to its compression type, a text chunk in the current PNG file claims to be ITXT but Perl's 'is_utf8_string' says that its encoding is invalid.: (W)
A language key 'lang_key' member of a 'png_text' structure in the file failed Perl's 'is_utf8_string' test, which says that its encoding is invalid.: (W)
None of your text chunks was allowed: (W) The user tried to set some text chunks in the image but they were not allowed.
Trying to read from a PNG in memory but there is no PNG in memory: (F) Something went wrong trying to read a PNG from a Perl scalar. This probably indicates a bug in the program.
Request for too many bytes %d on a scalar of length %d at read position %d.\n: (F) There was an attempt to read some data from a Perl scalar which went beyond the expected end of the scalar in memory.
set_IHDR: Bad values for width (%d), height (%d), or bit depth (%d): (F) The user tried to set a PNG header with unacceptable values, as indicated.
set_PLTE: Empty array of colours in set_PLTE: (F) The user tried to set an empty palette of colours.
Too many transparencies %d supplied: (F) The user tried to set more than the maximum possible number of transparencies for a paletted image.
Image has no height: (F) The height of the image is zero.
Image has no rows: (F) The image does not have any rows of image data.
Image rows have zero length: (F) The rows of image data have zero length.
Image has zero height: (F) The image we are trying to read has zero height.
Out of memory allocating %d bytes for image: (F) We were refused the memory we want to read the image into.
Row pointers already allocated: (F) There was an attempt to set the rows of an image after they had already been set.
Chunk name '%s' has wrong number of characters: %d required: (F) We tried to set an unknown chunk with a name which doesn't have four characters.
Number of unknown chunks is zero: (F) The user tried to set an empty list of unknown chunks.
Illegal PNG chunk name length, chunk names must be %d characters long: (W) The user's name for a private chunk was not a valid length. In this case the chunk is ignored.
Unknown chunk location is zero, which means 'don't write the chunk': (W) The user supplied a value for "location" of zero, which means "don't write the chunk".
undefined chunk name at offset %d in chunk list: (F)
chunk %i has bad length %d: should be %d in chunk list: (F)
set_keep_unknown_chunks is not supported in your libpng: (F) libpng was compiled without this option.

BUGS

This section documents some known deficiencies in the module.

set_rows is unreliable

The method "set_rows" doesn't actually copy or write any information. All it does is set a pointer to the pointers to the rows in the PNG data structure. The actual data is only written when you ask to write it. So if you "set_rows" to some data, then delete or change that data before asking to write the png with "write_png", you will get a memory error.

Conditional compilation

It is possible to compile a version of the libpng library without support for various things. For example, it's possible to have a libpng without support for text chunks by undefining a macro PNG_TEXT_SUPPORTED. The module supports some of the conditional compilation choices which I've found in practice, but it does not support every possible choice. If you encounter problems using this Perl module because of a conditionally-compiled libpng, then please let me know and I'll consider adding that facility to the module.

EXAMPLES

There is a collection of example scripts online at http://www.lemoda.net/image-png/. This currently contains

PNG inspector http://www.lemoda.net/png/inspect/: This downloads a PNG file you specify from the internet and prints out its contents.
PNG quantizer http://www.lemoda.net/png/quantize/: This downloads a PNG file you specify from the internet and quantizes it with as many colours as you want (from two to 256) in order to reduce its size. The quantized image is uploaded to imgur.com using WWW::Imgur.

AUTHOR

Ben Bullock, <bkb@cpan.org>

COPYRIGHT & LICENCE

You can use, copy, modify and redistribute Image::PNG and associated files under the Perl Artistic Licence or the GNU General Public Licence.

SUPPORT

Mailing list

There is a mailing list at http://groups.google.com/group/perlimagepng. You don't need to be a member of the list to post messages to the list or participate in discussions. Your messages may be held for moderation though.

If you have anything at all to say about the module, whether it is bug reports, feature requests, or anything else, I'd prefer to discuss it on the mailing list because that way there is a public record which everyone can access, rather than being restricted to email. That means that, for example, if someone else takes over maintaining this module, they can easily access records of previous discussions.

CPAN stuff

There is a bug tracker at .

FOR PROGRAMMERS

(This section is only for people who want to fix a bug or add an improvement to this module, and who want to share the change with other people by adding it to the public version of this module.)

If you want to alter this module, note very carefully that the distributed files are not actually the source code of the module. The source code lives in the "tmpl" directory of the distribution and the distribution is created via scripts.

The original files of this distribution make very heavy use of the Template Perl module in order to cut down the amount of repetitive stuff which needs to be put into various source and documentation files. If you plan to alter the C file, you may also need a program called "cfunctions" which you can download from sourceforge, which generates the header file perl-libpng.h from perl-libpng.c.

To install Image::PNG, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Image::PNG

CPAN shell

perl -MCPAN -e shell
install Image::PNG

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)