Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

tiffdec: K&R cosmetics

Browse Source
pull/5/head
Alex Converse 13 years ago
parent cbf767a87c
commit f346b6bbeb
1 changed files with 147 additions and 108 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 255
      libavcodec/tiff.c

255
libavcodec/tiff.c
Unescape View File

@ -53,35 +53,39 @@ typedef struct TiffContext {
int strips, rps, sstype; int strips, rps, sstype;
int sot; int sot;
const uint8_t* stripdata; const uint8_t *stripdata;
const uint8_t* stripsizes; const uint8_t *stripsizes;
int stripsize, stripoff; int stripsize, stripoff;
LZWState *lzw; LZWState *lzw;
} TiffContext; } TiffContext;
static unsigned tget_short(const uint8_t **p, int le) { static unsigned tget_short(const uint8_t **p, int le)
{
unsigned v = le ? AV_RL16(*p) : AV_RB16(*p); unsigned v = le ? AV_RL16(*p) : AV_RB16(*p);
*p += 2; *p += 2;
return v; return v;
} }
static unsigned tget_long(const uint8_t **p, int le) { static unsigned tget_long(const uint8_t **p, int le)
{
unsigned v = le ? AV_RL32(*p) : AV_RB32(*p); unsigned v = le ? AV_RL32(*p) : AV_RB32(*p);
*p += 4; *p += 4;
return v; return v;
} }
static unsigned tget(const uint8_t **p, int type, int le) { static unsigned tget(const uint8_t **p, int type, int le)
switch(type){ {
switch (type) {
case TIFF_BYTE : return *(*p)++; case TIFF_BYTE : return *(*p)++;
case TIFF_SHORT: return tget_short(p, le); case TIFF_SHORT: return tget_short(p, le);
case TIFF_LONG : return tget_long (p, le); case TIFF_LONG : return tget_long(p, le);
default : return UINT_MAX; default : return UINT_MAX;
} }
} }
#if CONFIG_ZLIB #if CONFIG_ZLIB
static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, int size) static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
int size)
{ {
z_stream zstream = { 0 }; z_stream zstream = { 0 };
int zret; int zret;
@ -102,7 +106,9 @@ static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
} }
#endif #endif
static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){ static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
const uint8_t *src, int size, int lines)
{
int c, line, pixels, code; int c, line, pixels, code;
const uint8_t *ssrc = src; const uint8_t *ssrc = src;
int width = ((s->width * s->bpp) + 7) >> 3; int width = ((s->width * s->bpp) + 7) >> 3;
@ -111,21 +117,24 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
#if CONFIG_ZLIB #if CONFIG_ZLIB
if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){ if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
uint8_t *zbuf; unsigned long outlen; uint8_t *zbuf;
unsigned long outlen;
int ret; int ret;
outlen = width * lines; outlen = width * lines;
zbuf = av_malloc(outlen); zbuf = av_malloc(outlen);
if (!zbuf) if (!zbuf)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = tiff_uncompress(zbuf, &outlen, src, size); ret = tiff_uncompress(zbuf, &outlen, src, size);
if(ret != Z_OK){ if (ret != Z_OK) {
av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret); av_log(s->avctx, AV_LOG_ERROR,
"Uncompressing failed (%lu of %lu) with error %d\n", outlen,
(unsigned long)width * lines, ret);
av_free(zbuf); av_free(zbuf);
return -1; return -1;
} }
src = zbuf; src = zbuf;
for(line = 0; line < lines; line++){ for (line = 0; line < lines; line++) {
memcpy(dst, src, width); memcpy(dst, src, width);
dst += stride; dst += stride;
src += width; src += width;
@ -134,48 +143,53 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
return 0; return 0;
} }
#endif #endif
if(s->compr == TIFF_LZW){ if (s->compr == TIFF_LZW) {
if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){ if (ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n"); av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
return -1; return -1;
} }
} }
if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){ if (s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3
|| s->compr == TIFF_G4) {
int i, ret = 0; int i, ret = 0;
uint8_t *src2 = av_malloc((unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE); uint8_t *src2 = av_malloc((unsigned)size +
FF_INPUT_BUFFER_PADDING_SIZE);
if (!src2) { if (!src2) {
av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); av_log(s->avctx, AV_LOG_ERROR,
"Error allocating temporary buffer\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if(s->fax_opts & 2){ if (s->fax_opts & 2) {
av_log(s->avctx, AV_LOG_ERROR, "Uncompressed fax mode is not supported (yet)\n"); av_log(s->avctx, AV_LOG_ERROR,
"Uncompressed fax mode is not supported (yet)\n");
av_free(src2); av_free(src2);
return -1; return -1;
} }
if(!s->fill_order){ if (!s->fill_order) {
memcpy(src2, src, size); memcpy(src2, src, size);
}else{ } else {
for(i = 0; i < size; i++) for (i = 0; i < size; i++)
src2[i] = av_reverse[src[i]]; src2[i] = av_reverse[src[i]];
} }
memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE); memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
switch(s->compr){ switch (s->compr) {
case TIFF_CCITT_RLE: case TIFF_CCITT_RLE:
case TIFF_G3: case TIFF_G3:
case TIFF_G4: case TIFF_G4:
ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts); ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride,
s->compr, s->fax_opts);
break; break;
} }
av_free(src2); av_free(src2);
return ret; return ret;
} }
for(line = 0; line < lines; line++){ for (line = 0; line < lines; line++) {
if(src - ssrc > size){ if (src - ssrc > size) {
av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n"); av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
return -1; return -1;
} }
switch(s->compr){ switch (s->compr) {
case TIFF_RAW: case TIFF_RAW:
if (ssrc + size - src < width) if (ssrc + size - src < width)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
@ -189,21 +203,23 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
src += width; src += width;
break; break;
case TIFF_PACKBITS: case TIFF_PACKBITS:
for(pixels = 0; pixels < width;){ for (pixels = 0; pixels < width;) {
code = (int8_t)*src++; code = (int8_t) * src++;
if(code >= 0){ if (code >= 0) {
code++; code++;
if(pixels + code > width){ if (pixels + code > width) {
av_log(s->avctx, AV_LOG_ERROR, "Copy went out of bounds\n"); av_log(s->avctx, AV_LOG_ERROR,
"Copy went out of bounds\n");
return -1; return -1;
} }
memcpy(dst + pixels, src, code); memcpy(dst + pixels, src, code);
src += code; src += code;
pixels += code; pixels += code;
}else if(code != -128){ // -127..-1 } else if (code != -128) { // -127..-1
code = (-code) + 1; code = (-code) + 1;
if(pixels + code > width){ if (pixels + code > width) {
av_log(s->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); av_log(s->avctx, AV_LOG_ERROR,
"Run went out of bounds\n");
return -1; return -1;
} }
c = *src++; c = *src++;
@ -214,8 +230,9 @@ static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uin
break; break;
case TIFF_LZW: case TIFF_LZW:
pixels = ff_lzw_decode(s->lzw, dst, width); pixels = ff_lzw_decode(s->lzw, dst, width);
if(pixels < width){ if (pixels < width) {
av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", pixels, width); av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",
pixels, width);
return -1; return -1;
} }
break; break;
@ -279,7 +296,8 @@ static int init_image(TiffContext *s)
return 0; return 0;
} }
static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf) static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
const uint8_t *buf, const uint8_t *end_buf)
{ {
unsigned tag, type, count, off, value = 0; unsigned tag, type, count, off, value = 0;
int i, j; int i, j;
@ -294,12 +312,13 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
off = tget_long(&buf, s->le); off = tget_long(&buf, s->le);
if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) { if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n", type); av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n",
type);
return 0; return 0;
} }
if(count == 1){ if (count == 1) {
switch(type){ switch (type) {
case TIFF_BYTE: case TIFF_BYTE:
case TIFF_SHORT: case TIFF_SHORT:
buf -= 4; buf -= 4;
@ -311,7 +330,7 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
buf = NULL; buf = NULL;
break; break;
case TIFF_STRING: case TIFF_STRING:
if(count <= 4){ if (count <= 4) {
buf -= 4; buf -= 4;
break; break;
} }
@ -327,12 +346,13 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
} }
} }
if(buf && (buf < start || buf > end_buf)){ if (buf && (buf < start || buf > end_buf)) {
av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); av_log(s->avctx, AV_LOG_ERROR,
"Tag referencing position outside the image\n");
return -1; return -1;
} }
switch(tag){ switch (tag) {
case TIFF_WIDTH: case TIFF_WIDTH:
s->width = value; s->width = value;
break; break;
@ -341,20 +361,25 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
break; break;
case TIFF_BPP: case TIFF_BPP:
s->bppcount = count; s->bppcount = count;
if(count > 4){ if (count > 4) {
av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count); av_log(s->avctx, AV_LOG_ERROR,
"This format is not supported (bpp=%d, %d components)\n",
s->bpp, count);
return -1; return -1;
} }
if(count == 1) s->bpp = value; if (count == 1)
else{ s->bpp = value;
switch(type){ else {
switch (type) {
case TIFF_BYTE: case TIFF_BYTE:
s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF); s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) +
((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
break; break;
case TIFF_SHORT: case TIFF_SHORT:
case TIFF_LONG: case TIFF_LONG:
s->bpp = 0; s->bpp = 0;
for(i = 0; i < count && buf < end_buf; i++) s->bpp += tget(&buf, type, s->le); for (i = 0; i < count && buf < end_buf; i++)
s->bpp += tget(&buf, type, s->le);
break; break;
default: default:
s->bpp = -1; s->bpp = -1;
@ -374,7 +399,7 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
case TIFF_COMPR: case TIFF_COMPR:
s->compr = value; s->compr = value;
s->predictor = 0; s->predictor = 0;
switch(s->compr){ switch (s->compr) {
case TIFF_RAW: case TIFF_RAW:
case TIFF_PACKBITS: case TIFF_PACKBITS:
case TIFF_LZW: case TIFF_LZW:
@ -394,48 +419,54 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
#endif #endif
case TIFF_JPEG: case TIFF_JPEG:
case TIFF_NEWJPEG: case TIFF_NEWJPEG:
av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n"); av_log(s->avctx, AV_LOG_ERROR,
"JPEG compression is not supported\n");
return -1; return -1;
default: default:
av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr); av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n",
s->compr);
return -1; return -1;
} }
break; break;
case TIFF_ROWSPERSTRIP: case TIFF_ROWSPERSTRIP:
if (type == TIFF_LONG && value == UINT_MAX) if (type == TIFF_LONG && value == UINT_MAX)
value = s->avctx->height; value = s->avctx->height;
if(value < 1){ if (value < 1) {
av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n"); av_log(s->avctx, AV_LOG_ERROR,
"Incorrect value of rows per strip\n");
return -1; return -1;
} }
s->rps = value; s->rps = value;
break; break;
case TIFF_STRIP_OFFS: case TIFF_STRIP_OFFS:
if(count == 1){ if (count == 1) {
s->stripdata = NULL; s->stripdata = NULL;
s->stripoff = value; s->stripoff = value;
}else } else
s->stripdata = start + off; s->stripdata = start + off;
s->strips = count; s->strips = count;
if(s->strips == 1) s->rps = s->height; if (s->strips == 1)
s->rps = s->height;
s->sot = type; s->sot = type;
if(s->stripdata > end_buf){ if (s->stripdata > end_buf) {
av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); av_log(s->avctx, AV_LOG_ERROR,
"Tag referencing position outside the image\n");
return -1; return -1;
} }
break; break;
case TIFF_STRIP_SIZE: case TIFF_STRIP_SIZE:
if(count == 1){ if (count == 1) {
s->stripsizes = NULL; s->stripsizes = NULL;
s->stripsize = value; s->stripsize = value;
s->strips = 1; s->strips = 1;
}else{ } else {
s->stripsizes = start + off; s->stripsizes = start + off;
} }
s->strips = count; s->strips = count;
s->sstype = type; s->sstype = type;
if(s->stripsizes > end_buf){ if (s->stripsizes > end_buf) {
av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); av_log(s->avctx, AV_LOG_ERROR,
"Tag referencing position outside the image\n");
return -1; return -1;
} }
break; break;
@ -443,7 +474,7 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
s->predictor = value; s->predictor = value;
break; break;
case TIFF_INVERT: case TIFF_INVERT:
switch(value){ switch (value) {
case 0: case 0:
s->invert = 1; s->invert = 1;
break; break;
@ -454,13 +485,15 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
case 3: case 3:
break; break;
default: default:
av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value); av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n",
value);
return -1; return -1;
} }
break; break;
case TIFF_FILL_ORDER: case TIFF_FILL_ORDER:
if(value < 1 || value > 2){ if (value < 1 || value > 2) {
av_log(s->avctx, AV_LOG_ERROR, "Unknown FillOrder value %d, trying default one\n", value); av_log(s->avctx, AV_LOG_ERROR,
"Unknown FillOrder value %d, trying default one\n", value);
value = 1; value = 1;
} }
s->fill_order = value - 1; s->fill_order = value - 1;
@ -474,43 +507,43 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *
gp = buf + count / 3 * off; gp = buf + count / 3 * off;
bp = buf + count / 3 * off * 2; bp = buf + count / 3 * off * 2;
off = (type_sizes[type] - 1) << 3; off = (type_sizes[type] - 1) << 3;
for(i = 0; i < count / 3; i++){ for (i = 0; i < count / 3; i++) {
j = (tget(&rp, type, s->le) >> off) << 16; j = (tget(&rp, type, s->le) >> off) << 16;
j |= (tget(&gp, type, s->le) >> off) << 8; j |= (tget(&gp, type, s->le) >> off) << 8;
j |= tget(&bp, type, s->le) >> off; j |= tget(&bp, type, s->le) >> off;
pal[i] = j; pal[i] = j;
} }
s->palette_is_set = 1; s->palette_is_set = 1;
break; break;
case TIFF_PLANAR: case TIFF_PLANAR:
if(value == 2){ if (value == 2) {
av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n"); av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
return -1; return -1;
} }
break; break;
case TIFF_T4OPTIONS: case TIFF_T4OPTIONS:
if(s->compr == TIFF_G3) if (s->compr == TIFF_G3)
s->fax_opts = value; s->fax_opts = value;
break; break;
case TIFF_T6OPTIONS: case TIFF_T6OPTIONS:
if(s->compr == TIFF_G4) if (s->compr == TIFF_G4)
s->fax_opts = value; s->fax_opts = value;
break; break;
default: default:
av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n", tag, tag); av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n",
tag, tag);
} }
return 0; return 0;
} }
static int decode_frame(AVCodecContext *avctx, static int decode_frame(AVCodecContext *avctx,
void *data, int *data_size, void *data, int *data_size, AVPacket *avpkt)
AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
TiffContext * const s = avctx->priv_data; TiffContext *const s = avctx->priv_data;
AVFrame *picture = data; AVFrame *picture = data;
AVFrame * const p = &s->picture; AVFrame *const p = &s->picture;
const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
unsigned off; unsigned off;
int id, le, ret; int id, le, ret;
@ -522,10 +555,13 @@ static int decode_frame(AVCodecContext *avctx,
//parse image header //parse image header
if (end_buf - buf < 8) if (end_buf - buf < 8)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
id = AV_RL16(buf); buf += 2; id = AV_RL16(buf);
if(id == 0x4949) le = 1; buf += 2;
else if(id == 0x4D4D) le = 0; if (id == 0x4949)
else{ le = 1;
else if (id == 0x4D4D)
le = 0;
else {
av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n"); av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
return -1; return -1;
} }
@ -535,8 +571,9 @@ static int decode_frame(AVCodecContext *avctx,
s->fill_order = 0; s->fill_order = 0;
// As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
// that further identifies the file as a TIFF file" // that further identifies the file as a TIFF file"
if(tget_short(&buf, le) != 42){ if (tget_short(&buf, le) != 42) {
av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n"); av_log(avctx, AV_LOG_ERROR,
"The answer to life, universe and everything is not correct!\n");
return -1; return -1;
} }
// Reset these pointers so we can tell if they were set this frame // Reset these pointers so we can tell if they were set this frame
@ -549,12 +586,12 @@ static int decode_frame(AVCodecContext *avctx,
} }
buf = orig_buf + off; buf = orig_buf + off;
entries = tget_short(&buf, le); entries = tget_short(&buf, le);
for(i = 0; i < entries; i++){ for (i = 0; i < entries; i++) {
if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0) if (tiff_decode_tag(s, orig_buf, buf, end_buf) < 0)
return -1; return -1;
buf += 12; buf += 12;
} }
if(!s->stripdata && !s->stripoff){ if (!s->stripdata && !s->stripoff) {
av_log(avctx, AV_LOG_ERROR, "Image data is missing\n"); av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
return -1; return -1;
} }
@ -562,53 +599,54 @@ static int decode_frame(AVCodecContext *avctx,
if ((ret = init_image(s)) < 0) if ((ret = init_image(s)) < 0)
return ret; return ret;
if(s->strips == 1 && !s->stripsize){ if (s->strips == 1 && !s->stripsize) {
av_log(avctx, AV_LOG_WARNING, "Image data size missing\n"); av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
s->stripsize = buf_size - s->stripoff; s->stripsize = buf_size - s->stripoff;
} }
stride = p->linesize[0]; stride = p->linesize[0];
dst = p->data[0]; dst = p->data[0];
for(i = 0; i < s->height; i += s->rps){ for (i = 0; i < s->height; i += s->rps) {
if(s->stripsizes) { if (s->stripsizes) {
if (s->stripsizes >= end_buf) if (s->stripsizes >= end_buf)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
ssize = tget(&s->stripsizes, s->sstype, s->le); ssize = tget(&s->stripsizes, s->sstype, s->le);
} else } else
ssize = s->stripsize; ssize = s->stripsize;
if(s->stripdata){ if (s->stripdata) {
if (s->stripdata >= end_buf) if (s->stripdata >= end_buf)
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
soff = tget(&s->stripdata, s->sot, s->le); soff = tget(&s->stripdata, s->sot, s->le);
}else } else
soff = s->stripoff; soff = s->stripoff;
if (soff > buf_size || ssize > buf_size - soff) { if (soff > buf_size || ssize > buf_size - soff) {
av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n"); av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
return -1; return -1;
} }
if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0) if (tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize,
FFMIN(s->rps, s->height - i)) < 0)
break; break;
dst += s->rps * stride; dst += s->rps * stride;
} }
if(s->predictor == 2){ if (s->predictor == 2) {
dst = p->data[0]; dst = p->data[0];
soff = s->bpp >> 3; soff = s->bpp >> 3;
ssize = s->width * soff; ssize = s->width * soff;
for(i = 0; i < s->height; i++) { for (i = 0; i < s->height; i++) {
for(j = soff; j < ssize; j++) for (j = soff; j < ssize; j++)
dst[j] += dst[j - soff]; dst[j] += dst[j - soff];
dst += stride; dst += stride;
} }
} }
if(s->invert){ if (s->invert) {
uint8_t *src; uint8_t *src;
int j; int j;
src = s->picture.data[0]; src = s->picture.data[0];
for(j = 0; j < s->height; j++){ for (j = 0; j < s->height; j++) {
for(i = 0; i < s->picture.linesize[0]; i++) for (i = 0; i < s->picture.linesize[0]; i++)
src[i] = 255 - src[i]; src[i] = 255 - src[i];
src += s->picture.linesize[0]; src += s->picture.linesize[0];
} }
@ -619,7 +657,8 @@ static int decode_frame(AVCodecContext *avctx,
return buf_size; return buf_size;
} }
static av_cold int tiff_init(AVCodecContext *avctx){ static av_cold int tiff_init(AVCodecContext *avctx)
{
TiffContext *s = avctx->priv_data; TiffContext *s = avctx->priv_data;
s->width = 0; s->width = 0;
@ -635,10 +674,10 @@ static av_cold int tiff_init(AVCodecContext *avctx){
static av_cold int tiff_end(AVCodecContext *avctx) static av_cold int tiff_end(AVCodecContext *avctx)
{ {
TiffContext * const s = avctx->priv_data; TiffContext *const s = avctx->priv_data;
ff_lzw_decode_close(&s->lzw); ff_lzw_decode_close(&s->lzw);
if(s->picture.data[0]) if (s->picture.data[0])
avctx->release_buffer(avctx, &s->picture); avctx->release_buffer(avctx, &s->picture);
return 0; return 0;
} }

Write Preview
Loading…
Cancel
Save