#if _MSC_VER >= 1400

#define _CRT_SECURE_NO_DEPRECATE 1

#endif

#include "zlib.h"

#include "psdutils.h"

void readrow(FILE *psd,

			 TPSDChannelInfo *chan,

			 psdPixel row,			   // row index

			 unsigned char *inbuffer,  // dest buffer for the uncompressed row

			 unsigned char *tmpbuffer) // temp rlebuffer for compressed data, 2xrb in size

{

	psdPixel n = 0, rlebytes;

	psdByte pos;

	int seekres = 0;

	switch (chan->comptype) {

	case RAWDATA: /* uncompressed */

		pos = chan->filepos + chan->rowbytes * row;

		seekres = fseek(psd, pos, SEEK_SET);

		if (seekres != -1)

			n = fread(inbuffer, 1, chan->rowbytes, psd);

		break;

	case RLECOMP:

		pos = chan->rowpos[row];

		seekres = fseek(psd, pos, SEEK_SET);

		if (seekres != -1) {

			rlebytes = fread(tmpbuffer, 1, chan->rowpos[row + 1] - pos, psd);

			n = unpackrow(inbuffer, tmpbuffer, chan->rowbytes, rlebytes);

		}

		break;

	case ZIPWITHPREDICTION:

	case ZIPWITHOUTPREDICTION:

		memcpy(inbuffer, chan->unzipdata + chan->rowbytes * row, chan->rowbytes);

		return;

	}

	// if we don't recognise the compression type, skip the row

	// FIXME: or would it be better to use the last valid type seen?

	//	if(seekres == -1)

	//	alwayswarn("# can't seek to " LL_L("%lld\n","%ld\n"), pos);

	if (n < chan->rowbytes) {

		//warn("row data short (wanted %d, got %d bytes)", chan->rowbytes, n);

		// zero out unwritten part of row

		memset(inbuffer + n, 0, chan->rowbytes - n);

	}

}

int unpackrow(unsigned char *out, unsigned char *in,

			  psdPixel outlen, psdPixel inlen)

{

	psdPixel i, len;

	int val;

	for (i = 0; inlen > 1 && i < outlen;) {

		len = *in++;

		--inlen;

		if (len == 128) /* ignore RLE flag value */

			;

		else {

			if (len > 128) {

				len = 1 + 256 - len;

				val = *in++;

				--inlen;

				if ((i + len) <= outlen)

					memset(out, val, len);

				else {

					memset(out, val, outlen - i); // fill to complete row

					len = 0;

				}

			} else {

				++len;

				if ((i + len) <= outlen) {

					if (len > inlen)

						break;

					memcpy(out, in, len);

					in += len;

					inlen -= len;

				} else {

					memcpy(out, in, outlen - i); // copy to complete row

					len = 0;

				}

			}

			out += len;

			i += len;

		}

	}

	if (i < outlen) {

		//WARNING: not enough RLE data for row;

	}

	return i;

}

void skipBlock(FILE *f)

{

	psdByte n = read4Bytes(f);

	if (n) {

		fseek(f, n, SEEK_CUR);

	} else {

	}

}

// Read 2byte unsigned binary value.

// BigEndian.

unsigned read2UBytes(FILE *f)

{

	unsigned n = fgetc(f) << 8;

	return n |= fgetc(f);

}

// Read 2byte binary value

// BigEndian.

int read2Bytes(FILE *f)

{

	unsigned n = fgetc(f) << 8;

	n |= fgetc(f);

	return n < 0x8000 ? n : n - 0x10000;

}

// Read 4byte signed binary value.

// BigEndian.

long read4Bytes(FILE *f)

{

	long n = fgetc(f) << 24;

	n |= fgetc(f) << 16;

	n |= fgetc(f) << 8;

	return n | fgetc(f);

}

void *mymalloc(long n)

{

	void *p = malloc(n);

	if (p)

		return p;

	else {

		//ALLOCATION ERROR

	}

	return NULL;

}

// ZIP COMPRESSION

// ZIP WITHOUT PREDICTION

// If no error returns 1 else returns 0

int psdUnzipWithoutPrediction(unsigned char *src_buf, int src_len,

							  unsigned char *dst_buf, int dst_len)

{

	z_stream stream;

	int state;

	memset(&stream, 0, sizeof(z_stream));

	stream.data_type = Z_BINARY;

	stream.next_in = (Bytef *)src_buf;

	stream.avail_in = src_len;

	stream.next_out = (Bytef *)dst_buf;

	stream.avail_out = dst_len;

	if (inflateInit(&stream) != Z_OK)

		return 0;

	do {

		state = inflate(&stream, Z_PARTIAL_FLUSH);

		if (state == Z_STREAM_END)

			break;

		if (state == Z_DATA_ERROR || state != Z_OK)

			break;

	} while (stream.avail_out > 0);

	if (state != Z_STREAM_END && state != Z_OK)

		return 0;

	return 1;

}

// ZIP WITH PREDICTION

int psdUnzipWithPrediction(unsigned char *src_buf, int src_len,

						   unsigned char *dst_buf, int dst_len,

						   int row_size, int color_depth)

{

	int status;

	int len;

	unsigned char *buf;

	status = psdUnzipWithoutPrediction(src_buf, src_len, dst_buf, dst_len);

	if (!status)

		return status;

	buf = dst_buf;

	do {

		len = row_size;

		if (color_depth == 16) {

			while (--len) {

				buf[2] += buf[0] + ((buf[1] + buf[3]) >> 8);

				buf[3] += buf[1];

				buf += 2;

			}

			buf += 2;

			dst_len -= row_size * 2;

		} else {

			while (--len) {

				*(buf + 1) += *buf;

				buf++;

			}

			buf++;

			dst_len -= row_size;

		}

	} while (dst_len > 0);

	return 1;

}