JPG and PNG decoder

[Stewart Gordon]

On 17/06/2012 08:55, cal wrote:

<snip>
> If you don't care too much about compression level, you simply zlib
> compress the data, write it out by image row/scanline, include
> appropriate header and chunk info, and you're done.
<snip>

Not quite.  You need to encode it by scanline, add the filter byte at the beginning of 
each line, _then_ zlib compress it.  The filter byte can just be 0 throughout if you don't 
want to worry about filtering.

If you just want a basic truecolour or greyscale PNG encoder, then it's a matter of:
- write the PNG signature
- write the IHDR, being careful about byte order
- write the IDAT - zlib compressed image data
- write the IEND

You also need to compute the CRC of each chunk, but std.zlib has a function to do that as 
well.

FWIW a while ago I wrote a simple experimental program that generates an image and encodes 
it as a PNG.  And I've just tweaked it and updated it to D2 (attached).  It supports only 
truecolour with 8 bits per sample, but it supports filtering, though it isn't adaptive 
(you just specify the filter to use when you run the program).

Stewart.
-------------- next part --------------
import
	std.file,
	std.math,
	std.path,
	std.stdio,
	std.zlib;

const ubyte[] header = [ 137, 80, 78, 71, 13, 10, 26, 10 ];
const uint WIDTH = 100, HEIGHT = 100;

align(1) struct IHDR {
	uint width = WIDTH;
	uint height = HEIGHT;
	ubyte bitDepth = 8;
	ubyte colourType = 2;
	ubyte compressMethod, filterMethod, interlaceMethod;

	version (LittleEndian) {
		IHDR bigEndian() {
			IHDR result = this;
			result.width = .bigEndian(width);
			result.height = .bigEndian(height);
			return result;
		}
	} else {
		ref IHDR bigEndian() { return this; }
	}
}


align(1) struct RGB {
	ubyte red, green, blue;
}


void main(string[] a) {
	ubyte filterType;
	string outputFile = "makepng.png";

	if (a.length > 1 && a[1].length == 1 && a[1][0] >= '0' && a[1][0] <= '4') {
		filterType = cast(ubyte) (a[1][0] - '0');
		a = a[1..$];
	}
	if (a.length > 1) {
		outputFile = defaultExtension(a[1], "png");
	}

	void[] pngData = header.dup;

	pngData ~= makeChunk("IHDR", IHDR.init.bigEndian);

	RGB[HEIGHT][WIDTH] imageData;

	foreach (y, ref scanline; imageData) {
		foreach (x, ref pixel; scanline) {
			if ((x-50) * (x-50) + (y-50) * (y-50) < 2000) {
				pixel.red = 255;
				pixel.green = cast(ubyte) (2 * x);
				pixel.blue = cast(ubyte) (255 * y / 100);
			}
		}
	}

	ubyte[] imageData2;

	if (filterType == 0) {
		foreach (y, ref scanLine; imageData) {
			imageData2 ~= 0;
			imageData2 ~= cast(ubyte[]) scanLine;
		}
	} else {
		Predictor predictor = predictors[filterType];

		ubyte[] prevLine, thisLine;
		prevLine.length = 3 * (WIDTH + 1);
		thisLine.length = 3 * (WIDTH + 1);

		foreach (y, ref scanLine; imageData) {
			thisLine[3..$] = cast(ubyte[]) scanLine;

			imageData2 ~= filterType;
			for (uint x = 0; x < 3 * WIDTH; x++) {
				imageData2 ~= cast(ubyte) (thisLine[x + 3]
				  - predictor(thisLine[x], prevLine[x+3], prevLine[x]));
			}

			ubyte[] tempLine = prevLine;
			prevLine = thisLine;
			thisLine = tempLine;
		}
	}

	assert (imageData2.length == (3 * WIDTH + 1) * HEIGHT);

	pngData ~= makeChunkV("IDAT", compress(imageData2));
	
	writeln(pngData.length);

	pngData ~= makeChunkV("IEND", null);

	std.file.write(outputFile, pngData);
}


version (LittleEndian) {
	uint bigEndian(uint value) {
		return (value << 24) | ((value & 0x0000FF00) << 8)
		  | ((value & 0x00FF0000) >> 8) | (value >> 24);
	}
} else {
	uint bigEndian(uint value) { return value; }
}

void[] bigEndianBytes(uint value) {
	uint[] be = [bigEndian(value)];
	return be;
}

void[] makeChunkV(in string type, in void[] data)
in {
	assert(type.length == 4);
} body {
	void[] typeAndData = type ~ data;
	uint crc = crc32(0, typeAndData);

	return bigEndianBytes(data.length) ~ typeAndData ~ bigEndianBytes(crc);
}


void[] makeChunk(T)(in string type, in T data) {
	static assert (!is(T : void[]));
	return makeChunkV(type, cast(void[]) (&data)[0..1]);
}


// FILTER PREDICTOR FUNCTIONS
alias ubyte function(ubyte, ubyte, ubyte) Predictor;
Predictor[5] predictors = [
	&noFilter, &subFilter, &upFilter, &averageFilter, &paethFilter
];

ubyte noFilter(ubyte left, ubyte up, ubyte leftUp) {
	return 0;
}

ubyte subFilter(ubyte left, ubyte up, ubyte leftUp) {
	return left;
}

ubyte upFilter(ubyte left, ubyte up, ubyte leftUp) {
	return up;
}

ubyte averageFilter(ubyte left, ubyte up, ubyte leftUp) {
	return (left + up) >> 1;
}

ubyte paethFilter(ubyte left, ubyte up, ubyte leftUp) {
	int
		p = left + up - leftUp,
		pa = abs(p - left),
		pb = abs(p - up),
		pc = abs(p - leftUp);

	if (pa <= pb && pa <= pc) return left;
	if (pb <= pc) return up;
	return leftUp;
}