#if _MSC_VER >= 1400
#define _CRT_SECURE_NO_DEPRECATE 1
#pragma warning(disable : 4996)
#endif
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#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;
break;
case QTL_FORMAT:
*xsize = QTL_NTSC_XSIZE;
*ysize = QTL_NTSC_YSIZE;
break;
case YUV_FORMAT:
*xsize = QUANTEL_XSIZE;
switch (f_stat.st_size) {
case QNT_PAL_FILE_SIZE:
case QNT_PAL_W_FILE_SIZE:
*ysize = QNT_PAL_YSIZE;
break;
case QTL_NTSC_FILE_SIZE:
case QTL_NTSC_W_FILE_SIZE:
*ysize = QTL_NTSC_YSIZE;
break;
default:
*ysize = f_stat.st_size / (QUANTEL_XSIZE * sizeof(short));
break;
}
break;
case SDL_FORMAT:
*xsize = QNT_PAL_XSIZE;
switch (f_stat.st_size) {
case QNT_PAL_FILE_SIZE:
*ysize = QNT_PAL_YSIZE;
break;
case QTL_NTSC_FILE_SIZE:
*ysize = QTL_NTSC_YSIZE;
break;
default:
/*printf("error: bad file dimension\n");*/
return FALSE;
}
break;
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;
break;
case QTL_FORMAT:
interlace = FALSE;
yuv_flag = 0;
max_ysize = QTL_NTSC_YSIZE;
break;
case YUV_FORMAT:
case VPB_FORMAT:
interlace = FALSE;
yuv_flag = 0;
max_ysize = QUANTEL_GET_YSIZE(ysize);
break;
case SDL_FORMAT:
interlace = TRUE;
yuv_flag = 0;
max_ysize = QUANTEL_GET_YSIZE(ysize);
break;
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;
}