00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00027 #include "avcodec.h"
00028 #include "bytestream.h"
00029 #include "config.h"
00030 #if CONFIG_ZLIB
00031 #include <zlib.h>
00032 #endif
00033 #include "lzw.h"
00034 #include "tiff.h"
00035 #include "tiff_data.h"
00036 #include "faxcompr.h"
00037 #include "internal.h"
00038 #include "mathops.h"
00039 #include "libavutil/attributes.h"
00040 #include "libavutil/intreadwrite.h"
00041 #include "libavutil/imgutils.h"
00042 #include "libavutil/avstring.h"
00043
00044 typedef struct TiffContext {
00045 AVCodecContext *avctx;
00046 AVFrame picture;
00047 GetByteContext gb;
00048
00049 int width, height;
00050 unsigned int bpp, bppcount;
00051 uint32_t palette[256];
00052 int palette_is_set;
00053 int le;
00054 enum TiffCompr compr;
00055 int invert;
00056 int fax_opts;
00057 int predictor;
00058 int fill_order;
00059
00060 int strips, rps, sstype;
00061 int sot;
00062 int stripsizesoff, stripsize, stripoff, strippos;
00063 LZWState *lzw;
00064
00065 int geotag_count;
00066 TiffGeoTag *geotags;
00067 } TiffContext;
00068
00069 static unsigned tget_short(GetByteContext *gb, int le)
00070 {
00071 unsigned v = le ? bytestream2_get_le16(gb) : bytestream2_get_be16(gb);
00072 return v;
00073 }
00074
00075 static unsigned tget_long(GetByteContext *gb, int le)
00076 {
00077 unsigned v = le ? bytestream2_get_le32(gb) : bytestream2_get_be32(gb);
00078 return v;
00079 }
00080
00081 static double tget_double(GetByteContext *gb, int le)
00082 {
00083 av_alias64 i = { .u64 = le ? bytestream2_get_le64(gb) : bytestream2_get_be64(gb)};
00084 return i.f64;
00085 }
00086
00087 static unsigned tget(GetByteContext *gb, int type, int le)
00088 {
00089 switch (type) {
00090 case TIFF_BYTE : return bytestream2_get_byte(gb);
00091 case TIFF_SHORT: return tget_short(gb, le);
00092 case TIFF_LONG : return tget_long(gb, le);
00093 default : return UINT_MAX;
00094 }
00095 }
00096
00097 static void free_geotags(TiffContext *const s)
00098 {
00099 int i;
00100 for (i = 0; i < s->geotag_count; i++) {
00101 if (s->geotags[i].val)
00102 av_freep(&s->geotags[i].val);
00103 }
00104 av_freep(&s->geotags);
00105 }
00106
00107 #define RET_GEOKEY(TYPE, array, element)\
00108 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
00109 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_name_type_map))\
00110 return ff_tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element;
00111
00112 static const char *get_geokey_name(int key)
00113 {
00114 RET_GEOKEY(VERT, vert, name);
00115 RET_GEOKEY(PROJ, proj, name);
00116 RET_GEOKEY(GEOG, geog, name);
00117 RET_GEOKEY(CONF, conf, name);
00118
00119 return NULL;
00120 }
00121
00122 static int get_geokey_type(int key)
00123 {
00124 RET_GEOKEY(VERT, vert, type);
00125 RET_GEOKEY(PROJ, proj, type);
00126 RET_GEOKEY(GEOG, geog, type);
00127 RET_GEOKEY(CONF, conf, type);
00128
00129 return AVERROR_INVALIDDATA;
00130 }
00131
00132 static int cmp_id_key(const void *id, const void *k)
00133 {
00134 return *(const int*)id - ((const TiffGeoTagKeyName*)k)->key;
00135 }
00136
00137 static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id)
00138 {
00139 return ((TiffGeoTagKeyName*)bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key))->name;
00140 }
00141
00142 static char *get_geokey_val(int key, int val)
00143 {
00144 char *ap;
00145
00146 if (val == TIFF_GEO_KEY_UNDEFINED)
00147 return av_strdup("undefined");
00148 if (val == TIFF_GEO_KEY_USER_DEFINED)
00149 return av_strdup("User-Defined");
00150
00151 #define RET_GEOKEY_VAL(TYPE, array)\
00152 if (val >= TIFF_##TYPE##_OFFSET &&\
00153 val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\
00154 return av_strdup(ff_tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]);
00155
00156 switch (key) {
00157 case TIFF_GT_MODEL_TYPE_GEOKEY:
00158 RET_GEOKEY_VAL(GT_MODEL_TYPE, gt_model_type);
00159 break;
00160 case TIFF_GT_RASTER_TYPE_GEOKEY:
00161 RET_GEOKEY_VAL(GT_RASTER_TYPE, gt_raster_type);
00162 break;
00163 case TIFF_GEOG_LINEAR_UNITS_GEOKEY:
00164 case TIFF_PROJ_LINEAR_UNITS_GEOKEY:
00165 case TIFF_VERTICAL_UNITS_GEOKEY:
00166 RET_GEOKEY_VAL(LINEAR_UNIT, linear_unit);
00167 break;
00168 case TIFF_GEOG_ANGULAR_UNITS_GEOKEY:
00169 case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY:
00170 RET_GEOKEY_VAL(ANGULAR_UNIT, angular_unit);
00171 break;
00172 case TIFF_GEOGRAPHIC_TYPE_GEOKEY:
00173 RET_GEOKEY_VAL(GCS_TYPE, gcs_type);
00174 RET_GEOKEY_VAL(GCSE_TYPE, gcse_type);
00175 break;
00176 case TIFF_GEOG_GEODETIC_DATUM_GEOKEY:
00177 RET_GEOKEY_VAL(GEODETIC_DATUM, geodetic_datum);
00178 RET_GEOKEY_VAL(GEODETIC_DATUM_E, geodetic_datum_e);
00179 break;
00180 case TIFF_GEOG_ELLIPSOID_GEOKEY:
00181 RET_GEOKEY_VAL(ELLIPSOID, ellipsoid);
00182 break;
00183 case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY:
00184 RET_GEOKEY_VAL(PRIME_MERIDIAN, prime_meridian);
00185 break;
00186 case TIFF_PROJECTED_CS_TYPE_GEOKEY:
00187 return av_strdup(search_keyval(ff_tiff_proj_cs_type_codes, FF_ARRAY_ELEMS(ff_tiff_proj_cs_type_codes), val));
00188 break;
00189 case TIFF_PROJECTION_GEOKEY:
00190 return av_strdup(search_keyval(ff_tiff_projection_codes, FF_ARRAY_ELEMS(ff_tiff_projection_codes), val));
00191 break;
00192 case TIFF_PROJ_COORD_TRANS_GEOKEY:
00193 RET_GEOKEY_VAL(COORD_TRANS, coord_trans);
00194 break;
00195 case TIFF_VERTICAL_CS_TYPE_GEOKEY:
00196 RET_GEOKEY_VAL(VERT_CS, vert_cs);
00197 RET_GEOKEY_VAL(ORTHO_VERT_CS, ortho_vert_cs);
00198 break;
00199
00200 }
00201
00202 ap = av_malloc(14);
00203 if (ap)
00204 snprintf(ap, 14, "Unknown-%d", val);
00205 return ap;
00206 }
00207
00208 static char *doubles2str(double *dp, int count, const char *sep)
00209 {
00210 int i;
00211 char *ap, *ap0;
00212 int component_len;
00213 if (!sep) sep = ", ";
00214 component_len = 15 + strlen(sep);
00215 ap = av_malloc(component_len * count);
00216 if (!ap)
00217 return NULL;
00218 ap0 = ap;
00219 ap[0] = '\0';
00220 for (i = 0; i < count; i++) {
00221 unsigned l = snprintf(ap, component_len, "%f%s", dp[i], sep);
00222 if(l >= component_len) {
00223 av_free(ap0);
00224 return NULL;
00225 }
00226 ap += l;
00227 }
00228 ap0[strlen(ap0) - strlen(sep)] = '\0';
00229 return ap0;
00230 }
00231
00232 static char *shorts2str(int16_t *sp, int count, const char *sep)
00233 {
00234 int i;
00235 char *ap, *ap0;
00236 if (!sep) sep = ", ";
00237 ap = av_malloc((5 + strlen(sep)) * count);
00238 if (!ap)
00239 return NULL;
00240 ap0 = ap;
00241 ap[0] = '\0';
00242 for (i = 0; i < count; i++) {
00243 int l = snprintf(ap, 5 + strlen(sep), "%d%s", sp[i], sep);
00244 ap += l;
00245 }
00246 ap0[strlen(ap0) - strlen(sep)] = '\0';
00247 return ap0;
00248 }
00249
00250 static int add_doubles_metadata(int count,
00251 const char *name, const char *sep,
00252 TiffContext *s)
00253 {
00254 char *ap;
00255 int i;
00256 double *dp;
00257
00258 if (count >= INT_MAX / sizeof(int64_t) || count <= 0)
00259 return AVERROR_INVALIDDATA;
00260 if (bytestream2_get_bytes_left(&s->gb) < count * sizeof(int64_t))
00261 return AVERROR_INVALIDDATA;
00262
00263 dp = av_malloc(count * sizeof(double));
00264 if (!dp)
00265 return AVERROR(ENOMEM);
00266
00267 for (i = 0; i < count; i++)
00268 dp[i] = tget_double(&s->gb, s->le);
00269 ap = doubles2str(dp, count, sep);
00270 av_freep(&dp);
00271 if (!ap)
00272 return AVERROR(ENOMEM);
00273 av_dict_set(&s->picture.metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
00274 return 0;
00275 }
00276
00277 static int add_shorts_metadata(int count, const char *name,
00278 const char *sep, TiffContext *s)
00279 {
00280 char *ap;
00281 int i;
00282 int16_t *sp;
00283
00284 if (count >= INT_MAX / sizeof(int16_t) || count <= 0)
00285 return AVERROR_INVALIDDATA;
00286 if (bytestream2_get_bytes_left(&s->gb) < count * sizeof(int16_t))
00287 return AVERROR_INVALIDDATA;
00288
00289 sp = av_malloc(count * sizeof(int16_t));
00290 if (!sp)
00291 return AVERROR(ENOMEM);
00292
00293 for (i = 0; i < count; i++)
00294 sp[i] = tget_short(&s->gb, s->le);
00295 ap = shorts2str(sp, count, sep);
00296 av_freep(&sp);
00297 if (!ap)
00298 return AVERROR(ENOMEM);
00299 av_dict_set(&s->picture.metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
00300 return 0;
00301 }
00302
00303 static int add_string_metadata(int count, const char *name,
00304 TiffContext *s)
00305 {
00306 char *value;
00307
00308 if (bytestream2_get_bytes_left(&s->gb) < count)
00309 return AVERROR_INVALIDDATA;
00310
00311 value = av_malloc(count + 1);
00312 if (!value)
00313 return AVERROR(ENOMEM);
00314
00315 bytestream2_get_bufferu(&s->gb, value, count);
00316 value[count] = 0;
00317
00318 av_dict_set(&s->picture.metadata, name, value, AV_DICT_DONT_STRDUP_VAL);
00319 return 0;
00320 }
00321
00322 static int add_metadata(int count, int type,
00323 const char *name, const char *sep, TiffContext *s)
00324 {
00325 switch(type) {
00326 case TIFF_DOUBLE: return add_doubles_metadata(count, name, sep, s);
00327 case TIFF_SHORT : return add_shorts_metadata(count, name, sep, s);
00328 case TIFF_STRING: return add_string_metadata(count, name, s);
00329 default : return AVERROR_INVALIDDATA;
00330 };
00331 }
00332
00333 #if CONFIG_ZLIB
00334 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
00335 int size)
00336 {
00337 z_stream zstream = { 0 };
00338 int zret;
00339
00340 zstream.next_in = (uint8_t *)src;
00341 zstream.avail_in = size;
00342 zstream.next_out = dst;
00343 zstream.avail_out = *len;
00344 zret = inflateInit(&zstream);
00345 if (zret != Z_OK) {
00346 av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
00347 return zret;
00348 }
00349 zret = inflate(&zstream, Z_SYNC_FLUSH);
00350 inflateEnd(&zstream);
00351 *len = zstream.total_out;
00352 return zret == Z_STREAM_END ? Z_OK : zret;
00353 }
00354 #endif
00355
00356 static void av_always_inline horizontal_fill(unsigned int bpp, uint8_t* dst,
00357 int usePtr, const uint8_t *src,
00358 uint8_t c, int width, int offset)
00359 {
00360 switch (bpp) {
00361 case 1:
00362 while (--width >= 0) {
00363 dst[(width+offset)*8+7] = (usePtr ? src[width] : c) & 0x1;
00364 dst[(width+offset)*8+6] = (usePtr ? src[width] : c) >> 1 & 0x1;
00365 dst[(width+offset)*8+5] = (usePtr ? src[width] : c) >> 2 & 0x1;
00366 dst[(width+offset)*8+4] = (usePtr ? src[width] : c) >> 3 & 0x1;
00367 dst[(width+offset)*8+3] = (usePtr ? src[width] : c) >> 4 & 0x1;
00368 dst[(width+offset)*8+2] = (usePtr ? src[width] : c) >> 5 & 0x1;
00369 dst[(width+offset)*8+1] = (usePtr ? src[width] : c) >> 6 & 0x1;
00370 dst[(width+offset)*8+0] = (usePtr ? src[width] : c) >> 7;
00371 }
00372 break;
00373 case 2:
00374 while (--width >= 0) {
00375 dst[(width+offset)*4+3] = (usePtr ? src[width] : c) & 0x3;
00376 dst[(width+offset)*4+2] = (usePtr ? src[width] : c) >> 2 & 0x3;
00377 dst[(width+offset)*4+1] = (usePtr ? src[width] : c) >> 4 & 0x3;
00378 dst[(width+offset)*4+0] = (usePtr ? src[width] : c) >> 6;
00379 }
00380 break;
00381 case 4:
00382 while (--width >= 0) {
00383 dst[(width+offset)*2+1] = (usePtr ? src[width] : c) & 0xF;
00384 dst[(width+offset)*2+0] = (usePtr ? src[width] : c) >> 4;
00385 }
00386 break;
00387 default:
00388 if (usePtr) {
00389 memcpy(dst + offset, src, width);
00390 } else {
00391 memset(dst + offset, c, width);
00392 }
00393 }
00394 }
00395
00396 static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
00397 const uint8_t *src, int size, int lines)
00398 {
00399 int c, line, pixels, code;
00400 const uint8_t *ssrc = src;
00401 int width = ((s->width * s->bpp) + 7) >> 3;
00402
00403 if (size <= 0)
00404 return AVERROR_INVALIDDATA;
00405
00406 #if CONFIG_ZLIB
00407 if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
00408 uint8_t *src2 = NULL, *zbuf;
00409 unsigned long outlen;
00410 int i, ret;
00411 outlen = width * lines;
00412 zbuf = av_malloc(outlen);
00413 if (!zbuf)
00414 return AVERROR(ENOMEM);
00415 if (s->fill_order) {
00416 src2 = av_malloc((unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE);
00417 if (!src2) {
00418 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
00419 av_free(zbuf);
00420 return AVERROR(ENOMEM);
00421 }
00422 for (i = 0; i < size; i++)
00423 src2[i] = ff_reverse[src[i]];
00424 memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00425 src = src2;
00426 }
00427 ret = tiff_uncompress(zbuf, &outlen, src, size);
00428 if (ret != Z_OK) {
00429 av_log(s->avctx, AV_LOG_ERROR,
00430 "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
00431 (unsigned long)width * lines, ret);
00432 av_free(src2);
00433 av_free(zbuf);
00434 return -1;
00435 }
00436 src = zbuf;
00437 for (line = 0; line < lines; line++) {
00438 if(s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8){
00439 horizontal_fill(s->bpp, dst, 1, src, 0, width, 0);
00440 }else{
00441 memcpy(dst, src, width);
00442 }
00443 dst += stride;
00444 src += width;
00445 }
00446 av_free(src2);
00447 av_free(zbuf);
00448 return 0;
00449 }
00450 #endif
00451 if (s->compr == TIFF_LZW) {
00452 if (ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0) {
00453 av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
00454 return -1;
00455 }
00456 }
00457 if (s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3
00458 || s->compr == TIFF_G4) {
00459 int i, ret = 0;
00460 uint8_t *src2 = av_malloc((unsigned)size +
00461 FF_INPUT_BUFFER_PADDING_SIZE);
00462
00463 if (!src2) {
00464 av_log(s->avctx, AV_LOG_ERROR,
00465 "Error allocating temporary buffer\n");
00466 return AVERROR(ENOMEM);
00467 }
00468 if (s->fax_opts & 2) {
00469 av_log(s->avctx, AV_LOG_ERROR,
00470 "Uncompressed fax mode is not supported (yet)\n");
00471 av_free(src2);
00472 return -1;
00473 }
00474 if (!s->fill_order) {
00475 memcpy(src2, src, size);
00476 } else {
00477 for (i = 0; i < size; i++)
00478 src2[i] = ff_reverse[src[i]];
00479 }
00480 memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00481 switch (s->compr) {
00482 case TIFF_CCITT_RLE:
00483 case TIFF_G3:
00484 case TIFF_G4:
00485 ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride,
00486 s->compr, s->fax_opts);
00487 break;
00488 }
00489 if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
00490 for (line = 0; line < lines; line++) {
00491 horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0);
00492 dst += stride;
00493 }
00494 av_free(src2);
00495 return ret;
00496 }
00497 for (line = 0; line < lines; line++) {
00498 if (src - ssrc > size) {
00499 av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
00500 return -1;
00501 }
00502 switch (s->compr) {
00503 case TIFF_RAW:
00504 if (ssrc + size - src < width)
00505 return AVERROR_INVALIDDATA;
00506 if (!s->fill_order) {
00507 horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),
00508 dst, 1, src, 0, width, 0);
00509 } else {
00510 int i;
00511 for (i = 0; i < width; i++)
00512 dst[i] = ff_reverse[src[i]];
00513 }
00514 src += width;
00515 break;
00516 case TIFF_PACKBITS:
00517 for (pixels = 0; pixels < width;) {
00518 if (ssrc + size - src < 2) {
00519 av_log(s->avctx, AV_LOG_ERROR, "Read went out of bounds\n");
00520 return AVERROR_INVALIDDATA;
00521 }
00522 code = (int8_t) * src++;
00523 if (code >= 0) {
00524 code++;
00525 if (pixels + code > width) {
00526 av_log(s->avctx, AV_LOG_ERROR,
00527 "Copy went out of bounds\n");
00528 return -1;
00529 }
00530 if (ssrc + size - src < code) {
00531 av_log(s->avctx, AV_LOG_ERROR, "Read went out of bounds\n");
00532 return AVERROR_INVALIDDATA;
00533 }
00534 horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),
00535 dst, 1, src, 0, code, pixels);
00536 src += code;
00537 pixels += code;
00538 } else if (code != -128) {
00539 code = (-code) + 1;
00540 if (pixels + code > width) {
00541 av_log(s->avctx, AV_LOG_ERROR,
00542 "Run went out of bounds\n");
00543 return -1;
00544 }
00545 c = *src++;
00546 horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),
00547 dst, 0, NULL, c, code, pixels);
00548 pixels += code;
00549 }
00550 }
00551 break;
00552 case TIFF_LZW:
00553 pixels = ff_lzw_decode(s->lzw, dst, width);
00554 if (pixels < width) {
00555 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",
00556 pixels, width);
00557 return -1;
00558 }
00559 if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
00560 horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0);
00561 break;
00562 }
00563 dst += stride;
00564 }
00565 return 0;
00566 }
00567
00568 static int init_image(TiffContext *s)
00569 {
00570 int i, ret;
00571 uint32_t *pal;
00572
00573 switch (s->bpp * 10 + s->bppcount) {
00574 case 11:
00575 if (!s->palette_is_set) {
00576 s->avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
00577 break;
00578 }
00579 case 21:
00580 case 41:
00581 case 81:
00582 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
00583 break;
00584 case 243:
00585 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
00586 break;
00587 case 161:
00588 s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GRAY16LE : AV_PIX_FMT_GRAY16BE;
00589 break;
00590 case 162:
00591 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8A;
00592 break;
00593 case 324:
00594 s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
00595 break;
00596 case 483:
00597 s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGB48BE;
00598 break;
00599 case 644:
00600 s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGBA64LE : AV_PIX_FMT_RGBA64BE;
00601 break;
00602 default:
00603 av_log(s->avctx, AV_LOG_ERROR,
00604 "This format is not supported (bpp=%d, bppcount=%d)\n",
00605 s->bpp, s->bppcount);
00606 return AVERROR_INVALIDDATA;
00607 }
00608 if (s->width != s->avctx->width || s->height != s->avctx->height) {
00609 if ((ret = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
00610 return ret;
00611 avcodec_set_dimensions(s->avctx, s->width, s->height);
00612 }
00613 if (s->picture.data[0])
00614 s->avctx->release_buffer(s->avctx, &s->picture);
00615 if ((ret = ff_get_buffer(s->avctx, &s->picture)) < 0) {
00616 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00617 return ret;
00618 }
00619 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
00620 if (s->palette_is_set) {
00621 memcpy(s->picture.data[1], s->palette, sizeof(s->palette));
00622 } else {
00623
00624 pal = (uint32_t *) s->picture.data[1];
00625 for (i = 0; i < 1<<s->bpp; i++)
00626 pal[i] = 0xFFU << 24 | i * 255 / ((1<<s->bpp) - 1) * 0x010101;
00627 }
00628 }
00629 return 0;
00630 }
00631
00632 static int tiff_decode_tag(TiffContext *s)
00633 {
00634 unsigned tag, type, count, off, value = 0;
00635 int i, j, k, pos, start;
00636 int ret;
00637 uint32_t *pal;
00638 double *dp;
00639
00640 tag = tget_short(&s->gb, s->le);
00641 type = tget_short(&s->gb, s->le);
00642 count = tget_long(&s->gb, s->le);
00643 off = tget_long(&s->gb, s->le);
00644 start = bytestream2_tell(&s->gb);
00645
00646 if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
00647 av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n",
00648 type);
00649 return 0;
00650 }
00651
00652 if (count == 1) {
00653 switch (type) {
00654 case TIFF_BYTE:
00655 case TIFF_SHORT:
00656 bytestream2_seek(&s->gb, -4, SEEK_CUR);
00657 value = tget(&s->gb, type, s->le);
00658 break;
00659 case TIFF_LONG:
00660 value = off;
00661 break;
00662 case TIFF_STRING:
00663 if (count <= 4) {
00664 bytestream2_seek(&s->gb, -4, SEEK_CUR);
00665 break;
00666 }
00667 default:
00668 value = UINT_MAX;
00669 bytestream2_seek(&s->gb, off, SEEK_SET);
00670 }
00671 } else {
00672 if (count <= 4 && type_sizes[type] * count <= 4) {
00673 bytestream2_seek(&s->gb, -4, SEEK_CUR);
00674 } else {
00675 bytestream2_seek(&s->gb, off, SEEK_SET);
00676 }
00677 }
00678
00679 switch (tag) {
00680 case TIFF_WIDTH:
00681 s->width = value;
00682 break;
00683 case TIFF_HEIGHT:
00684 s->height = value;
00685 break;
00686 case TIFF_BPP:
00687 s->bppcount = count;
00688 if (count > 4) {
00689 av_log(s->avctx, AV_LOG_ERROR,
00690 "This format is not supported (bpp=%d, %d components)\n",
00691 s->bpp, count);
00692 return -1;
00693 }
00694 if (count == 1)
00695 s->bpp = value;
00696 else {
00697 switch (type) {
00698 case TIFF_BYTE:
00699 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) +
00700 ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
00701 break;
00702 case TIFF_SHORT:
00703 case TIFF_LONG:
00704 s->bpp = 0;
00705 if (bytestream2_get_bytes_left(&s->gb) < type_sizes[type] * count)
00706 return -1;
00707 for (i = 0; i < count; i++)
00708 s->bpp += tget(&s->gb, type, s->le);
00709 break;
00710 default:
00711 s->bpp = -1;
00712 }
00713 }
00714 break;
00715 case TIFF_SAMPLES_PER_PIXEL:
00716 if (count != 1) {
00717 av_log(s->avctx, AV_LOG_ERROR,
00718 "Samples per pixel requires a single value, many provided\n");
00719 return AVERROR_INVALIDDATA;
00720 }
00721 if (s->bppcount == 1)
00722 s->bpp *= value;
00723 s->bppcount = value;
00724 break;
00725 case TIFF_COMPR:
00726 s->compr = value;
00727 s->predictor = 0;
00728 switch (s->compr) {
00729 case TIFF_RAW:
00730 case TIFF_PACKBITS:
00731 case TIFF_LZW:
00732 case TIFF_CCITT_RLE:
00733 break;
00734 case TIFF_G3:
00735 case TIFF_G4:
00736 s->fax_opts = 0;
00737 break;
00738 case TIFF_DEFLATE:
00739 case TIFF_ADOBE_DEFLATE:
00740 #if CONFIG_ZLIB
00741 break;
00742 #else
00743 av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
00744 return -1;
00745 #endif
00746 case TIFF_JPEG:
00747 case TIFF_NEWJPEG:
00748 av_log(s->avctx, AV_LOG_ERROR,
00749 "JPEG compression is not supported\n");
00750 return -1;
00751 default:
00752 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n",
00753 s->compr);
00754 return -1;
00755 }
00756 break;
00757 case TIFF_ROWSPERSTRIP:
00758 if (type == TIFF_LONG && value == UINT_MAX)
00759 value = s->avctx->height;
00760 if (value < 1) {
00761 av_log(s->avctx, AV_LOG_ERROR,
00762 "Incorrect value of rows per strip\n");
00763 return -1;
00764 }
00765 s->rps = value;
00766 break;
00767 case TIFF_STRIP_OFFS:
00768 if (count == 1) {
00769 s->strippos = 0;
00770 s->stripoff = value;
00771 } else
00772 s->strippos = off;
00773 s->strips = count;
00774 if (s->strips == 1)
00775 s->rps = s->height;
00776 s->sot = type;
00777 if (s->strippos > bytestream2_size(&s->gb)) {
00778 av_log(s->avctx, AV_LOG_ERROR,
00779 "Tag referencing position outside the image\n");
00780 return -1;
00781 }
00782 break;
00783 case TIFF_STRIP_SIZE:
00784 if (count == 1) {
00785 s->stripsizesoff = 0;
00786 s->stripsize = value;
00787 s->strips = 1;
00788 } else {
00789 s->stripsizesoff = off;
00790 }
00791 s->strips = count;
00792 s->sstype = type;
00793 if (s->stripsizesoff > bytestream2_size(&s->gb)) {
00794 av_log(s->avctx, AV_LOG_ERROR,
00795 "Tag referencing position outside the image\n");
00796 return -1;
00797 }
00798 break;
00799 case TIFF_TILE_BYTE_COUNTS:
00800 case TIFF_TILE_LENGTH:
00801 case TIFF_TILE_OFFSETS:
00802 case TIFF_TILE_WIDTH:
00803 av_log(s->avctx, AV_LOG_ERROR, "Tiled images are not supported\n");
00804 return AVERROR_PATCHWELCOME;
00805 break;
00806 case TIFF_PREDICTOR:
00807 s->predictor = value;
00808 break;
00809 case TIFF_INVERT:
00810 switch (value) {
00811 case 0:
00812 s->invert = 1;
00813 break;
00814 case 1:
00815 s->invert = 0;
00816 break;
00817 case 2:
00818 case 3:
00819 break;
00820 default:
00821 av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n",
00822 value);
00823 return -1;
00824 }
00825 break;
00826 case TIFF_FILL_ORDER:
00827 if (value < 1 || value > 2) {
00828 av_log(s->avctx, AV_LOG_ERROR,
00829 "Unknown FillOrder value %d, trying default one\n", value);
00830 value = 1;
00831 }
00832 s->fill_order = value - 1;
00833 break;
00834 case TIFF_PAL:
00835 pal = (uint32_t *) s->palette;
00836 off = type_sizes[type];
00837 if (count / 3 > 256 || bytestream2_get_bytes_left(&s->gb) < count / 3 * off * 3)
00838 return -1;
00839 off = (type_sizes[type] - 1) << 3;
00840 for (k = 2; k >= 0; k--) {
00841 for (i = 0; i < count / 3; i++) {
00842 if (k == 2)
00843 pal[i] = 0xFFU << 24;
00844 j = (tget(&s->gb, type, s->le) >> off) << (k * 8);
00845 pal[i] |= j;
00846 }
00847 }
00848 s->palette_is_set = 1;
00849 break;
00850 case TIFF_PLANAR:
00851 if (value == 2) {
00852 av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
00853 return -1;
00854 }
00855 break;
00856 case TIFF_T4OPTIONS:
00857 if (s->compr == TIFF_G3)
00858 s->fax_opts = value;
00859 break;
00860 case TIFF_T6OPTIONS:
00861 if (s->compr == TIFF_G4)
00862 s->fax_opts = value;
00863 break;
00864 #define ADD_METADATA(count, name, sep)\
00865 if (ret = add_metadata(count, type, name, sep, s) < 0) {\
00866 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
00867 return ret;\
00868 }
00869 case TIFF_MODEL_PIXEL_SCALE:
00870 ADD_METADATA(count, "ModelPixelScaleTag", NULL);
00871 break;
00872 case TIFF_MODEL_TRANSFORMATION:
00873 ADD_METADATA(count, "ModelTransformationTag", NULL);
00874 break;
00875 case TIFF_MODEL_TIEPOINT:
00876 ADD_METADATA(count, "ModelTiepointTag", NULL);
00877 break;
00878 case TIFF_GEO_KEY_DIRECTORY:
00879 ADD_METADATA(1, "GeoTIFF_Version", NULL);
00880 ADD_METADATA(2, "GeoTIFF_Key_Revision", ".");
00881 s->geotag_count = tget_short(&s->gb, s->le);
00882 if (s->geotag_count > count / 4 - 1) {
00883 s->geotag_count = count / 4 - 1;
00884 av_log(s->avctx, AV_LOG_WARNING, "GeoTIFF key directory buffer shorter than specified\n");
00885 }
00886 if (bytestream2_get_bytes_left(&s->gb) < s->geotag_count * sizeof(int16_t) * 4)
00887 return -1;
00888 s->geotags = av_mallocz(sizeof(TiffGeoTag) * s->geotag_count);
00889 if (!s->geotags) {
00890 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
00891 return AVERROR(ENOMEM);
00892 }
00893 for (i = 0; i < s->geotag_count; i++) {
00894 s->geotags[i].key = tget_short(&s->gb, s->le);
00895 s->geotags[i].type = tget_short(&s->gb, s->le);
00896 s->geotags[i].count = tget_short(&s->gb, s->le);
00897
00898 if (!s->geotags[i].type)
00899 s->geotags[i].val = get_geokey_val(s->geotags[i].key, tget_short(&s->gb, s->le));
00900 else
00901 s->geotags[i].offset = tget_short(&s->gb, s->le);
00902 }
00903 break;
00904 case TIFF_GEO_DOUBLE_PARAMS:
00905 if (count >= INT_MAX / sizeof(int64_t))
00906 return AVERROR_INVALIDDATA;
00907 if (bytestream2_get_bytes_left(&s->gb) < count * sizeof(int64_t))
00908 return AVERROR_INVALIDDATA;
00909 dp = av_malloc(count * sizeof(double));
00910 if (!dp) {
00911 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
00912 return AVERROR(ENOMEM);
00913 }
00914 for (i = 0; i < count; i++)
00915 dp[i] = tget_double(&s->gb, s->le);
00916 for (i = 0; i < s->geotag_count; i++) {
00917 if (s->geotags[i].type == TIFF_GEO_DOUBLE_PARAMS) {
00918 if (s->geotags[i].count == 0
00919 || s->geotags[i].offset + s->geotags[i].count > count) {
00920 av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);
00921 } else {
00922 char *ap = doubles2str(&dp[s->geotags[i].offset], s->geotags[i].count, ", ");
00923 if (!ap) {
00924 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
00925 av_freep(&dp);
00926 return AVERROR(ENOMEM);
00927 }
00928 s->geotags[i].val = ap;
00929 }
00930 }
00931 }
00932 av_freep(&dp);
00933 break;
00934 case TIFF_GEO_ASCII_PARAMS:
00935 pos = bytestream2_tell(&s->gb);
00936 for (i = 0; i < s->geotag_count; i++) {
00937 if (s->geotags[i].type == TIFF_GEO_ASCII_PARAMS) {
00938 if (s->geotags[i].count == 0
00939 || s->geotags[i].offset + s->geotags[i].count > count) {
00940 av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);
00941 } else {
00942 char *ap;
00943
00944 bytestream2_seek(&s->gb, pos + s->geotags[i].offset, SEEK_SET);
00945 if (bytestream2_get_bytes_left(&s->gb) < s->geotags[i].count)
00946 return -1;
00947 ap = av_malloc(s->geotags[i].count);
00948 if (!ap) {
00949 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
00950 return AVERROR(ENOMEM);
00951 }
00952 bytestream2_get_bufferu(&s->gb, ap, s->geotags[i].count);
00953 ap[s->geotags[i].count - 1] = '\0';
00954 s->geotags[i].val = ap;
00955 }
00956 }
00957 }
00958 break;
00959 case TIFF_ARTIST:
00960 ADD_METADATA(count, "artist", NULL);
00961 break;
00962 case TIFF_COPYRIGHT:
00963 ADD_METADATA(count, "copyright", NULL);
00964 break;
00965 case TIFF_DATE:
00966 ADD_METADATA(count, "date", NULL);
00967 break;
00968 case TIFF_DOCUMENT_NAME:
00969 ADD_METADATA(count, "document_name", NULL);
00970 break;
00971 case TIFF_HOST_COMPUTER:
00972 ADD_METADATA(count, "computer", NULL);
00973 break;
00974 case TIFF_IMAGE_DESCRIPTION:
00975 ADD_METADATA(count, "description", NULL);
00976 break;
00977 case TIFF_MAKE:
00978 ADD_METADATA(count, "make", NULL);
00979 break;
00980 case TIFF_MODEL:
00981 ADD_METADATA(count, "model", NULL);
00982 break;
00983 case TIFF_PAGE_NAME:
00984 ADD_METADATA(count, "page_name", NULL);
00985 break;
00986 case TIFF_PAGE_NUMBER:
00987 ADD_METADATA(count, "page_number", " / ");
00988 break;
00989 case TIFF_SOFTWARE_NAME:
00990 ADD_METADATA(count, "software", NULL);
00991 break;
00992 default:
00993 av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n",
00994 tag, tag);
00995 }
00996 bytestream2_seek(&s->gb, start, SEEK_SET);
00997 return 0;
00998 }
00999
01000 static int decode_frame(AVCodecContext *avctx,
01001 void *data, int *got_frame, AVPacket *avpkt)
01002 {
01003 TiffContext *const s = avctx->priv_data;
01004 AVFrame *picture = data;
01005 AVFrame *const p = &s->picture;
01006 unsigned off;
01007 int id, le, ret;
01008 int i, j, entries;
01009 int stride;
01010 unsigned soff, ssize;
01011 uint8_t *dst;
01012 GetByteContext stripsizes;
01013 GetByteContext stripdata;
01014
01015 bytestream2_init(&s->gb, avpkt->data, avpkt->size);
01016
01017
01018 if (avpkt->size < 8)
01019 return AVERROR_INVALIDDATA;
01020 id = bytestream2_get_le16u(&s->gb);
01021 if (id == 0x4949)
01022 le = 1;
01023 else if (id == 0x4D4D)
01024 le = 0;
01025 else {
01026 av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
01027 return -1;
01028 }
01029 s->le = le;
01030
01031 s->bppcount = s->bpp = 1;
01032 s->invert = 0;
01033 s->compr = TIFF_RAW;
01034 s->fill_order = 0;
01035 free_geotags(s);
01036
01037
01038 s->picture.metadata = NULL;
01039
01040
01041
01042 if (tget_short(&s->gb, le) != 42) {
01043 av_log(avctx, AV_LOG_ERROR,
01044 "The answer to life, universe and everything is not correct!\n");
01045 return -1;
01046 }
01047
01048 s->stripsizesoff = s->strippos = 0;
01049
01050 off = tget_long(&s->gb, le);
01051 if (off >= UINT_MAX - 14 || avpkt->size < off + 14) {
01052 av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
01053 return AVERROR_INVALIDDATA;
01054 }
01055 bytestream2_seek(&s->gb, off, SEEK_SET);
01056 entries = tget_short(&s->gb, le);
01057 if (bytestream2_get_bytes_left(&s->gb) < entries * 12)
01058 return AVERROR_INVALIDDATA;
01059 for (i = 0; i < entries; i++) {
01060 if (tiff_decode_tag(s) < 0)
01061 return -1;
01062 }
01063
01064 for (i = 0; i<s->geotag_count; i++) {
01065 const char *keyname = get_geokey_name(s->geotags[i].key);
01066 if (!keyname) {
01067 av_log(avctx, AV_LOG_WARNING, "Unknown or unsupported GeoTIFF key %d\n", s->geotags[i].key);
01068 continue;
01069 }
01070 if (get_geokey_type(s->geotags[i].key) != s->geotags[i].type) {
01071 av_log(avctx, AV_LOG_WARNING, "Type of GeoTIFF key %d is wrong\n", s->geotags[i].key);
01072 continue;
01073 }
01074 ret = av_dict_set(&s->picture.metadata, keyname, s->geotags[i].val, 0);
01075 if (ret<0) {
01076 av_log(avctx, AV_LOG_ERROR, "Writing metadata with key '%s' failed\n", keyname);
01077 return ret;
01078 }
01079 }
01080
01081 if (!s->strippos && !s->stripoff) {
01082 av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
01083 return -1;
01084 }
01085
01086 if ((ret = init_image(s)) < 0)
01087 return ret;
01088
01089 if (s->strips == 1 && !s->stripsize) {
01090 av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
01091 s->stripsize = avpkt->size - s->stripoff;
01092 }
01093 stride = p->linesize[0];
01094 dst = p->data[0];
01095
01096 if (s->stripsizesoff) {
01097 if (s->stripsizesoff >= (unsigned)avpkt->size)
01098 return AVERROR_INVALIDDATA;
01099 bytestream2_init(&stripsizes, avpkt->data + s->stripsizesoff, avpkt->size - s->stripsizesoff);
01100 }
01101 if (s->strippos) {
01102 if (s->strippos >= (unsigned)avpkt->size)
01103 return AVERROR_INVALIDDATA;
01104 bytestream2_init(&stripdata, avpkt->data + s->strippos, avpkt->size - s->strippos);
01105 }
01106
01107 if (s->rps <= 0) {
01108 av_log(avctx, AV_LOG_ERROR, "rps %d invalid\n", s->rps);
01109 return AVERROR_INVALIDDATA;
01110 }
01111
01112 for (i = 0; i < s->height; i += s->rps) {
01113 if (s->stripsizesoff)
01114 ssize = tget(&stripsizes, s->sstype, s->le);
01115 else
01116 ssize = s->stripsize;
01117
01118 if (s->strippos)
01119 soff = tget(&stripdata, s->sot, s->le);
01120 else
01121 soff = s->stripoff;
01122
01123 if (soff > avpkt->size || ssize > avpkt->size - soff) {
01124 av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
01125 return -1;
01126 }
01127 if (tiff_unpack_strip(s, dst, stride, avpkt->data + soff, ssize,
01128 FFMIN(s->rps, s->height - i)) < 0)
01129 break;
01130 dst += s->rps * stride;
01131 }
01132 if (s->predictor == 2) {
01133 dst = p->data[0];
01134 soff = s->bpp >> 3;
01135 ssize = s->width * soff;
01136 if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48LE ||
01137 s->avctx->pix_fmt == AV_PIX_FMT_RGBA64LE) {
01138 for (i = 0; i < s->height; i++) {
01139 for (j = soff; j < ssize; j += 2)
01140 AV_WL16(dst + j, AV_RL16(dst + j) + AV_RL16(dst + j - soff));
01141 dst += stride;
01142 }
01143 } else if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
01144 s->avctx->pix_fmt == AV_PIX_FMT_RGBA64BE) {
01145 for (i = 0; i < s->height; i++) {
01146 for (j = soff; j < ssize; j += 2)
01147 AV_WB16(dst + j, AV_RB16(dst + j) + AV_RB16(dst + j - soff));
01148 dst += stride;
01149 }
01150 } else {
01151 for (i = 0; i < s->height; i++) {
01152 for (j = soff; j < ssize; j++)
01153 dst[j] += dst[j - soff];
01154 dst += stride;
01155 }
01156 }
01157 }
01158
01159 if (s->invert) {
01160 dst = s->picture.data[0];
01161 for (i = 0; i < s->height; i++) {
01162 for (j = 0; j < s->picture.linesize[0]; j++)
01163 dst[j] = (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 ? (1<<s->bpp) - 1 : 255) - dst[j];
01164 dst += s->picture.linesize[0];
01165 }
01166 }
01167 *picture = s->picture;
01168 *got_frame = 1;
01169
01170 return avpkt->size;
01171 }
01172
01173 static av_cold int tiff_init(AVCodecContext *avctx)
01174 {
01175 TiffContext *s = avctx->priv_data;
01176
01177 s->width = 0;
01178 s->height = 0;
01179 s->avctx = avctx;
01180 avcodec_get_frame_defaults(&s->picture);
01181 avctx->coded_frame = &s->picture;
01182 ff_lzw_decode_open(&s->lzw);
01183 ff_ccitt_unpack_init();
01184
01185 return 0;
01186 }
01187
01188 static av_cold int tiff_end(AVCodecContext *avctx)
01189 {
01190 TiffContext *const s = avctx->priv_data;
01191
01192 free_geotags(s);
01193
01194 ff_lzw_decode_close(&s->lzw);
01195 if (s->picture.data[0])
01196 avctx->release_buffer(avctx, &s->picture);
01197 return 0;
01198 }
01199
01200 AVCodec ff_tiff_decoder = {
01201 .name = "tiff",
01202 .type = AVMEDIA_TYPE_VIDEO,
01203 .id = AV_CODEC_ID_TIFF,
01204 .priv_data_size = sizeof(TiffContext),
01205 .init = tiff_init,
01206 .close = tiff_end,
01207 .decode = decode_frame,
01208 .capabilities = CODEC_CAP_DR1,
01209 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
01210 };