Go to the documentation of this file.
32 #define LZMA_API_STATIC
125 static const float d65_white[3] = { 0.950456f, 1.f, 1.088754f };
128 if (
s->tiff_type < tiff_type)
129 s->tiff_type = tiff_type;
135 for (
i = 0;
i <
s->geotag_count;
i++) {
136 if (
s->geotags[
i].val)
143 #define RET_GEOKEY(TYPE, array, element)\
144 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
145 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\
146 return tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element;
191 #define RET_GEOKEY_VAL(TYPE, array)\
192 if (val >= TIFF_##TYPE##_OFFSET &&\
193 val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_codes))\
194 return av_strdup(tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]);
254 uint64_t component_len;
255 if (!sep) sep =
", ";
256 component_len = 24LL + strlen(sep);
257 if (count >= (INT_MAX - 1)/component_len)
259 ap =
av_malloc(component_len * count + 1);
264 for (
i = 0;
i < count;
i++) {
265 unsigned l =
snprintf(ap, component_len,
"%.15g%s", dp[
i], sep);
266 if(l >= component_len) {
272 ap0[strlen(ap0) - strlen(sep)] =
'\0';
302 value_norm = ((
float)
value - black_level) * scale_factor;
319 int is_single_comp,
int is_u16,
int odd_line)
321 float scale_factor[4];
325 for (
int i = 0;
i < 4;
i++)
326 scale_factor[
i] =
s->premultiply[
s->pattern[
i]] * 65535.f / (
s->white_level -
s->black_level[
i]);
328 for (
int i = 0;
i < 4;
i++)
329 scale_factor[
i] =
s->premultiply[
i ] * 65535.f / (
s->white_level -
s->black_level[
i]);
332 if (is_single_comp) {
339 uint16_t *dst_u16 = (uint16_t *)dst;
340 const uint16_t *src_u16 = (
const uint16_t *)
src;
343 for (col = 0; col <
width; col++)
344 *dst_u16++ =
dng_process_color16(*src_u16++,
s->dng_lut,
s->black_level[col&1], scale_factor[col&1]);
347 dst += dst_stride *
sizeof(uint16_t);
348 dst_u16 = (uint16_t *)dst;
351 for (col = 0; col <
width; col++)
352 *dst_u16++ =
dng_process_color16(*src_u16++,
s->dng_lut,
s->black_level[(col&1) + 2], scale_factor[(col&1) + 2]);
354 dst += dst_stride *
sizeof(uint16_t);
355 src += src_stride *
sizeof(uint16_t);
362 uint16_t *dst_u16 = (uint16_t *)dst;
363 const uint16_t *src_u16 = (
const uint16_t *)
src;
365 for (col = 0; col <
width; col++)
367 s->black_level[(col&1) + 2 * ((
line&1) + odd_line)],
368 scale_factor[(col&1) + 2 * ((
line&1) + odd_line)]);
370 dst += dst_stride *
sizeof(uint16_t);
371 src += src_stride *
sizeof(uint16_t);
375 uint8_t *dst_u8 = dst;
376 const uint8_t *src_u8 =
src;
378 for (col = 0; col <
width; col++)
380 s->black_level[(col&1) + 2 * ((
line&1) + odd_line)],
381 scale_factor[(col&1) + 2 * ((
line&1) + odd_line)]);
391 unsigned int bpp, uint8_t* dst,
392 int usePtr,
const uint8_t *
src,
397 while (--
width >= 0) {
409 while (--
width >= 0) {
417 while (--
width >= 0) {
425 uint16_t *dst16 = (uint16_t *)dst;
427 uint8_t
shift = is_dng ? 0 : 16 - bpp;
431 for (
int i = 0;
i <
s->width;
i++) {
450 if (!
s->deinvert_buf)
459 const uint8_t *
src,
int lnum,
int width,
int bpp)
462 uint16_t *dst = (uint16_t *)(p->
data[0] + lnum * p->
linesize[0]);
466 for (
int i = 0;
i <
s->width;
i++) {
472 const uint8_t *
src,
int lnum)
475 int w = (
s->width - 1) /
s->subsampling[0] + 1;
476 uint8_t *pu = &p->
data[1][lnum /
s->subsampling[1] * p->
linesize[1]];
478 if (
s->width %
s->subsampling[0] ||
s->height %
s->subsampling[1]) {
479 for (
i = 0;
i <
w;
i++) {
480 for (j = 0; j <
s->subsampling[1]; j++)
481 for (k = 0; k <
s->subsampling[0]; k++)
483 FFMIN(
i *
s->subsampling[0] + k,
s->width-1)] = *
src++;
488 for (
i = 0;
i <
w;
i++) {
489 for (j = 0; j <
s->subsampling[1]; j++)
490 for (k = 0; k <
s->subsampling[0]; k++)
492 i *
s->subsampling[0] + k] = *
src++;
500 static int tiff_uncompress(uint8_t *dst,
unsigned long *
len,
const uint8_t *
src,
503 z_stream zstream = { 0 };
506 zstream.next_in =
src;
507 zstream.avail_in =
size;
508 zstream.next_out = dst;
509 zstream.avail_out = *
len;
510 zret = inflateInit(&zstream);
515 zret =
inflate(&zstream, Z_SYNC_FLUSH);
516 inflateEnd(&zstream);
517 *
len = zstream.total_out;
518 return zret == Z_STREAM_END ? Z_OK : zret;
523 int strip_start,
int is_yuv)
526 unsigned long outlen;
528 outlen =
width * lines;
537 src =
s->deinvert_buf;
539 ret = tiff_uncompress(zbuf, &outlen,
src,
size);
542 "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
556 line +=
s->subsampling[1] - 1;
567 static int tiff_uncompress_lzma(uint8_t *dst, uint64_t *
len,
const uint8_t *
src,
570 lzma_stream stream = LZMA_STREAM_INIT;
573 stream.next_in =
src;
574 stream.avail_in =
size;
575 stream.next_out = dst;
576 stream.avail_out = *
len;
577 ret = lzma_stream_decoder(&stream, UINT64_MAX, 0);
578 if (
ret != LZMA_OK) {
582 ret = lzma_code(&stream, LZMA_RUN);
584 *
len = stream.total_out;
585 return ret == LZMA_STREAM_END ? LZMA_OK :
ret;
590 int strip_start,
int is_yuv)
592 uint64_t outlen =
width * (uint64_t)lines;
602 src =
s->deinvert_buf;
604 ret = tiff_uncompress_lzma(buf, &outlen,
src,
size);
605 if (
ret != LZMA_OK) {
607 "Uncompressing failed (%"PRIu64
" of %"PRIu64
") with error %d\n", outlen,
621 line +=
s->subsampling[1] - 1;
640 src =
s->deinvert_buf;
643 s->compr,
s->fax_opts);
653 int tile_byte_count,
int dst_x,
int dst_y,
int w,
int h)
656 uint8_t *dst_data, *src_data;
658 int is_single_comp, is_u16, pixel_size;
666 s->jpkt->data = (uint8_t*)
s->gb.buffer;
667 s->jpkt->size = tile_byte_count;
673 mjpegdecctx->
bayer = 1;
693 is_u16 = (
s->bpp > 8);
697 if (
s->jpgframe->width !=
s->avctx_mjpeg->width ||
698 s->jpgframe->height !=
s->avctx_mjpeg->height ||
699 s->jpgframe->format !=
s->avctx_mjpeg->pix_fmt)
703 if (
s->avctx_mjpeg->width ==
w * 2 &&
704 s->avctx_mjpeg->height ==
h / 2 &&
707 }
else if (
s->avctx_mjpeg->width >=
w &&
708 s->avctx_mjpeg->height >=
h &&
715 pixel_size = (is_u16 ?
sizeof(uint16_t) :
sizeof(uint8_t));
717 if (is_single_comp && !is_u16) {
723 dst_offset = dst_x +
frame->
linesize[0] * dst_y / pixel_size;
724 dst_data =
frame->
data[0] + dst_offset * pixel_size;
725 src_data =
s->jpgframe->data[0];
731 s->jpgframe->linesize[0] / pixel_size,
743 const uint8_t *
src,
int size,
int strip_start,
int lines)
747 const uint8_t *ssrc =
src;
748 int width = ((
s->width *
s->bpp) + 7) >> 3;
752 desc->nb_components >= 3;
762 int bytes_per_row = (((
s->width - 1) /
s->subsampling[0] + 1) *
s->bpp *
763 s->subsampling[0] *
s->subsampling[1] + 7) >> 3;
765 if (
s->yuv_line ==
NULL) {
772 width = (
s->width - 1) /
s->subsampling[0] + 1;
783 if (
s->yuv_line ==
NULL) {
794 strip_start, is_yuv);
797 "zlib support not enabled, "
798 "deflate compression not supported\n");
805 strip_start, is_yuv);
808 "LZMA support not enabled\n");
816 ssrc =
src =
s->deinvert_buf;
827 if (pixels <
width) {
836 line +=
s->subsampling[1] - 1;
871 if (is_dng &&
stride == 0)
888 if (!
s->fill_order) {
899 int is_u16, pixel_size_bytes, pixel_size_bits,
elements;
901 is_u16 = (
s->bpp /
s->bppcount > 8);
902 pixel_size_bits = (is_u16 ? 16 : 8);
903 pixel_size_bytes = (is_u16 ?
sizeof(uint16_t) :
sizeof(uint8_t));
905 elements =
width / pixel_size_bytes * pixel_size_bits /
s->bpp *
s->bppcount;
916 (
line + strip_start)&1);
922 for (pixels = 0; pixels <
width;) {
933 "Copy went out of bounds\n");
940 }
else if (
code != -128) {
944 "Run went out of bounds\n");
962 line +=
s->subsampling[1] - 1;
976 int tile_offset_offset, tile_offset;
977 int tile_byte_count_offset, tile_byte_count;
978 int tile_count_x, tile_count_y;
979 int tile_width, tile_length;
980 int has_width_leftover, has_height_leftover;
981 int tile_x = 0, tile_y = 0;
982 int pos_x = 0, pos_y = 0;
985 if (
s->tile_width <= 0 ||
s->tile_length <= 0)
988 has_width_leftover = (
s->width %
s->tile_width != 0);
989 has_height_leftover = (
s->height %
s->tile_length != 0);
992 tile_count_x = (
s->width +
s->tile_width - 1) /
s->tile_width;
993 tile_count_y = (
s->height +
s->tile_length - 1) /
s->tile_length;
996 for (tile_idx = 0; tile_idx < tile_count_x * tile_count_y; tile_idx++) {
997 tile_x = tile_idx % tile_count_x;
998 tile_y = tile_idx / tile_count_x;
1000 if (has_width_leftover && tile_x == tile_count_x - 1)
1001 tile_width =
s->width %
s->tile_width;
1003 tile_width =
s->tile_width;
1005 if (has_height_leftover && tile_y == tile_count_y - 1)
1006 tile_length =
s->height %
s->tile_length;
1008 tile_length =
s->tile_length;
1011 tile_offset_offset =
s->tile_offsets_offset + tile_idx *
sizeof(
int);
1016 tile_byte_count_offset =
s->tile_byte_counts_offset + tile_idx *
sizeof(
int);
1030 pos_x += tile_width;
1031 if (tile_x == tile_count_x - 1) {
1033 pos_y += tile_length;
1047 int create_gray_palette = 0;
1050 if (
s->bpp > 128 ||
s->bppcount >= 10) {
1052 "Unsupported image parameters: bpp=%d, bppcount=%d\n",
1053 s->bpp,
s->bppcount);
1057 switch (
s->planar * 10000 +
s->bpp * 10 +
s->bppcount +
s->is_bayer * 100000) {
1059 if (!
s->palette_is_set) {
1066 if (!
s->palette_is_set) {
1067 create_gray_palette = 1;
1121 if (
s->subsampling[0] == 1 &&
s->subsampling[1] == 1) {
1123 }
else if (
s->subsampling[0] == 2 &&
s->subsampling[1] == 1) {
1125 }
else if (
s->subsampling[0] == 4 &&
s->subsampling[1] == 1) {
1127 }
else if (
s->subsampling[0] == 1 &&
s->subsampling[1] == 2) {
1129 }
else if (
s->subsampling[0] == 2 &&
s->subsampling[1] == 2) {
1131 }
else if (
s->subsampling[0] == 4 &&
s->subsampling[1] == 4) {
1157 "bpp=40 without PHOTOMETRIC_SEPARATED is unsupported\n");
1193 "This format is not supported (bpp=%d, bppcount=%d)\n",
1194 s->bpp,
s->bppcount);
1202 desc->nb_components < 3) {
1208 if (
s->width !=
s->avctx->width ||
s->height !=
s->avctx->height) {
1220 if (!create_gray_palette)
1221 memcpy(
frame->
data[1],
s->palette,
sizeof(
s->palette));
1225 uint32_t *pal = (uint32_t *)
frame->
data[1];
1226 for (
i = 0;
i < 1<<
s->bpp;
i++)
1227 pal[
i] = 0xFFU << 24 |
i * 255 / ((1<<
s->bpp) - 1) * 0x010101;
1238 if (
s->res[0] &&
s->res[1] &&
s->res[2] &&
s->res[3]) {
1239 uint64_t num =
s->res[2] * (uint64_t)
s->res[1];
1240 uint64_t den =
s->res[0] * (uint64_t)
s->res[3];
1241 if (num > INT64_MAX || den > INT64_MAX) {
1245 av_reduce(&
s->avctx->sample_aspect_ratio.num, &
s->avctx->sample_aspect_ratio.den,
1246 num, den, INT32_MAX);
1247 if (!
s->avctx->sample_aspect_ratio.den)
1248 s->avctx->sample_aspect_ratio = (
AVRational) {0, 1};
1266 if (tag <= s->last_tag)
1301 s->is_thumbnail = (
value != 0);
1310 if (count > 5 || count <= 0) {
1312 "This format is not supported (bpp=%d, %d components)\n",
1316 s->bppcount = count;
1327 for (
i = 0;
i < count;
i++)
1338 "Samples per pixel requires a single value, many provided\n");
1343 "Invalid samples per pixel %d\n",
value);
1346 if (
s->bppcount == 1)
1396 if (
value > INT_MAX) {
1398 "strippos %u too large\n",
value);
1406 if (
s->strips ==
s->bppcount)
1412 if (
value > INT_MAX) {
1414 "stripsize %u too large\n",
value);
1417 s->stripsizesoff = 0;
1421 s->stripsizesoff = off;
1431 s->tile_offsets_offset = off;
1435 s->tile_byte_counts_offset = off;
1456 for (
int i = 0;
i < count;
i++)
1458 s->white_level =
s->dng_lut[count-1];
1464 for (
int i = 0; i < count && count > 1;
i++) {
1487 for (
int i = count; i < 4 && count > 0;
i++)
1488 s->black_level[
i] =
s->black_level[count - 1];
1526 "PhotometricInterpretation 0x%04X",
1531 "unknown\n",
value);
1536 if (value < 1 || value > 2) {
1538 "Unknown FillOrder value %d, trying default one\n",
value);
1541 s->fill_order =
value - 1;
1546 if (count / 3 > 256 ||
1550 pal_gb[0] = pal_gb[1] = pal_gb[2] =
s->gb;
1560 for (
i = 0;
i < count / 3;
i++) {
1561 uint32_t p = 0xFF000000;
1567 s->palette_is_set = 1;
1578 for (
i = 0;
i < count;
i++) {
1580 if (
s->subsampling[
i] <= 0) {
1582 s->subsampling[
i] = 1;
1595 #define ADD_METADATA(count, name, sep)\
1596 if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\
1597 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
1610 if (
s->geotag_count) {
1617 if (
s->geotag_count > count / 4 - 1) {
1618 s->geotag_count = count / 4 - 1;
1622 ||
s->geotag_count == 0) {
1623 s->geotag_count = 0;
1626 s->geotags =
av_calloc(
s->geotag_count,
sizeof(*
s->geotags));
1629 s->geotag_count = 0;
1632 for (
i = 0;
i <
s->geotag_count;
i++) {
1637 if (!
s->geotags[
i].type)
1644 if (count >= INT_MAX /
sizeof(int64_t))
1653 for (
i = 0;
i < count;
i++)
1655 for (
i = 0;
i <
s->geotag_count;
i++) {
1657 if (
s->geotags[
i].count == 0
1658 ||
s->geotags[
i].offset +
s->geotags[
i].count > count) {
1660 }
else if (
s->geotags[
i].val) {
1663 char *ap =
doubles2str(&dp[
s->geotags[
i].offset],
s->geotags[
i].count,
", ");
1669 s->geotags[
i].val = ap;
1677 for (
i = 0;
i <
s->geotag_count;
i++) {
1679 if (
s->geotags[
i].count == 0
1680 ||
s->geotags[
i].offset +
s->geotags[
i].count > count) {
1688 if (
s->geotags[
i].val)
1696 ap[
s->geotags[
i].count - 1] =
'\0';
1697 s->geotags[
i].val = ap;
1749 bytestream2_seek(&
s->gb, count *
sizeof(uint16_t) -
sizeof(uint16_t), SEEK_CUR);
1756 unsigned int ver[4];
1763 ver[0], ver[1], ver[2], ver[3]);
1772 for (
int i = 0;
i < 3;
i++) {
1787 for (
int i = 0;
i < 3;
i++) {
1802 for (
int i = 0;
i < 2;
i++) {
1812 s->as_shot_white[2] = 1.f -
s->as_shot_white[0] -
s->as_shot_white[1];
1813 for (
int i = 0;
i < 3;
i++) {
1819 for (
int i = 0;
i < 3;
i++) {
1820 for (
int j = 0; j < 3; j++) {
1829 s->use_color_matrix = 1;
1834 for (
int i = 0;
i < 3;
i++) {
1835 for (
int j = 0; j < 3; j++) {
1856 "Unknown or unsupported tag %d/0x%0X\n",
1862 if (
s->bpp > 128
U) {
1864 "This format is not supported (bpp=%d, %d components)\n",
1874 { 0.412453f, 0.357580f, 0.180423f },
1875 { 0.212671f, 0.715160f, 0.072169f },
1876 { 0.019334f, 0.119193f, 0.950227f },
1880 float rgb2cam[3][4],
1881 double cam2xyz[4][3])
1883 double cam2rgb[4][3], num;
1886 for (
i = 0;
i < 3;
i++) {
1887 for (j = 0; j < 3; j++) {
1889 for (k = 0; k < 3; k++)
1890 cam2rgb[
i][j] += cam2xyz[
i][k] *
xyz2rgb[k][j];
1894 for (
i = 0;
i < 3;
i++) {
1895 for (num = j = 0; j < 3; j++)
1896 num += cam2rgb[
i][j];
1899 for (j = 0; j < 3; j++)
1900 cam2rgb[
i][j] /= num;
1901 s->premultiply[
i] = 1.f / num;
1909 unsigned off, last_off = 0;
1912 unsigned soff, ssize;
1916 int retry_for_subifd, retry_for_page;
1918 int has_tile_bits, has_strip_bits;
1926 }
else if (off >= UINT_MAX - 14 || avpkt->
size < off + 14) {
1934 s->use_color_matrix = 0;
1936 s->is_thumbnail = 0;
1937 s->bppcount =
s->bpp = 1;
1948 for (
i = 0;
i < 65536;
i++)
1952 s->black_level[
i] = 0.f;
1955 s->as_shot_neutral[
i] = 0.f;
1958 s->as_shot_white[
i] = 1.f;
1961 s->analog_balance[
i] = 1.f;
1964 s->premultiply[
i] = 1.f;
1967 for (j = 0; j < 4; j++)
1968 s->camera_calibration[
i][j] =
i == j;
1973 s->stripsizesoff =
s->strippos = 0;
1979 for (
i = 0;
i < entries;
i++) {
1984 if (
s->get_thumbnail && !
s->is_thumbnail) {
1990 retry_for_subifd =
s->sub_ifd && (
s->get_subimage || (!
s->get_thumbnail &&
s->is_thumbnail));
1992 retry_for_page =
s->get_page &&
s->cur_page + 1 <
s->get_page;
1994 if (retry_for_page) {
1997 }
else if (retry_for_subifd) {
2002 if (retry_for_subifd || retry_for_page) {
2007 if (off <= last_off) {
2012 if (off >= UINT_MAX - 14 || avpkt->
size < off + 14) {
2024 for (
i = 0;
i<
s->geotag_count;
i++) {
2042 double cam2xyz[4][3];
2043 float cmatrix[3][4];
2044 float pmin = FLT_MAX;
2047 for (
i = 0;
i < 3;
i++) {
2048 for (j = 0; j < 3; j++)
2049 s->camera_calibration[
i][j] *=
s->analog_balance[
i];
2052 if (!
s->use_color_matrix) {
2053 for (
i = 0;
i < 3;
i++) {
2054 if (
s->camera_calibration[
i][
i])
2055 s->premultiply[
i] /=
s->camera_calibration[
i][
i];
2058 for (
int c = 0;
c < 3;
c++) {
2059 for (
i = 0;
i < 3;
i++) {
2061 for (j = 0; j < 3; j++)
2062 cam2xyz[
c][
i] +=
s->camera_calibration[
c][j] *
s->color_matrix[j][
i] *
s->as_shot_white[
i];
2069 for (
int c = 0;
c < 3;
c++)
2070 pmin =
fminf(pmin,
s->premultiply[
c]);
2072 for (
int c = 0;
c < 3;
c++)
2073 s->premultiply[
c] /= pmin;
2075 if (
s->bpp %
s->bppcount)
2077 bps =
s->bpp /
s->bppcount;
2078 if (bps < 8 || bps > 32)
2081 if (
s->white_level == 0)
2082 s->white_level = (1LL <<
bps) - 1;
2084 if (
s->white_level <=
s->black_level[0]) {
2085 av_log(avctx,
AV_LOG_ERROR,
"BlackLevel (%g) must be less than WhiteLevel (%"PRId32
")\n",
2086 s->black_level[0],
s->white_level);
2094 if (!
s->is_tiled && !
s->strippos && !
s->stripoff) {
2099 has_tile_bits =
s->is_tiled ||
s->tile_byte_counts_offset ||
s->tile_offsets_offset ||
s->tile_width ||
s->tile_length;
2100 has_strip_bits =
s->strippos ||
s->strips ||
s->stripoff ||
s->rps ||
s->sot ||
s->sstype ||
s->stripsize ||
s->stripsizesoff;
2102 if (has_tile_bits && has_strip_bits) {
2103 int tiled_dng =
s->is_tiled && is_dng;
2113 if (!
s->is_tiled || has_strip_bits) {
2114 if (
s->strips == 1 && !
s->stripsize) {
2116 s->stripsize = avpkt->
size -
s->stripoff;
2119 if (
s->stripsizesoff) {
2120 if (
s->stripsizesoff >= (
unsigned)avpkt->
size)
2123 avpkt->
size -
s->stripsizesoff);
2126 if (
s->strippos >= (
unsigned)avpkt->
size)
2129 avpkt->
size -
s->strippos);
2132 if (
s->rps <= 0 ||
s->rps %
s->subsampling[1]) {
2147 if (is_dng &&
s->is_tiled) {
2151 }
else if (!
s->is_bayer) {
2163 planes =
s->planar ?
s->bppcount : 1;
2164 for (plane = 0; plane <
planes; plane++) {
2165 uint8_t *five_planes =
NULL;
2166 int remaining = avpkt->
size;
2169 dst = p->
data[plane];
2178 for (
i = 0;
i <
s->height;
i +=
s->rps) {
2181 if (
s->stripsizesoff)
2182 ssize =
ff_tget(&stripsizes,
s->sstype, le);
2184 ssize =
s->stripsize;
2187 soff =
ff_tget(&stripdata,
s->sot, le);
2191 if (soff > avpkt->
size || ssize > avpkt->
size - soff || ssize > remaining) {
2198 FFMIN(
s->rps,
s->height -
i))) < 0) {
2206 decoded_height =
FFMIN(
i,
s->height);
2208 if (
s->predictor == 2) {
2213 dst = five_planes ? five_planes : p->
data[plane];
2216 soff =
FFMAX(soff /
s->bppcount, 1);
2217 ssize =
s->width * soff;
2224 for (
i = 0;
i < decoded_height;
i++) {
2225 for (j = soff; j < ssize; j += 2)
2235 for (
i = 0;
i < decoded_height;
i++) {
2236 for (j = soff; j < ssize; j += 2)
2241 for (
i = 0;
i < decoded_height;
i++) {
2242 for (j = soff; j < ssize; j++)
2243 dst[j] += dst[j - soff];
2251 if (
s->predictor == 3) {
2257 dst = five_planes ? five_planes : p->
data[plane];
2260 soff =
FFMAX(soff /
s->bppcount, 1);
2263 ssize =
s->width * soff;
2264 bpc =
FFMAX(soff /
s->bppcount, 1);
2273 for (
i = 0;
i < decoded_height;
i++) {
2280 tmpbuf[j] = dst[j] + tmpbuf[j-
channels];
2287 for (j = 0; j < group_size; j++) {
2288 for (
int k = 0; k < bpc; k++) {
2289 dst[bpc * j + k] = tmpbuf[(bpc - k - 1) * group_size + j];
2297 for (
i = 0;
i < decoded_height;
i++) {
2302 tmpbuf[j] = dst[j] + tmpbuf[j-
channels];
2304 for (j = 0; j < group_size; j++) {
2305 for (
int k = 0; k < bpc; k++) {
2306 dst[bpc * j + k] = tmpbuf[k * group_size + j];
2319 dst = p->
data[plane];
2320 for (
i = 0;
i <
s->height;
i++) {
2321 for (j = 0; j <
stride; j++)
2322 dst[j] =
c - dst[j];
2330 uint8_t *
src = five_planes ? five_planes : p->
data[plane];
2331 dst = p->
data[plane];
2332 for (
i = 0;
i <
s->height;
i++) {
2333 for (j = 0; j <
s->width; j++) {
2334 int k = 255 -
src[x * j + 3];
2335 int r = (255 -
src[x * j ]) * k;
2336 int g = (255 -
src[x * j + 1]) * k;
2337 int b = (255 -
src[x * j + 2]) * k;
2338 dst[4 * j ] =
r * 257 >> 16;
2339 dst[4 * j + 1] =
g * 257 >> 16;
2340 dst[4 * j + 2] =
b * 257 >> 16;
2349 dst = p->
data[plane];
2350 for (
i = 0;
i <
s->height;
i++) {
2351 for (j = 0; j <
s->width; j++) {
2352 uint64_t k = 65535 -
AV_RB16(dst + 8 * j + 6);
2353 uint64_t
r = (65535 -
AV_RB16(dst + 8 * j )) * k;
2354 uint64_t
g = (65535 -
AV_RB16(dst + 8 * j + 2)) * k;
2355 uint64_t
b = (65535 -
AV_RB16(dst + 8 * j + 4)) * k;
2356 AV_WB16(dst + 8 * j ,
r * 65537 >> 32);
2357 AV_WB16(dst + 8 * j + 2,
g * 65537 >> 32);
2358 AV_WB16(dst + 8 * j + 4,
b * 65537 >> 32);
2359 AV_WB16(dst + 8 * j + 6, 65535);
2366 if (
s->planar &&
s->bppcount > 2) {
2373 if (
s->is_bayer &&
s->white_level &&
s->bpp == 16 && !is_dng) {
2374 uint16_t *dst = (uint16_t *)p->
data[0];
2375 for (
i = 0;
i <
s->height;
i++) {
2376 for (j = 0; j <
s->width; j++)
2377 dst[j] =
FFMIN((dst[j] / (
float)
s->white_level) * 65535, 65535);
2397 s->subsampling[1] = 1;
2407 if (!
s->jpgframe || !
s->jpkt)
2415 if (!
s->avctx_mjpeg)
2417 s->avctx_mjpeg->flags = avctx->
flags;
2418 s->avctx_mjpeg->flags2 = avctx->
flags2;
2419 s->avctx_mjpeg->dct_algo = avctx->
dct_algo;
2420 s->avctx_mjpeg->idct_algo = avctx->
idct_algo;
2438 s->deinvert_buf_size = 0;
2440 s->yuv_line_size = 0;
2447 #define OFFSET(x) offsetof(TiffContext, x)
enum AVColorTransferCharacteristic color_trc
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int ff_tadd_string_metadata(int count, const char *name, GetByteContext *gb, int le, AVDictionary **metadata)
Adds a string of count characters into the metadata dictionary.
#define AV_LOG_WARNING
Something somehow does not look correct.
@ TIFF_GEOG_LINEAR_UNITS_GEOKEY
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
const FFCodec ff_tiff_decoder
#define AV_EF_EXPLODE
abort decoding on minor error detection
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
static int get_geokey_type(int key)
#define AV_OPT_FLAG_VIDEO_PARAM
static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
static const ElemCat * elements[ELEMENT_COUNT]
@ TIFF_PHOTOMETRIC_ICC_LAB
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
static char * get_geokey_val(int key, int val)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AVERROR_EOF
End of file.
static void camera_xyz_coeff(TiffContext *s, float rgb2cam[3][4], double cam2xyz[4][3])
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
@ TIFF_PROJ_COORD_TRANS_GEOKEY
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
static char * doubles2str(double *dp, int count, const char *sep)
static const TiffGeoTagKeyName tiff_projection_codes[]
@ TIFF_GEOG_AZIMUTH_UNITS_GEOKEY
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
This structure describes decoded (raw) audio or video data.
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
static av_cold int tiff_end(AVCodecContext *avctx)
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
@ TIFF_PHOTOMETRIC_ITU_LAB
const uint8_t ff_reverse[256]
#define RET_GEOKEY_VAL(TYPE, array)
static int deinvert_buffer(TiffContext *s, const uint8_t *src, int size)
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
int ff_lzw_decode(LZWState *p, uint8_t *buf, int len)
Decode given number of bytes NOTE: the algorithm here is inspired from the LZW GIF decoder written by...
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
@ TIFF_GEOG_ELLIPSOID_GEOKEY
#define TIFF_GEO_KEY_USER_DEFINED
@ TIFF_PROJ_LINEAR_UNITS_GEOKEY
av_cold void ff_lzw_decode_close(LZWState **p)
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
#define AV_PIX_FMT_BAYER_GRBG16
@ TIFF_PHOTOMETRIC_WHITE_IS_ZERO
@ TIFF_GEOG_PRIME_MERIDIAN_GEOKEY
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static uint16_t av_always_inline dng_process_color16(uint16_t value, const uint16_t *lut, float black_level, float scale_factor)
Map stored raw sensor values into linear reference values (see: DNG Specification - Chapter 5)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in FFCodec caps_internal and use ff_thread_get_buffer() to allocate frames. Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
#define TIFF_GEO_KEY_UNDEFINED
static const AVOption tiff_options[]
@ TIFF_PHOTOMETRIC_LINEAR_RAW
@ TIFF_PHOTOMETRIC_ALPHA_MASK
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int ff_ccitt_unpack(AVCodecContext *avctx, const uint8_t *src, int srcsize, uint8_t *dst, int height, int stride, enum TiffCompr compr, int opts)
unpack data compressed with CCITT Group 3 1/2-D or Group 4 method
AVCodec p
The public AVCodec.
static void unpack_yuv(TiffContext *s, AVFrame *p, const uint8_t *src, int lnum)
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
static void tiff_set_type(TiffContext *s, enum TiffType tiff_type)
static int dng_decode_tiles(AVCodecContext *avctx, AVFrame *frame, const AVPacket *avpkt)
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
@ TIFF_GEOG_GEODETIC_DATUM_GEOKEY
int flags
AV_CODEC_FLAG_*.
static double val(void *priv, double ch)
static void av_always_inline horizontal_fill(TiffContext *s, unsigned int bpp, uint8_t *dst, int usePtr, const uint8_t *src, uint8_t c, int width, int offset)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
int dct_algo
DCT algorithm, see FF_DCT_* below.
@ TIFF_VERTICAL_CS_TYPE_GEOKEY
#define AV_PIX_FMT_GRAY16
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
@ DNG_LINEARIZATION_TABLE
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
@ TIFF_GRAY_RESPONSE_CURVE
#define FF_ARRAY_ELEMS(a)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
float camera_calibration[4][4]
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
#define FF_CODEC_DECODE_CB(func)
static const TiffGeoTagKeyName tiff_proj_cs_type_codes[]
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
@ AV_PIX_FMT_BAYER_BGGR8
bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
TiffType
TIFF types in ascenting priority (last in the list is highest)
av_cold void ff_lzw_decode_open(LZWState **p)
int(* init)(AVBSFContext *ctx)
float fminf(float, float)
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
@ TIFF_GEOGRAPHIC_TYPE_GEOKEY
static int dng_decode_jpeg(AVCodecContext *avctx, AVFrame *frame, int tile_byte_count, int dst_x, int dst_y, int w, int h)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int ff_tadd_shorts_metadata(int count, const char *name, const char *sep, GetByteContext *gb, int le, int is_signed, AVDictionary **metadata)
Adds count shorts converted to a string into the metadata dictionary.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
int64_t max_pixels
The number of pixels per image to maximally accept.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define CODEC_LONG_NAME(str)
enum TiffPhotometric photometric
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
static const char * search_keyval(const TiffGeoTagKeyName *keys, int n, int id)
@ AV_PIX_FMT_BAYER_RGGB8
bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define AV_PIX_FMT_BAYER_BGGR16
static uint16_t av_always_inline dng_process_color8(uint16_t value, const uint16_t *lut, float black_level, float scale_factor)
av_cold void ff_ccitt_unpack_init(void)
initialize unpacker code
@ TIFF_VERTICAL_UNITS_GEOKEY
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
@ AVDISCARD_ALL
discard all
static av_cold int tiff_init(AVCodecContext *avctx)
#define LIBAVUTIL_VERSION_INT
unsigned ff_tget_short(GetByteContext *gb, int le)
Reads a short from the bytestream using given endianness.
Describe the class of an AVClass context structure.
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Rational number (pair of numerator and denominator).
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
@ TIFF_PHOTOMETRIC_PALETTE
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
@ AV_PICTURE_TYPE_I
Intra.
@ TIFF_PHOTOMETRIC_CIE_LAB
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
#define AV_PIX_FMT_BAYER_GBRG16
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline int bytestream2_tell(GetByteContext *g)
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
int ff_tread_tag(GetByteContext *gb, int le, unsigned *tag, unsigned *type, unsigned *count, int *next)
Reads the first 3 fields of a TIFF tag, which are the tag id, the tag type and the count of values fo...
@ AV_PIX_FMT_RGBF32BE
IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian.
int flags2
AV_CODEC_FLAG2_*.
enum AVPictureType pict_type
Picture type of the frame.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
@ TIFF_TYPE_CINEMADNG
Digital Negative (DNG) image part of an CinemaDNG image sequence.
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
static int shift(int a, int b)
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
@ DNG_CAMERA_CALIBRATION1
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
static const float xyz2rgb[3][3]
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
@ TIFF_GT_MODEL_TYPE_GEOKEY
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
@ TIFF_MODEL_TRANSFORMATION
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
static int cmp_id_key(const void *id, const void *k)
#define AV_LOG_INFO
Standard information.
static const AVClass tiff_decoder_class
#define RET_GEOKEY(TYPE, array, element)
@ TIFF_PHOTOMETRIC_LOG_LUV
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
static int decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
#define i(width, name, range_min, range_max)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
unsigned ff_tget_long(GetByteContext *gb, int le)
Reads a long from the bytestream using given endianness.
@ TIFF_PHOTOMETRIC_BLACK_IS_ZERO
int ff_lzw_decode_init(LZWState *p, int csize, const uint8_t *buf, int buf_size, int mode)
Initialize LZW decoder.
static void unpack_gray(TiffContext *s, AVFrame *p, const uint8_t *src, int lnum, int width, int bpp)
#define av_malloc_array(a, b)
@ AV_PIX_FMT_BAYER_GBRG8
bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
@ TIFF_TYPE_TIFF
TIFF image based on the TIFF 6.0 or TIFF/EP (ISO 12234-2) specifications.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
static const struct @363 planes[]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
@ TIFF_TYPE_DNG
Digital Negative (DNG) image.
const char * name
Name of the codec implementation.
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
void * av_calloc(size_t nmemb, size_t size)
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
#define FFSWAP(type, a, b)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static const float d65_white[3]
static const char * get_geokey_name(int key)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
double ff_tget_double(GetByteContext *gb, int le)
Reads a double from the bytestream using given endianness.
TiffPhotometric
list of TIFF, TIFF/AP and DNG PhotometricInterpretation (TIFF_PHOTOMETRIC) values
main external API structure.
#define ADD_METADATA(count, name, sep)
@ AV_PIX_FMT_RGBAF32BE
IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining again
static av_always_inline int bytestream2_seek_p(PutByteContext *p, int offset, int whence)
AVDictionary * metadata
metadata.
static void set_sar(TiffContext *s, unsigned tag, unsigned num, unsigned den)
static int tiff_unpack_fax(TiffContext *s, uint8_t *dst, int stride, const uint8_t *src, int size, int width, int lines)
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
int ff_tdecode_header(GetByteContext *gb, int *le, int *ifd_offset)
Decodes a TIFF header from the input bytestream and sets the endianness in *le and the offset to the ...
@ AV_PIX_FMT_RGBF32LE
IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
@ DNG_CAMERA_CALIBRATION2
char * av_strdup(const char *s)
Duplicate a string.
@ AV_PIX_FMT_RGBAF32LE
IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian.
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
static int init_image(TiffContext *s, AVFrame *frame)
#define avpriv_request_sample(...)
Structure to hold side data for an AVFrame.
static void free_geotags(TiffContext *const s)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
This structure stores compressed data.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
static void av_always_inline dng_blit(TiffContext *s, uint8_t *dst, int dst_stride, const uint8_t *src, int src_stride, int width, int height, int is_single_comp, int is_u16, int odd_line)
static int tiff_unpack_strip(TiffContext *s, AVFrame *p, uint8_t *dst, int stride, const uint8_t *src, int size, int strip_start, int lines)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int tile_byte_counts_offset
int ff_tadd_doubles_metadata(int count, const char *name, const char *sep, GetByteContext *gb, int le, AVDictionary **metadata)
Adds count doubles converted to a string into the metadata dictionary.
AVCodecContext * avctx_mjpeg
static int add_metadata(int count, int type, const char *name, const char *sep, TiffContext *s, AVFrame *frame)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
TiffCompr
list of TIFF, TIFF/EP and DNG compression types
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
@ TIFF_GEOG_ANGULAR_UNITS_GEOKEY
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const uint8_t type_sizes[14]
sizes of various TIFF field types (string size = 100)
#define AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_BAYER_RGGB16
unsigned ff_tget(GetByteContext *gb, int type, int le)
Reads a byte from the bytestream using given endianness.
@ TIFF_PHOTOMETRIC_SEPARATED
@ TIFF_PROJECTED_CS_TYPE_GEOKEY
@ AV_PIX_FMT_BAYER_GRBG8
bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
unsigned int yuv_line_size
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
@ TIFF_GT_RASTER_TYPE_GEOKEY