pp6q2gr5v/node_modules/pngjs-image/lib/png/decoder.js

// Copyright 2015 Yahoo! Inc.
// Copyrights licensed under the Mit License. See the accompanying LICENSE file for terms.

var Chunk = require('./chunk');

var CRC = require('./processor/crc');

var BufferedStream = require('./utils/bufferedStream');
var utils = require('./utils/utils');
var constants = require('./utils/constants');

var path = require('path');


/**
 * @class Decoder
 * @module PNG
 * @submodule PNGCore
 * @extends chunkUtils
 * @constructor
 */
var Decoder = function () {
	this._chunks = {};
	this._chunkData = {};

	utils.loadModule(path.join(__dirname, 'utils', 'chunkUtils.js'), this);
};


/**
 * Gets the data supplied by each chunk
 *
 * @method getChunkData
 * @return {object}
 */
Decoder.prototype.getChunkData = function () {
	return this._chunkData;
};


/**
 * Decodes the supplied data
 *
 * @method decode
 * @param {Buffer} buffer Image data
 * @param {object} [options] Decoding options
 * @param {boolean} [options.strict=false] Strict decoding
 */
Decoder.prototype.decode = function (buffer, options) {

	options = options || {};

	var i, len,
		chunk, image = null,
		signature = constants.signature,
		streamSignature,
		strict = !!options.strict,
		stream = new BufferedStream(buffer, false);

	this._chunks = {};
	this._chunkData = {};

	// Check signature
	streamSignature = stream.readBuffer(signature.length);
	for (i = 0, len = signature.length; i < len; i++) {
		if (streamSignature[i] !== signature[i]) {
			// Always throw error (even with strict=false) - need to be sure it is a PNG
			throw new Error('Invalid signature for a PNG image.');
		}
	}

	// Load all chunks until end is reached
	// Phase 1 - Forward
	do {
		chunk = this._parseChunk(stream, strict, options);
	} while (chunk.getType() !== 'IEND');

	// Run through all chunks before scaling
	// Phase 2 - Forward
	this.applyWithSortedChunks(function (chunk) {

		try {
			image = chunk.decode(image, strict, options);

		} catch (err) {

			// Ignore non-critical errors - not required for image reading
			// If strict is requested, then re-throw
			if (strict || chunk.isCritical()) {
				throw err;
			}
		}
	}, true);

	// Run through all chunks after scaling
	// Phase 3 - Forward
	this.applyWithSortedChunks(function (chunk) {

		try {
			image = chunk.postDecode(image, strict, options);

		} catch (err) {

			// Ignore non-critical errors - not required for image reading
			// If strict is requested, then re-throw
			if (strict || chunk.isCritical()) {
				throw err;
			}
		}
	}, true);

	// Run through all chunks after image is complete
	// Phase 4 - Forward
	this.applyWithSortedChunks(function (chunk) {

		try {
			image = chunk.finalizeDecode(image, strict, options);

		} catch (err) {

			// Ignore non-critical errors - not required for image reading
			// If strict is requested, then re-throw
			if (strict || chunk.isCritical()) {
				throw err;
			}
		}
	}, true);

	// Run through all chunks-types (not chunks) to gather chunk-data
	// Phase 5 - Forward
	this.applyWithSortedChunks(function (chunk) {
		Chunk.decodeTypeData(chunk.getType(), this._chunkData, this._chunks, strict, options);
	}.bind(this), false);

	return image;
};

/**
 * Reads the next chunk in the stream
 *
 * @method _parseChunk
 * @param {BufferedStream} stream Data stream
 * @param {boolean} strict Should decoding be strict?
 * @param {object} options Decoding options
 * @return {Chunk} Chunk read
 * @private
 */
Decoder.prototype._parseChunk = function (stream, strict, options) {

	var chunkLength,
		chunkType,
		chunkCrc,
		calculatedCrc,
		crc,
		chunk,
		chunkOffset;

	// Read chunk-length
	chunkLength = stream.readUInt32BE();
	if (chunkLength + 8 > stream.length) {
		throw new Error('Chunk length is greater than the input data.');
	}
	chunkOffset = stream.readOffset + chunkLength + 8; // 8 for type and CRC value

	// Load chunk for crc calculation
	crc = new CRC();
	crc.write(stream.toBuffer(true), stream.readOffset, chunkLength + 4); // Including chunk-type

	// Create chunk that is suggested by the data
	chunkType = stream.readString(4, 'ascii');
	chunk = new Chunk(chunkType, this._chunks);

	try {

		// Parsing of chunk data
		chunk.parse(stream, chunkLength, strict, options);

		// Load crc and compare with calculated one
		chunkCrc = stream.readInt32BE();
		calculatedCrc = crc.getValue();
		if (strict && (chunkCrc !== calculatedCrc)) {
			//throw new Error('CRC error.');
			//TODO: Something is not working; overflow?
		}

		// Add to parsed chunks
		this.addChunk(chunk);

	} catch (err) {

		// Ignore non-critical errors - not required for image reading
		// If strict is requested, then re-throw
		if (strict || chunk.isCritical()) {
			throw err;
		}
	} finally {
		// Make sure the chunk did not read over bounds - resetting of reader offset
		stream.readOffset = chunkOffset;
	}

	return chunk;
};

module.exports = Decoder;