PNG file read and write. Leverages color.d's MemoryImage interfaces for interop.

The main high-level functions you want are readPng, readPngFromBytes, writePng, and maybe writeImageToPngFile or writePngLazy for some circumstances.

The other functions are low-level implementations and helpers for dissecting the png file format.

Public Imports

public import arsd.color;
Undocumented in source.



enum PngType

Represents the different types of png files, with numbers matching what the spec gives for filevalues.


PNG* blankPNG(PngHeader h)

Creates a new PNG object from the given header parameters, ready to receive data.

int bytesPerPixel(PngHeader header)
Color[] fetchPalette(PNG* p)

Extracts the palette chunk from a PNG object as an array of RGBA quads.

ubyte[] getANDMask(PNG* p)

Takes the transparency info and returns an AND mask suitable for use in a Windows ico

PngHeader getHeader(PNG* p)

Gets the parsed PngHeader data out of the PNG object.

PngHeader getHeaderFromFile(string filename)

Opens a file and pulls the PngHeader out, leaving the rest of the data alone.

MemoryImage imageFromPng(PNG* png)

The return value should be casted to indexed or truecolor depending on what the file is. You can also use getAsTrueColorImage to forcibly convert it if needed.

auto pngFromBytes(Range r)

Given an input range of bytes, return a lazy PNG file

PNG* pngFromImage(IndexedImage i)

Creates the PNG data structure out of an IndexedImage. This structure will have the minimum number of colors needed to represent the image faithfully in the file and will be ready for writing to a file.

PNG* pngFromImage(TrueColorImage i)

Creates the PNG data structure out of a TrueColorImage. This implementation currently always make the file a true color with alpha png type.

MemoryImage readPng(string filename)

Easily reads a png file into a MemoryImage

PNG* readPng(ubyte[] data)

Given an in-memory array of bytes from a PNG file, returns the parsed out PNG object.

LazyPngChunks!(Range) readPngChunks(Range r)

Lazily breaks the buffered input range into png chunks, as defined in the PNG spec

auto readPngChunks(Range r)

Same as above, but takes a regular input range instead of a buffered one. Provided for easier compatibility with standard input ranges (for example, std.stdio.File.byChunk)

MemoryImage readPngFromBytes(const(ubyte)[] bytes)

Easily reads a png from a data array into a MemoryImage.

void replacePalette(PNG* p, Color[] colors)

Replaces the palette data in a PNG object.

immutable(ubyte)[] unfilter(ubyte filterType, ubyte[] data, ubyte[] previousLine, int bpp)

Png files apply a filter to each line in the datastream, hoping to aid in compression. This undoes that as you load.

void writeImageToPngFile(char[] filename, TrueColorImage image)

this is just like writePng(filename, pngFromImage(image)), but it manages its own memory and writes straight to the file instead of using intermediate buffers that might not get gc'd right

void writePng(string filename, MemoryImage mi)

Saves a MemoryImage to a png file. See also: writeImageToPngFile which uses memory a little more efficiently

void writePng(string filename, ubyte[] data, int width, int height, PngType type, ubyte depth)

Saves an image from an existing array of pixel data. Note that depth other than 8 may not be implemented yet. Also note depth of 16 must be stored big endian

ubyte[] writePng(PNG* p)

Turns a PNG structure into an array of bytes, ready to be written to a file.

void writePngLazy(OutputRange where, InputRange image)

turns a range of png scanlines into a png file in the output range. really weird

Static variables

immutable(ubyte[]) PNG_MAGIC_NUMBER;

All PNG files are supposed to open with these bytes according to the spec


struct BufferedInputRange(Range)

Allows appending to front on a regular input range, if that range is an array. It appends to the array rather than creating an array of arrays; it's meant to make the illusion of one continuous front rather than simply adding capability to walk backward to an existing input range.

struct Chunk

A PNG file consists of the magic number then a stream of chunks. This struct represents those chunks.

struct LazyPngChunks(T)

See: readPngChunks

struct LazyPngFile(LazyPngChunksProvider)

Lazily reads out basic info from a png (header, palette, image data) It will only allocate memory to read a palette, and only copies on the header and the palette. It ignores everything else.

struct PNG

Represents the PNG file's data. This struct is intended to be passed around by pointer.

struct PngHeader

The first chunk in a PNG file is a header that contains this info


template isBufferedInputRange(R)

* Buffered input range - generic, non-image code Is the given range a buffered input range? That is, an input range that also provides consumeFromFront(int) and appendToFront()

See Also

  • arsd.image has generic load interfaces that can handle multiple file formats, including png.
  • arsd.apng handles the animated png extensions.



Originally written in 2009. This is why some of it is still written in a C-like style!