#if _MSC_VER >= 1400

#define _CRT_SECURE_NO_DEPRECATE 1

#pragma warning(disable : 4996)

#endif

#include <string.h></string.h>

#include <stdio.h></stdio.h>

#include <sys types.h=""></sys>

#include <sys stat.h=""></sys>

#include "../compatibility/tnz4.h"

#include "../compatibility/inforegion.h"

#include "filequantel.h"

#include "filequantelP.h"

#ifdef _WIN32

#define STAT_BUF struct _stat

#else

#define STAT_BUF struct stat

#endif

static IMAGE *img_read_region_quantel_no_interlaced(

	T_CHAR *fname, int x1, int y1, int x2, int y2, int scale, int type);

static IMAGE *img_read_region_quantel_interlaced(

	T_CHAR *fname, int x1, int y1, int x2, int y2, int scale, int type);

/*static char *Quantel_error[] = { "qnt locked format 720x576", 

                                 "qtl locked format 720x486", 

				 "yuv locked format 720x486 / 720x576", 

				 "sdl locked format 720x486 / 720x576" };

*/

#define QUANTEL_BUILD_ROW                        \

                                                 \

	for (x = 0; x < region.scanNcol / 2; x++) {  \

		u = *lineBuf++ - 128;                    \

		j = *lineBuf++ - 16;                     \

		if (j < 0)                               \

			j = 0;                               \

		v = *lineBuf++ - 128;                    \

		k = *lineBuf++ - 16;                     \

		r = 76310 * j + 104635 * v;              \

		if (r > 0xFFFFFF)                        \

			r = 0xFFFFFF;                        \

		if (r <= 0xFFFF)                         \

			r = 0;                               \

		g = 76310 * j + -25690 * u + -53294 * v; \

		if (g > 0xFFFFFF)                        \

			g = 0xFFFFFF;                        \

		if (g <= 0xFFFF)                         \

			g = 0;                               \

		b = 76310 * j + 132278 * u;              \

		if (b > 0xFFFFFF)                        \

			b = 0xFFFFFF;                        \

		if (b <= 0xFFFF)                         \

			b = 0;                               \

		bufRGB->r = (unsigned char)(r >> 16);    \

		bufRGB->g = (unsigned char)(g >> 16);    \

		bufRGB->b = (unsigned char)(b >> 16);    \

		bufRGB->m = 255;                         \

		bufRGB++;                                \

		r = 76310 * k + 104635 * v;              \

		if (r > 0xFFFFFF)                        \

			r = 0xFFFFFF;                        \

		if (r <= 0xFFFF)                         \

			r = 0;                               \

		g = 76310 * k + -25690 * u + -53294 * v; \

		if (g > 0xFFFFFF)                        \

			g = 0xFFFFFF;                        \

		if (g <= 0xFFFF)                         \

			g = 0;                               \

		b = 76310 * k + 132278 * u;              \

		if (b > 0xFFFFFF)                        \

			b = 0xFFFFFF;                        \

		if (b <= 0xFFFF)                         \

			b = 0;                               \

		bufRGB->r = (unsigned char)(r >> 16);    \

		bufRGB->g = (unsigned char)(g >> 16);    \

		bufRGB->b = (unsigned char)(b >> 16);    \

		bufRGB->m = 255;                         \

		bufRGB++;                                \

		lineBuf += ((region.step - 1) * 4);      \

	}

#define QUANTEL_GET_YSIZE(ysize) \

	(abs((ysize - QNT_PAL_YSIZE)) > abs((ysize - QTL_NTSC_YSIZE))) ? QTL_NTSC_YSIZE : QNT_PAL_YSIZE;

/*---------------------------------------------------------------------------*/

static void vpb_string(char *str, int field_type, char **p_h, char *stop)

{

	char *h;

	int len;

	h = *p_h;

	len = strlen(str);

	NOT_MORE_THAN(255, len)

	if (h + 3 + len >= stop)

		return;

	*h++ = field_type;

	*h++ = 0;

	*h++ = len;

	strncpy(h, str, (size_t)len);

	h += len;

	*p_h = h;

}

/*---------------------------------------------------------------------------*/

static void vpb_int(int val, char **p_h)

{

	char *h;

	h = *p_h;

	*h++ = (char)(val >> 24);

	*h++ = (char)(val >> 16);

	*h++ = (char)(val >> 8);

	*h++ = (char)(val);

	*p_h = h;

}

/*---------------------------------------------------------------------------*/

static void vpb_short(int val, char **p_h)

{

	char *h;

	h = *p_h;

	*h++ = (char)(val >> 8);

	*h++ = (char)(val);

	*p_h = h;

}

/*---------------------------------------------------------------------------*/

static TBOOL write_vpb_header(FILE *file, int xsize, int ysize)

{

	char header[1024], *h, *stop;

	int bytes, sqlx, sqly;

	h = header;

	stop = header + 1024;

	vpb_string("Picture", 0x03, &h, stop);

	vpb_string("Toonz", 0x97, &h, stop);

	if (ysize == 486) {

		sqlx = 2133; /* 711 * 3   NTSC */

		sqly = 1940; /* 485 * 4        */

	} else {

		sqlx = 2103; /* 701 * 3   PAL  */

		sqly = 2300; /* 575 * 4        */

	}

	bytes = xsize * ysize * 2;

	if (h + 3 + 20 < stop) {

		*h++ = 0x10;

		*h++ = 1;

		*h++ = 20;

		vpb_short(0x10, &h);  /* format code */

		vpb_short(0x00, &h);  /* format code modifier */

		vpb_short(xsize, &h); /* width of picture in pixels */

		vpb_short(ysize, &h); /* height of picture in pixels */

		vpb_short(sqlx, &h);  /* width of arbitrary square in pixels */

		vpb_short(sqly, &h);  /* height of arbitrary square in pixels */

		vpb_int(0, &h);		  /* offset from end of 1st K for start of image */

		vpb_int(bytes, &h);   /* length in bytes of image within file */

	}

	*h++ = 0x04;

	*h++ = 1;

	*h++ = 4;

	vpb_int(bytes, &h);

	while (h < stop)

		*h++ = (char)0xFF;

	return fwrite(header, 1, 1024, file) == 1024;

}

/*---------------------------------------------------------------------------*/

static int quantel_get_info(const T_CHAR *fname, int type, int *xsize, int *ysize)

{

	STAT_BUF f_stat;

	if (_wstat(fname, &f_stat) == -1)

		return FALSE;

	switch (type) {

	case QNT_FORMAT:

		*xsize = QNT_PAL_XSIZE;

		*ysize = QNT_PAL_YSIZE;

		CASE QTL_FORMAT :

			*xsize = QTL_NTSC_XSIZE;

		*ysize = QTL_NTSC_YSIZE;

		CASE YUV_FORMAT :

			*xsize = QUANTEL_XSIZE;

		switch (f_stat.st_size) {

		case QNT_PAL_FILE_SIZE:

			__OR QNT_PAL_W_FILE_SIZE :

				*ysize = QNT_PAL_YSIZE;

			CASE QTL_NTSC_FILE_SIZE : __OR QTL_NTSC_W_FILE_SIZE :

										  *ysize = QTL_NTSC_YSIZE;

		DEFAULT:

			*ysize = f_stat.st_size / (QUANTEL_XSIZE * sizeof(short));

		}

		CASE SDL_FORMAT :

			*xsize = QNT_PAL_XSIZE;

		switch (f_stat.st_size) {

		case QNT_PAL_FILE_SIZE:

			*ysize = QNT_PAL_YSIZE;

			CASE QTL_NTSC_FILE_SIZE :

				*ysize = QTL_NTSC_YSIZE;

		DEFAULT:

			/*printf("error: bad file dimension\n");*/

			return FALSE;

		}

	DEFAULT:

		/*printf("error: bad file format\n");*/

		return FALSE;

	}

	return TRUE;

}

/*---------------------------------------------------------------------------*/

static int vpb_get_info(FILE *file, int *xsize, int *ysize, int *imgoffs)

{

	UCHAR buf[1024];

	unsigned int len;

	*xsize = *ysize = *imgoffs = 0;

	while (fread(buf, 1, 3, file) == 3) {

		if (buf[1] > 1)

			return FALSE;

		if (buf[0] == 0x10) {

			len = 20;

			if (fread(buf, 1, len, file) != len)

				return FALSE;

			*xsize = buf[4] << 8 | buf[5];

			*ysize = buf[6] << 8 | buf[7];

			*imgoffs = buf[12] << 24 | buf[13] << 16 | buf[14] << 8 | buf[15];

			*imgoffs += 1024;

			return TRUE;

		}

		len = buf[2];

		if (fread(buf, 1, len, file) != len)

			return FALSE;

	}

	return FALSE;

}

/*---------------------------------------------------------------------------*/

static int quantel_write_buffer(FILE *outf, UCHAR *buf, int ysize)

{

	int n;

	n = fwrite(buf, 1, ysize * BYTESPERROW, outf);

	if (n <= 0) {

		/*printf("quantel_write_frame error: write failed\n");*/

		return FALSE;

	}

	return TRUE;

}

/*---------------------------------------------------------------------------*/

static void quantel_rgb_to_yuv(USHORT *rp, USHORT *gp, USHORT *bp, UCHAR *ap)

{

	int i, r, g, b;

	TINT32 y1, y2, u, v, u1, u2, v1, v2;

	y1 = y2 = 0;

	ap -= BYTESPERROW - 1;

	for (i = QUANTEL_XSIZE / 2; i > 0; i--) {

		/* first pixel gives Y and 0.5 of chroma */

		r = *rp++;

		g = *gp++;

		b = *bp++;

		y1 = 16829 * r + 33039 * g + 6416 * b;

		u1 = -4831 * r + -9488 * g + 14319 * b;

		v1 = 14322 * r + -11992 * g + -2330 * b;

		/* second pixel gives Y and 0.5 of chroma */

		r = *rp++;

		g = *gp++;

		b = *bp++;

		y2 = 16829 * r + 33039 * g + 6416 * b;

		u2 = -4831 * r + -9488 * g + 14319 * b;

		v2 = 14322 * r + -11992 * g + -2330 * b;

		/* average the chroma */

		u = u1 + u2;

		v = v1 + v2;

		/* round the chroma */

		u1 = (u + 0x008000) >> 16;

		v1 = (v + 0x008000) >> 16;

		/* limit the chroma */

		if (u1 < -112)

			u1 = -112;

		if (u1 > 111)

			u1 = 111;

		if (v1 < -112)

			v1 = -112;

		if (v1 > 111)

			v1 = 111;

		/* limit the lum */

		if (y1 > 0x00dbffff)

			y1 = 0x00dbffff;

		if (y2 > 0x00dbffff)

			y2 = 0x00dbffff;

		/* save the results */

		*ap++ = (u1 + 128);

		*ap++ = (y1 >> 16) + 16;

		*ap++ = (v1 + 128);

		*ap++ = (y2 >> 16) + 16;

	}

}

/*---------------------------------------------------------------------------*/

void img_read_quantel_info(const T_CHAR *fname, int *w, int *h, int type)

{

	int xsize, ysize, imgoffs;

	FILE *file;

	*w = 0;

	*h = 0;

	if (type == VPB_FORMAT) {

		file = _wfopen(fname, L"rb");

		if (!file) {

			/*printf("img_read_quantel_info error: unable to open file %s\n", fname);*/

			return;

		}

		if (!vpb_get_info(file, &xsize, &ysize, &imgoffs)) {

			fclose(file);

			return;

		}

		fclose(file);

	} else {

		if (!quantel_get_info(fname, type, &xsize, &ysize))

			return;

	}

	*w = xsize;

	*h = ysize;

}

/*---------------------------------------------------------------------------*/

void *img_read_quantel(const T_CHAR *fname, int *w, int *h, int type)

{

	FILE *fileyuv;

	IMAGE *image;

	LPIXEL *bufout1, *bufout2, *buf;

	int xsize, ysize, imgoffs, quantel_xsize;

	int y, exit = 0;

	fileyuv = _wfopen(fname, L"rb");

	if (fileyuv == NULL) {

		/*printf("img_read_quantel error: unable to open file %s\n", fname);*/

		return NIL;

	}

	if (type == VPB_FORMAT) {

		if (!vpb_get_info(fileyuv, &xsize, &ysize, &imgoffs)) {

			fclose(fileyuv);

			return NIL;

		}

		fseek(fileyuv, imgoffs, SEEK_SET);

		quantel_xsize = xsize;

	} else {

		if (!quantel_get_info(fname, type, &xsize, &ysize)) {

			fclose(fileyuv);

			return NIL;

		}

		quantel_xsize = QUANTEL_XSIZE;

	}

	image = new_img();

	image->type = TOONZRGB;

	if (!allocate_pixmap(image, xsize, ysize))

		return NIL;

	bufout1 = bufout2 = (LPIXEL *)image->buffer;

	bufout1 += ysize * xsize - 1;

	bufout2 += (ysize - 1) * xsize - 1;

	if (type == SDL_FORMAT) {

		for (y = 0; y < ysize; y += 2) {

			buf = bufout1 - (quantel_xsize - 1);

			QUANTEL_GET_YUV_LINE(fileyuv, buf, quantel_xsize)

			if (exit)

				break;

			bufout1 -= quantel_xsize * 2;

		}

		for (y = 1; y < ysize; y += 2) {

			buf = bufout2 - (quantel_xsize - 1);

			QUANTEL_GET_YUV_LINE(fileyuv, buf, quantel_xsize)

			if (exit)

				break;

			bufout2 -= quantel_xsize * 2;

		}

	} else {

		for (y = 0; y < ysize; y++) {

			buf = bufout1 - (quantel_xsize - 1);

			QUANTEL_GET_YUV_LINE(fileyuv, buf, quantel_xsize)

			if (exit)

				break;

			bufout1 -= quantel_xsize;

		}

	}

	if (ferror(fileyuv) || feof(fileyuv)) {

		fclose(fileyuv);

		return NIL;

	}

	fclose(fileyuv);

	*w = image->xsize;

	*h = image->ysize;

	return image->buffer;

}

/*---------------------------------------------------------------------------*/

int img_write_quantel(const T_CHAR *fname, void *buffer, int w, int h, int type)

{

	FILE *outf;

	UCHAR *picbuf, *ap;

	USHORT rbuffer[8192], gbuffer[8192], bbuffer[8192];

	USHORT *rbuf, *gbuf, *bbuf;

	int y, yuv_flag = 0;

	int xmarg, ymarg;

	LPIXEL *RGBbuf, *appo;

	int xsize, true_ysize, max_ysize = 0, ysize, ret, interlace = 0;

	rbuf = (USHORT *)&rbuffer;

	gbuf = (USHORT *)&gbuffer;

	bbuf = (USHORT *)&bbuffer;

	xsize = w;

	ysize = h;

	if (xsize > QUANTEL_XSIZE) {

		/* printf("error: bad X size (%s)\n", Quantel_error[type-1]);*/

		return FALSE;

	} else if (xsize < QUANTEL_XSIZE)

		xmarg = (QUANTEL_XSIZE - xsize) / 2;

	else

		xmarg = 0;

	switch (type) {

	case QNT_FORMAT:

		interlace = FALSE;

		yuv_flag = 0;

		max_ysize = QNT_PAL_YSIZE;

		CASE QTL_FORMAT : interlace = FALSE;

		yuv_flag = 0;

		max_ysize = QTL_NTSC_YSIZE;

		CASE YUV_FORMAT : __OR VPB_FORMAT : interlace = FALSE;

		yuv_flag = 0;

		max_ysize = QUANTEL_GET_YSIZE(ysize);

		CASE SDL_FORMAT : interlace = TRUE;

		yuv_flag = 0;

		max_ysize = QUANTEL_GET_YSIZE(ysize);

	DEFAULT:

		/*printf("error: %d bad file format\n", fname);*/

		return 0;

	}

	if (ysize > max_ysize) {

		/*printf("error: bad Y size (%s)\n", Quantel_error[type-1]);*/

		return FALSE;

	} else if (!yuv_flag && ysize < max_ysize) {

		ymarg = (max_ysize - ysize) / 2;

		true_ysize = max_ysize;

	} else {

		ymarg = 0;

		true_ysize = ysize;

	}

	outf = _wfopen(fname, L"wb");

	if (outf == NULL) {

		/*printf("error: unable to open %s for writing\n",  fname);*/

		return FALSE;

	}

	if (type == VPB_FORMAT) {

		write_vpb_header(outf, QUANTEL_XSIZE, true_ysize);

	}

	picbuf = (UCHAR *)malloc(true_ysize * QUANTEL_XSIZE * sizeof(short));

	if (picbuf == NIL) {

		/*printf("img_write_quantel error: out of memory\n");*/

		return 0;

	}

	ap = picbuf + (true_ysize * QUANTEL_XSIZE * sizeof(short)) - 1;

	RGBbuf = (LPIXEL *)buffer;

	if (interlace) {

		appo = RGBbuf;

		for (y = 0; y < true_ysize; y += 2) {

			if (y < ymarg || y > (true_ysize - ymarg - 1))

				QUANTEL_FILL_LINE_OF_BLACK(rbuf, gbuf, bbuf, QUANTEL_XSIZE)

			else {

				QUANTEL_FILL_LINE_OF_RGB(xmarg, xsize, rbuf, gbuf, bbuf, appo)

				appo += xsize;

			}

			quantel_rgb_to_yuv(rbuf, gbuf, bbuf, ap);

			ap -= BYTESPERROW;

		}

		appo = RGBbuf + xsize;

		for (y = 1; y < true_ysize; y += 2) {

			if (y < ymarg || y > (true_ysize - ymarg - 1))

				QUANTEL_FILL_LINE_OF_BLACK(rbuf, gbuf, bbuf, QUANTEL_XSIZE)

			else {

				QUANTEL_FILL_LINE_OF_RGB(xmarg, xsize, rbuf, gbuf, bbuf, appo)

				appo += xsize;

			}

			quantel_rgb_to_yuv(rbuf, gbuf, bbuf, ap);

			ap -= BYTESPERROW;

		}

	} else {

		for (y = 0; y < true_ysize; y++) {

			if (y < ymarg || y > (true_ysize - ymarg - 1))

				QUANTEL_FILL_LINE_OF_BLACK(rbuf, gbuf, bbuf, QUANTEL_XSIZE)

			else

				QUANTEL_FILL_LINE_OF_RGB(xmarg, xsize, rbuf, gbuf, bbuf, RGBbuf)

			quantel_rgb_to_yuv(rbuf, gbuf, bbuf, ap);

			ap -= BYTESPERROW;

		}

	}

	ret = quantel_write_buffer(outf, picbuf, true_ysize);

	if (picbuf)

		free(picbuf);

	fclose(outf);

	return ret; /*  ??  */

}

/*---------------------------------------------------------------------------*/

IMAGE *img_read_region_quantel(T_CHAR *fname, int x1, int y1, int x2, int y2,

							   int scale, int type)

{

	if (type == SDL_FORMAT)

		return (img_read_region_quantel_no_interlaced(fname, x1, y1, x2, y2, scale, type));

	else

		return (img_read_region_quantel_interlaced(fname, x1, y1, x2, y2, scale, type));

}

/*---------------------------------------------------------------------------*/

static IMAGE *img_read_region_quantel_no_interlaced(T_CHAR *fname,

													int x1, int y1, int x2, int y2,

													int scale, int type)

{

	int offset, xsize, ysize, imgoffs;

	int rows_field1, rows_field2, ret, step, off_row;

	LPIXEL *bufout1, *bufout2, *buff;

	TINT32 r, g, b, j, k, u, v, x, y;

	unsigned char *linebuf, *head_linebuf = NULL;

	INFO_REGION region;

	IMAGE *image = NULL;

	FILE *fileyuv;

	fileyuv = _wfopen(fname, L"rb");

	if (!fileyuv)

		return NIL;

	if (type == VPB_FORMAT) {

		if (!vpb_get_info(fileyuv, &xsize, &ysize, &imgoffs)) {

			fclose(fileyuv);

			return NIL;

		}

	} else {

		if (!quantel_get_info(fname, type, &xsize, &ysize)) {

			fclose(fileyuv);

			return NIL;

		}

		imgoffs = 0;

	}

	image = new_img();

	image->type = TOONZRGB;

	getInfoRegion(®ion, x1, y1, x2, y2, scale, xsize, ysize);

	if (!allocate_pixmap(image, region.xsize, region.ysize))

		return NIL;

	bufout1 = bufout2 = (LPIXEL *)image->buffer;

	bufout1 += (region.ysize - 1) * region.xsize + region.x_offset;

	bufout2 += (region.ysize - 2) * region.xsize + region.x_offset;

	linebuf = (unsigned char *)calloc(1, BYTESPERROW);

	if (!linebuf) {

		/*

	printf("error: out of memory\n");

  exit(1);

	*/

		return 0;

	}

	if (region.scanNrow & 0x1) /* se dispare */

	{

		rows_field1 = region.scanNrow / 2 + 1;

		rows_field2 = region.scanNrow / 2;

	} else

		rows_field1 = rows_field2 = region.scanNrow / 2;

	offset = (region.ly_in - (region.scanNrow * scale + MAX(y1, 0))) / 2;

	offset *= BYTESPERROW;

	if (fseek(fileyuv, imgoffs + offset, SEEK_SET)) {

		/* printf("error: seek failed; inconsistent data\n");*/

		goto error;

	}

	for (y = 0; y < rows_field1; y++) {

		ret = fread(linebuf, 1, BYTESPERROW, fileyuv);

		if (!ret)

			goto end;

		head_linebuf = linebuf;

		off_row = region.startScanCol * sizeof(TUINT32) / 2;

		if (off_row & 3)

			off_row += 2;

		linebuf += off_row;

		buff = bufout1;

		for (x = 0; x < region.scanNcol / 2; x++) {

			u = *linebuf++ - 128;

			j = *linebuf++ - 16;

			if (j < 0)

				j = 0;

			v = *linebuf++ - 128;

			k = *linebuf++ - 16;

			r = 76310 * j + 104635 * v;

			if (r > 0xffffff)

				r = 0xffffff;

			if (r <= 0xffff)

				r = 0;

			g = 76310 * j + -25690 * u + -53294 * v;

			if (g > 0xffffff)

				g = 0xffffff;

			if (g <= 0xffff)

				g = 0;

			b = 76310 * j + 132278 * u;

			if (b > 0xffffff)

				b = 0xffffff;

			if (b <= 0xffff)

				b = 0;

			buff->r = (unsigned char)(r >> 16);

			buff->g = (unsigned char)(g >> 16);

			buff->b = (unsigned char)(b >> 16);

			buff->m = 255;

			buff++;

			r = 76310 * k + 104635 * v;

			if (r > 0xffffff)

				r = 0xffffff;

			if (r <= 0xffff)

				r = 0;

			g = 76310 * k + -25690 * u + -53294 * v;

			if (g > 0xffffff)

				g = 0xffffff;

			if (g <= 0xffff)

				g = 0;

			b = 76310 * k + 132278 * u;

			if (b > 0xffffff)

				b = 0xffffff;

			if (b <= 0xffff)

				b = 0;

			buff->r = (unsigned char)(r >> 16);

			buff->g = (unsigned char)(g >> 16);

			buff->b = (unsigned char)(b >> 16);

			buff->m = 255;

			buff++;

			linebuf += (region.step - 1) * sizeof(TUINT32);

		}

		linebuf = head_linebuf;

		if (y * 2 > region.ly_in)

			break;

		for (step = 1; step < region.step; step++) {

			if (fseek(fileyuv, BYTESPERROW, SEEK_CUR)) {

				printf("error: seek failed; inconsistent data\n");

				goto error;

			}

		}

		bufout1 -= region.xsize * 2;

	}

	offset = (region.ly_in - (region.scanNrow * scale + MAX(y1, 0))) / 2;

	offset = (region.ly_in / 2 + offset);

	offset *= BYTESPERROW;

	if (fseek(fileyuv, imgoffs + offset, SEEK_SET)) {

		/*printf("error: seek failed; inconsistent data\n");*/

		goto error;

	}

	for (y = 0; y < rows_field2; y++) {

		ret = fread(linebuf, 1, BYTESPERROW, fileyuv);

		if (!ret)

			goto end;

		head_linebuf = linebuf;

		off_row = region.startScanCol * sizeof(TUINT32) / 2;

		if (off_row & 3)

			off_row += 2;

		linebuf += off_row;

		buff = bufout2;

		for (x = 0; x < region.scanNcol / 2; x++) {

			u = *linebuf++ - 128;

			j = *linebuf++ - 16;

			if (j < 0)

				j = 0;

			v = *linebuf++ - 128;

			k = *linebuf++ - 16;

			r = 76310 * j + 104635 * v;

			if (r > 0xffffff)

				r = 0xffffff;

			if (r <= 0xffff)

				r = 0;

			g = 76310 * j + -25690 * u + -53294 * v;

			if (g > 0xffffff)

				g = 0xffffff;

			if (g <= 0xffff)

				g = 0;

			b = 76310 * j + 132278 * u;

			if (b > 0xffffff)

				b = 0xffffff;

			if (b <= 0xffff)

				b = 0;

			buff->r = (unsigned char)(r >> 16);

			buff->g = (unsigned char)(g >> 16);

			buff->b = (unsigned char)(b >> 16);

			buff->m = 255;

			buff++;

			r = 76310 * k + 104635 * v;

			if (r > 0xffffff)

				r = 0xffffff;

			if (r <= 0xffff)

				r = 0;

			g = 76310 * k + -25690 * u + -53294 * v;

			if (g > 0xffffff)

				g = 0xffffff;

			if (g <= 0xffff)

				g = 0;

			b = 76310 * k + 132278 * u;

			if (b > 0xffffff)

				b = 0xffffff;

			if (b <= 0xffff)

				b = 0;

			buff->r = (unsigned char)(r >> 16);

			buff->g = (unsigned char)(g >> 16);

			buff->b = (unsigned char)(b >> 16);

			buff->m = 255;

			buff++;

			linebuf += (region.step - 1) * sizeof(TUINT32);

		}

		linebuf = head_linebuf;

		if (y * 2 + 1 > region.ly_in)

			break;

		for (step = 1; step < region.step; step++) {

			if (fseek(fileyuv, BYTESPERROW, SEEK_CUR)) {

				printf("error: seek failed; inconsistent data\n");

				goto error;

			}

		}

		bufout2 -= region.xsize * 2;

	}

	if (ferror(fileyuv) || feof(fileyuv))

		goto error;

end:

	if (head_linebuf)

		free(head_linebuf);

	fclose(fileyuv);

	return image;

error:

	if (head_linebuf)

		free(head_linebuf);

	free_img(image);

	fclose(fileyuv);

	return NIL;

}

/*---------------------------------------------------------------------------*/

static IMAGE *img_read_region_quantel_interlaced(T_CHAR *fname,

												 int x1, int y1, int x2, int y2,

												 int scale, int type)

{

	int offset, rgbbuf_offset, xsize, ysize, imgoffs, ret, step, x, y;

	LPIXEL *bufRGB, *headBufRGB;

	unsigned char *headLineBuf, *lineBuf;

	TINT32 r, g, b, j, k, u, v;

	INFO_REGION region;

	IMAGE *image = NULL;

	FILE *fileyuv;

	fileyuv = _wfopen(fname, L"rb");

	if (!fileyuv)

		return NIL;

	if (type == VPB_FORMAT) {

		if (!vpb_get_info(fileyuv, &xsize, &ysize, &imgoffs)) {

			fclose(fileyuv);

			return NIL;

		}

	} else {

		if (!quantel_get_info(fname, type, &xsize, &ysize)) {

			fclose(fileyuv);

			return NIL;

		}

		imgoffs = 0;

	}

	image = new_img();

	image->type = TOONZRGB;

	getInfoRegion(®ion, x1, y1, x2, y2, scale, xsize, ysize);

	if (!allocate_pixmap(image, region.xsize, region.ysize))

		return NIL;

	rgbbuf_offset = (region.x_offset + (region.xsize * region.y_offset));

	headBufRGB = (LPIXEL *)image->buffer;

	headLineBuf = lineBuf = (unsigned char *)calloc(1, BYTESPERROW);

	if (!headLineBuf) {

		return 0;

	}

	if (y2 < ysize - 1)

		offset = (ysize - 1 - y2) * BYTESPERROW;

	else

		offset = 0;

	fseek(fileyuv, imgoffs + offset, SEEK_SET);

	for (y = 0; y < region.scanNrow; y++) {

		bufRGB = headBufRGB + rgbbuf_offset +

				 (region.xsize * (region.scanNrow - y - 1));

		ret = fread(lineBuf, 1, BYTESPERROW, fileyuv);

		if (!ret)

			goto end;

		lineBuf += region.startScanCol * sizeof(LPIXEL);

		QUANTEL_BUILD_ROW; /* sta in testa al file */

		if (y >= region.scanNrow - 1)

			break;

		for (step = 1; step < region.step; step++) {

			if (fseek(fileyuv, BYTESPERROW, SEEK_CUR)) {

				/*printf("error: seek failed; inconsistent data\n");*/

				goto error;

			}

		}

		lineBuf = headLineBuf;

	}

	if (ferror(fileyuv) || feof(fileyuv))

		goto error;

end:

	if (headLineBuf)

		free(headLineBuf);

	fclose(fileyuv);

	return image;

error:

	if (headLineBuf)

		free(headLineBuf);

	free_img(image);

	fclose(fileyuv);

	return NIL;

}