812 lines
25 KiB
C
812 lines
25 KiB
C
|
|
|
|
#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"
|
|
|
|
#ifndef min
|
|
#define min(a, b) (((a) < (b)) ? (a) : (b))
|
|
#endif
|
|
#ifndef max
|
|
#define max(a, b) (((a) > (b)) ? (a) : (b))
|
|
#endif
|
|
|
|
#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;
|
|
}
|