GetByteContext gb;
int get_subimage;
+ uint16_t get_page;
+ int get_thumbnail;
+ enum TiffType tiff_type;
int width, height;
unsigned int bpp, bppcount;
uint32_t palette[256];
int predictor;
int fill_order;
uint32_t res[4];
+ int is_thumbnail;
int is_bayer;
uint8_t pattern[4];
unsigned white_level;
uint32_t sub_ifd;
+ uint16_t cur_page;
int strips, rps, sstype;
int sot;
TiffGeoTag *geotags;
} TiffContext;
+static void tiff_set_type(TiffContext *s, enum TiffType tiff_type) {
+ if (s->tiff_type < tiff_type) // Prioritize higher-valued entries
+ s->tiff_type = tiff_type;
+}
+
static void free_geotags(TiffContext *const s)
{
int i;
if (s->compr == TIFF_CCITT_RLE ||
s->compr == TIFF_G3 ||
s->compr == TIFF_G4) {
- if (is_yuv)
+ if (is_yuv || p->format == AV_PIX_FMT_GRAY12)
return AVERROR_INVALIDDATA;
return tiff_unpack_fax(s, dst, stride, src, size, width, lines);
case 324:
s->avctx->pix_fmt = s->photometric == TIFF_PHOTOMETRIC_SEPARATED ? AV_PIX_FMT_RGB0 : AV_PIX_FMT_RGBA;
break;
+ case 405:
+ if (s->photometric == TIFF_PHOTOMETRIC_SEPARATED)
+ s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
+ else {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "bpp=40 without PHOTOMETRIC_SEPARATED is unsupported\n");
+ return AVERROR_PATCHWELCOME;
+ }
+ break;
case 483:
s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGB48BE;
break;
}
switch (tag) {
+ case TIFF_SUBFILE:
+ s->is_thumbnail = (value != 0);
case TIFF_WIDTH:
s->width = value;
break;
s->height = value;
break;
case TIFF_BPP:
- if (count > 4U) {
+ if (count > 5U) {
av_log(s->avctx, AV_LOG_ERROR,
"This format is not supported (bpp=%d, %d components)\n",
value, count);
"Samples per pixel requires a single value, many provided\n");
return AVERROR_INVALIDDATA;
}
- if (value > 4U) {
+ if (value > 5U) {
av_log(s->avctx, AV_LOG_ERROR,
"Samples per pixel %d is too large\n", value);
return AVERROR_INVALIDDATA;
s->predictor = value;
break;
case TIFF_SUB_IFDS:
- s->sub_ifd = value;
+ if (count == 1)
+ s->sub_ifd = value;
+ else if (count > 1)
+ s->sub_ifd = ff_tget(&s->gb, TIFF_LONG, s->le); /** Only get the first SubIFD */
break;
- case TIFF_WHITE_LEVEL:
+ case DNG_WHITE_LEVEL:
s->white_level = value;
break;
case TIFF_CFA_PATTERN_DIM:
break;
case TIFF_PAGE_NUMBER:
ADD_METADATA(count, "page_number", " / ");
+ // need to seek back to re-read the page number
+ bytestream2_seek(&s->gb, -count * sizeof(uint16_t), SEEK_CUR);
+ // read the page number
+ s->cur_page = ff_tget(&s->gb, TIFF_SHORT, s->le);
+ // get back to where we were before the previous seek
+ bytestream2_seek(&s->gb, count * sizeof(uint16_t) - sizeof(uint16_t), SEEK_CUR);
break;
case TIFF_SOFTWARE_NAME:
ADD_METADATA(count, "software", NULL);
break;
+ case DNG_VERSION:
+ if (count == 4) {
+ unsigned int ver[4];
+ ver[0] = ff_tget(&s->gb, type, s->le);
+ ver[1] = ff_tget(&s->gb, type, s->le);
+ ver[2] = ff_tget(&s->gb, type, s->le);
+ ver[3] = ff_tget(&s->gb, type, s->le);
+
+ av_log(s->avctx, AV_LOG_DEBUG, "DNG file, version %u.%u.%u.%u\n",
+ ver[0], ver[1], ver[2], ver[3]);
+
+ tiff_set_type(s, TIFF_TYPE_DNG);
+ }
+ break;
+ case CINEMADNG_TIME_CODES:
+ case CINEMADNG_FRAME_RATE:
+ case CINEMADNG_T_STOP:
+ case CINEMADNG_REEL_NAME:
+ case CINEMADNG_CAMERA_LABEL:
+ tiff_set_type(s, TIFF_TYPE_CINEMADNG);
+ break;
default:
if (s->avctx->err_recognition & AV_EF_EXPLODE) {
av_log(s->avctx, AV_LOG_ERROR,
uint8_t *dst;
GetByteContext stripsizes;
GetByteContext stripdata;
+ int retry_for_subifd, retry_for_page;
bytestream2_init(&s->gb, avpkt->data, avpkt->size);
s->le = le;
// TIFF_BPP is not a required tag and defaults to 1
again:
+ s->is_thumbnail = 0;
s->bppcount = s->bpp = 1;
s->photometric = TIFF_PHOTOMETRIC_NONE;
s->compr = TIFF_RAW;
s->fill_order = 0;
s->white_level = 0;
s->is_bayer = 0;
+ s->cur_page = 0;
+ s->tiff_type = TIFF_TYPE_TIFF;
free_geotags(s);
// Reset these offsets so we can tell if they were set this frame
return ret;
}
- if (s->sub_ifd && s->get_subimage) {
+ if (s->get_thumbnail && !s->is_thumbnail) {
+ av_log(avctx, AV_LOG_INFO, "No embedded thumbnail present\n");
+ return AVERROR_EOF;
+ }
+
+ /** whether we should process this IFD's SubIFD */
+ retry_for_subifd = s->sub_ifd && (s->get_subimage || (!s->get_thumbnail && s->is_thumbnail));
+ /** whether we should process this multi-page IFD's next page */
+ retry_for_page = s->get_page && s->cur_page + 1 < s->get_page; // get_page is 1-indexed
+
+ if (retry_for_page) {
+ // set offset to the next IFD
+ off = ff_tget_long(&s->gb, le);
+ } else if (retry_for_subifd) {
+ // set offset to the SubIFD
off = s->sub_ifd;
+ }
+
+ if (retry_for_subifd || retry_for_page) {
if (off >= UINT_MAX - 14 || avpkt->size < off + 14) {
av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
return AVERROR_INVALIDDATA;
planes = s->planar ? s->bppcount : 1;
for (plane = 0; plane < planes; plane++) {
+ uint8_t *five_planes = NULL;
int remaining = avpkt->size;
int decoded_height;
stride = p->linesize[plane];
dst = p->data[plane];
+ if (s->photometric == TIFF_PHOTOMETRIC_SEPARATED &&
+ s->avctx->pix_fmt == AV_PIX_FMT_RGBA) {
+ stride = stride * 5 / 4;
+ five_planes =
+ dst = av_malloc(stride * s->height);
+ if (!dst)
+ return AVERROR(ENOMEM);
+ }
for (i = 0; i < s->height; i += s->rps) {
if (i)
dst += s->rps * stride;
if (soff > avpkt->size || ssize > avpkt->size - soff || ssize > remaining) {
av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
+ av_freep(&five_planes);
return AVERROR_INVALIDDATA;
}
remaining -= ssize;
if ((ret = tiff_unpack_strip(s, p, dst, stride, avpkt->data + soff, ssize, i,
FFMIN(s->rps, s->height - i))) < 0) {
- if (avctx->err_recognition & AV_EF_EXPLODE)
+ if (avctx->err_recognition & AV_EF_EXPLODE) {
+ av_freep(&five_planes);
return ret;
+ }
break;
}
}
av_log(s->avctx, AV_LOG_ERROR, "predictor == 2 with YUV is unsupported");
return AVERROR_PATCHWELCOME;
}
- dst = p->data[plane];
+ dst = five_planes ? five_planes : p->data[plane];
soff = s->bpp >> 3;
if (s->planar)
soff = FFMAX(soff / s->bppcount, 1);
}
if (s->photometric == TIFF_PHOTOMETRIC_SEPARATED &&
- s->avctx->pix_fmt == AV_PIX_FMT_RGB0) {
+ (s->avctx->pix_fmt == AV_PIX_FMT_RGB0 || s->avctx->pix_fmt == AV_PIX_FMT_RGBA)) {
+ int x = s->avctx->pix_fmt == AV_PIX_FMT_RGB0 ? 4 : 5;
+ uint8_t *src = five_planes ? five_planes : p->data[plane];
dst = p->data[plane];
for (i = 0; i < s->height; i++) {
for (j = 0; j < s->width; j++) {
- int k = 255 - dst[4 * j + 3];
- int r = (255 - dst[4 * j ]) * k;
- int g = (255 - dst[4 * j + 1]) * k;
- int b = (255 - dst[4 * j + 2]) * k;
+ int k = 255 - src[x * j + 3];
+ int r = (255 - src[x * j ]) * k;
+ int g = (255 - src[x * j + 1]) * k;
+ int b = (255 - src[x * j + 2]) * k;
dst[4 * j ] = r * 257 >> 16;
dst[4 * j + 1] = g * 257 >> 16;
dst[4 * j + 2] = b * 257 >> 16;
- dst[4 * j + 3] = 255;
+ dst[4 * j + 3] = s->avctx->pix_fmt == AV_PIX_FMT_RGBA ? src[x * j + 4] : 255;
+ }
+ src += stride;
+ dst += p->linesize[plane];
+ }
+ av_freep(&five_planes);
+ } else if (s->photometric == TIFF_PHOTOMETRIC_SEPARATED &&
+ s->avctx->pix_fmt == AV_PIX_FMT_RGBA64BE) {
+ dst = p->data[plane];
+ for (i = 0; i < s->height; i++) {
+ for (j = 0; j < s->width; j++) {
+ uint64_t k = 65535 - AV_RB16(dst + 8 * j + 6);
+ uint64_t r = (65535 - AV_RB16(dst + 8 * j )) * k;
+ uint64_t g = (65535 - AV_RB16(dst + 8 * j + 2)) * k;
+ uint64_t b = (65535 - AV_RB16(dst + 8 * j + 4)) * k;
+ AV_WB16(dst + 8 * j , r * 65537 >> 32);
+ AV_WB16(dst + 8 * j + 2, g * 65537 >> 32);
+ AV_WB16(dst + 8 * j + 4, b * 65537 >> 32);
+ AV_WB16(dst + 8 * j + 6, 65535);
}
dst += p->linesize[plane];
}
#define OFFSET(x) offsetof(TiffContext, x)
static const AVOption tiff_options[] = {
{ "subimage", "decode subimage instead if available", OFFSET(get_subimage), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM },
+ { "thumbnail", "decode embedded thumbnail subimage instead if available", OFFSET(get_thumbnail), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM },
+ { "page", "page number of multi-page image to decode (starting from 1)", OFFSET(get_page), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM },
{ NULL },
};
projects / ffmpeg / blobdiff