Go to the documentation of this file.
32 #define LZMA_API_STATIC
127 static const float d65_white[3] = { 0.950456f, 1.f, 1.088754f };
130 if (
s->tiff_type < tiff_type)
131 s->tiff_type = tiff_type;
136 for (
int i = 0;
i <
s->geotag_count;
i++)
144 #define RET_GEOKEY_STR(TYPE, array)\
145 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
146 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\
147 return tiff_##array##_name_type_string + tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].offset;
159 #define RET_GEOKEY_TYPE(TYPE, array)\
160 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
161 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\
162 return tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].type;
190 return "User-Defined";
192 #define RET_GEOKEY_VAL(TYPE, array)\
193 if (val >= TIFF_##TYPE##_OFFSET &&\
194 val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_codes))\
195 return tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET];
248 uint64_t component_len;
249 if (!sep) sep =
", ";
250 component_len = 24LL + strlen(sep);
251 if (count >= (INT_MAX - 1)/component_len)
253 ap =
av_malloc(component_len * count + 1);
258 for (
i = 0;
i < count;
i++) {
259 unsigned l =
snprintf(ap, component_len,
"%.15g%s", dp[
i], sep);
260 if(l >= component_len) {
266 ap0[strlen(ap0) - strlen(sep)] =
'\0';
296 value_norm = ((
float)
value - black_level) * scale_factor;
313 int is_single_comp,
int is_u16,
int odd_line)
315 float scale_factor[4];
319 for (
int i = 0;
i < 4;
i++)
320 scale_factor[
i] =
s->premultiply[
s->pattern[
i]] * 65535.f / (
s->white_level -
s->black_level[
i]);
322 for (
int i = 0;
i < 4;
i++)
323 scale_factor[
i] =
s->premultiply[
i ] * 65535.f / (
s->white_level -
s->black_level[
i]);
326 if (is_single_comp) {
333 uint16_t *dst_u16 = (uint16_t *)dst;
334 const uint16_t *src_u16 = (
const uint16_t *)
src;
337 for (col = 0; col <
width; col++)
338 *dst_u16++ =
dng_process_color16(*src_u16++,
s->dng_lut,
s->black_level[col&1], scale_factor[col&1]);
341 dst += dst_stride *
sizeof(uint16_t);
342 dst_u16 = (uint16_t *)dst;
345 for (col = 0; col <
width; col++)
346 *dst_u16++ =
dng_process_color16(*src_u16++,
s->dng_lut,
s->black_level[(col&1) + 2], scale_factor[(col&1) + 2]);
348 dst += dst_stride *
sizeof(uint16_t);
349 src += src_stride *
sizeof(uint16_t);
356 uint16_t *dst_u16 = (uint16_t *)dst;
357 const uint16_t *src_u16 = (
const uint16_t *)
src;
359 for (col = 0; col <
width; col++)
361 s->black_level[(col&1) + 2 * ((
line&1) + odd_line)],
362 scale_factor[(col&1) + 2 * ((
line&1) + odd_line)]);
364 dst += dst_stride *
sizeof(uint16_t);
365 src += src_stride *
sizeof(uint16_t);
369 uint8_t *dst_u8 = dst;
370 const uint8_t *src_u8 =
src;
372 for (col = 0; col <
width; col++)
374 s->black_level[(col&1) + 2 * ((
line&1) + odd_line)],
375 scale_factor[(col&1) + 2 * ((
line&1) + odd_line)]);
385 unsigned int bpp, uint8_t* dst,
386 int usePtr,
const uint8_t *
src,
391 while (--
width >= 0) {
403 while (--
width >= 0) {
411 while (--
width >= 0) {
419 uint16_t *dst16 = (uint16_t *)dst;
421 uint8_t
shift = is_dng ? 0 : 16 - bpp;
425 for (
int i = 0;
i <
s->width;
i++) {
444 if (!
s->deinvert_buf)
453 const uint8_t *
src,
int lnum,
int width,
int bpp)
456 uint16_t *dst = (uint16_t *)(p->
data[0] + lnum * p->
linesize[0]);
460 for (
int i = 0;
i <
s->width;
i++) {
466 const uint8_t *
src,
int lnum)
469 int w = (
s->width - 1) /
s->subsampling[0] + 1;
470 uint8_t *pu = &p->
data[1][lnum /
s->subsampling[1] * p->
linesize[1]];
472 if (
s->width %
s->subsampling[0] ||
s->height %
s->subsampling[1]) {
473 for (
i = 0;
i <
w;
i++) {
474 for (j = 0; j <
s->subsampling[1]; j++)
475 for (k = 0; k <
s->subsampling[0]; k++)
477 FFMIN(
i *
s->subsampling[0] + k,
s->width-1)] = *
src++;
482 for (
i = 0;
i <
w;
i++) {
483 for (j = 0; j <
s->subsampling[1]; j++)
484 for (k = 0; k <
s->subsampling[0]; k++)
486 i *
s->subsampling[0] + k] = *
src++;
494 static int tiff_uncompress(uint8_t *dst,
unsigned long *
len,
const uint8_t *
src,
497 z_stream zstream = { 0 };
500 zstream.next_in =
src;
501 zstream.avail_in =
size;
502 zstream.next_out = dst;
503 zstream.avail_out = *
len;
504 zret = inflateInit(&zstream);
509 zret =
inflate(&zstream, Z_SYNC_FLUSH);
510 inflateEnd(&zstream);
511 *
len = zstream.total_out;
512 return zret == Z_STREAM_END ? Z_OK : zret;
517 int strip_start,
int is_yuv)
520 unsigned long outlen;
522 outlen =
width * lines;
531 src =
s->deinvert_buf;
533 ret = tiff_uncompress(zbuf, &outlen,
src,
size);
536 "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
550 line +=
s->subsampling[1] - 1;
561 static int tiff_uncompress_lzma(uint8_t *dst, uint64_t *
len,
const uint8_t *
src,
564 lzma_stream stream = LZMA_STREAM_INIT;
567 stream.next_in =
src;
568 stream.avail_in =
size;
569 stream.next_out = dst;
570 stream.avail_out = *
len;
571 ret = lzma_stream_decoder(&stream, UINT64_MAX, 0);
572 if (
ret != LZMA_OK) {
576 ret = lzma_code(&stream, LZMA_RUN);
578 *
len = stream.total_out;
579 return ret == LZMA_STREAM_END ? LZMA_OK :
ret;
584 int strip_start,
int is_yuv)
586 uint64_t outlen =
width * (uint64_t)lines;
596 src =
s->deinvert_buf;
598 ret = tiff_uncompress_lzma(buf, &outlen,
src,
size);
599 if (
ret != LZMA_OK) {
601 "Uncompressing failed (%"PRIu64
" of %"PRIu64
") with error %d\n", outlen,
615 line +=
s->subsampling[1] - 1;
634 src =
s->deinvert_buf;
637 s->compr,
s->fax_opts);
647 int tile_byte_count,
int dst_x,
int dst_y,
int w,
int h)
650 uint8_t *dst_data, *src_data;
652 int is_single_comp, is_u16, pixel_size;
660 s->jpkt->data = (uint8_t*)
s->gb.buffer;
661 s->jpkt->size = tile_byte_count;
667 mjpegdecctx->
bayer = 1;
687 is_u16 = (
s->bpp > 8);
691 if (
s->jpgframe->width !=
s->avctx_mjpeg->width ||
692 s->jpgframe->height !=
s->avctx_mjpeg->height ||
693 s->jpgframe->format !=
s->avctx_mjpeg->pix_fmt)
697 if (
s->avctx_mjpeg->width ==
w * 2 &&
698 s->avctx_mjpeg->height ==
h / 2 &&
701 }
else if (
s->avctx_mjpeg->width >=
w &&
702 s->avctx_mjpeg->height >=
h &&
709 pixel_size = (is_u16 ?
sizeof(uint16_t) :
sizeof(uint8_t));
711 if (is_single_comp && !is_u16) {
717 dst_offset = dst_x +
frame->linesize[0] * dst_y / pixel_size;
718 dst_data =
frame->data[0] + dst_offset * pixel_size;
719 src_data =
s->jpgframe->data[0];
723 frame->linesize[0] / pixel_size,
725 s->jpgframe->linesize[0] / pixel_size,
737 const uint8_t *
src,
int size,
int strip_start,
int lines)
741 const uint8_t *ssrc =
src;
742 int width = ((
s->width *
s->bpp) + 7) >> 3;
746 desc->nb_components >= 3;
756 int bytes_per_row = (((
s->width - 1) /
s->subsampling[0] + 1) *
s->bpp *
757 s->subsampling[0] *
s->subsampling[1] + 7) >> 3;
759 if (
s->yuv_line ==
NULL) {
766 width = (
s->width - 1) /
s->subsampling[0] + 1;
777 if (
s->yuv_line ==
NULL) {
788 strip_start, is_yuv);
791 "zlib support not enabled, "
792 "deflate compression not supported\n");
799 strip_start, is_yuv);
802 "LZMA support not enabled\n");
810 ssrc =
src =
s->deinvert_buf;
821 if (pixels <
width) {
830 line +=
s->subsampling[1] - 1;
865 if (is_dng &&
stride == 0)
882 if (!
s->fill_order) {
893 int is_u16, pixel_size_bytes, pixel_size_bits,
elements;
895 is_u16 = (
s->bpp /
s->bppcount > 8);
896 pixel_size_bits = (is_u16 ? 16 : 8);
897 pixel_size_bytes = (is_u16 ?
sizeof(uint16_t) :
sizeof(uint8_t));
899 elements =
width / pixel_size_bytes * pixel_size_bits /
s->bpp *
s->bppcount;
910 (
line + strip_start)&1);
916 for (pixels = 0; pixels <
width;) {
927 "Copy went out of bounds\n");
934 }
else if (
code != -128) {
938 "Run went out of bounds\n");
956 line +=
s->subsampling[1] - 1;
970 int tile_offset_offset, tile_offset;
971 int tile_byte_count_offset, tile_byte_count;
972 int tile_count_x, tile_count_y;
973 int tile_width, tile_length;
974 int has_width_leftover, has_height_leftover;
975 int tile_x = 0, tile_y = 0;
976 int pos_x = 0, pos_y = 0;
979 if (
s->tile_width <= 0 ||
s->tile_length <= 0)
982 has_width_leftover = (
s->width %
s->tile_width != 0);
983 has_height_leftover = (
s->height %
s->tile_length != 0);
986 tile_count_x = (
s->width +
s->tile_width - 1) /
s->tile_width;
987 tile_count_y = (
s->height +
s->tile_length - 1) /
s->tile_length;
990 for (tile_idx = 0; tile_idx < tile_count_x * tile_count_y; tile_idx++) {
991 tile_x = tile_idx % tile_count_x;
992 tile_y = tile_idx / tile_count_x;
994 if (has_width_leftover && tile_x == tile_count_x - 1)
995 tile_width =
s->width %
s->tile_width;
997 tile_width =
s->tile_width;
999 if (has_height_leftover && tile_y == tile_count_y - 1)
1000 tile_length =
s->height %
s->tile_length;
1002 tile_length =
s->tile_length;
1005 tile_offset_offset =
s->tile_offsets_offset + tile_idx *
sizeof(
int);
1010 tile_byte_count_offset =
s->tile_byte_counts_offset + tile_idx *
sizeof(
int);
1024 pos_x += tile_width;
1025 if (tile_x == tile_count_x - 1) {
1027 pos_y += tile_length;
1041 int create_gray_palette = 0;
1044 if (
s->bpp > 128 ||
s->bppcount >= 10) {
1046 "Unsupported image parameters: bpp=%d, bppcount=%d\n",
1047 s->bpp,
s->bppcount);
1051 switch (
s->planar * 10000 +
s->bpp * 10 +
s->bppcount +
s->is_bayer * 100000) {
1053 if (!
s->palette_is_set) {
1060 if (!
s->palette_is_set) {
1061 create_gray_palette = 1;
1115 if (
s->subsampling[0] == 1 &&
s->subsampling[1] == 1) {
1117 }
else if (
s->subsampling[0] == 2 &&
s->subsampling[1] == 1) {
1119 }
else if (
s->subsampling[0] == 4 &&
s->subsampling[1] == 1) {
1121 }
else if (
s->subsampling[0] == 1 &&
s->subsampling[1] == 2) {
1123 }
else if (
s->subsampling[0] == 2 &&
s->subsampling[1] == 2) {
1125 }
else if (
s->subsampling[0] == 4 &&
s->subsampling[1] == 4) {
1151 "bpp=40 without PHOTOMETRIC_SEPARATED is unsupported\n");
1187 "This format is not supported (bpp=%d, bppcount=%d)\n",
1188 s->bpp,
s->bppcount);
1196 desc->nb_components < 3) {
1202 if (
s->width !=
s->avctx->width ||
s->height !=
s->avctx->height) {
1214 if (!create_gray_palette)
1215 memcpy(
frame->data[1],
s->palette,
sizeof(
s->palette));
1219 uint32_t *pal = (uint32_t *)
frame->data[1];
1220 for (
i = 0;
i < 1<<
s->bpp;
i++)
1221 pal[
i] = 0xFFU << 24 |
i * 255 / ((1<<
s->bpp) - 1) * 0x010101;
1232 if (
s->res[0] &&
s->res[1] &&
s->res[2] &&
s->res[3]) {
1233 uint64_t num =
s->res[2] * (uint64_t)
s->res[1];
1234 uint64_t den =
s->res[0] * (uint64_t)
s->res[3];
1235 if (num > INT64_MAX || den > INT64_MAX) {
1239 av_reduce(&
s->avctx->sample_aspect_ratio.num, &
s->avctx->sample_aspect_ratio.den,
1240 num, den, INT32_MAX);
1241 if (!
s->avctx->sample_aspect_ratio.den)
1242 s->avctx->sample_aspect_ratio = (
AVRational) {0, 1};
1260 if (tag <= s->last_tag)
1295 s->is_thumbnail = (
value != 0);
1304 if (count > 5 || count <= 0) {
1306 "This format is not supported (bpp=%d, %d components)\n",
1310 s->bppcount = count;
1321 for (
i = 0;
i < count;
i++)
1332 "Samples per pixel requires a single value, many provided\n");
1337 "Invalid samples per pixel %d\n",
value);
1340 if (
s->bppcount == 1)
1390 if (
value > INT_MAX) {
1392 "strippos %u too large\n",
value);
1400 if (
s->strips ==
s->bppcount)
1406 if (
value > INT_MAX) {
1408 "stripsize %u too large\n",
value);
1411 s->stripsizesoff = 0;
1415 s->stripsizesoff = off;
1425 s->tile_offsets_offset = off;
1429 s->tile_byte_counts_offset = off;
1450 for (
int i = 0;
i < count;
i++)
1452 s->white_level =
s->dng_lut[count-1];
1458 for (
int i = 0; i < count && count > 1;
i++) {
1481 for (
int i = count; i < 4 && count > 0;
i++)
1482 s->black_level[
i] =
s->black_level[count - 1];
1520 "PhotometricInterpretation 0x%04X",
1525 "unknown\n",
value);
1530 if (value < 1 || value > 2) {
1532 "Unknown FillOrder value %d, trying default one\n",
value);
1535 s->fill_order =
value - 1;
1540 if (count / 3 > 256 ||
1544 pal_gb[0] = pal_gb[1] = pal_gb[2] =
s->gb;
1554 for (
i = 0;
i < count / 3;
i++) {
1555 uint32_t p = 0xFF000000;
1561 s->palette_is_set = 1;
1572 for (
i = 0;
i < count;
i++) {
1574 if (
s->subsampling[
i] <= 0) {
1576 s->subsampling[
i] = 1;
1589 #define ADD_METADATA(count, name, sep)\
1590 if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\
1591 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
1604 if (
s->geotag_count) {
1611 if (
s->geotag_count > count / 4 - 1) {
1612 s->geotag_count = count / 4 - 1;
1616 ||
s->geotag_count == 0) {
1617 s->geotag_count = 0;
1620 s->geotags =
av_calloc(
s->geotag_count,
sizeof(*
s->geotags));
1623 s->geotag_count = 0;
1626 for (
i = 0;
i <
s->geotag_count;
i++) {
1633 if (!
s->geotags[
i].type) {
1637 if (!
s->geotags[
i].val)
1640 s->geotags[
i].offset =
val;
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++) {
2035 s->geotags[
i].val =
NULL;
2043 double cam2xyz[4][3];
2044 float cmatrix[3][4];
2045 float pmin = FLT_MAX;
2048 for (
i = 0;
i < 3;
i++) {
2049 for (j = 0; j < 3; j++)
2050 s->camera_calibration[
i][j] *=
s->analog_balance[
i];
2053 if (!
s->use_color_matrix) {
2054 for (
i = 0;
i < 3;
i++) {
2055 if (
s->camera_calibration[
i][
i])
2056 s->premultiply[
i] /=
s->camera_calibration[
i][
i];
2059 for (
int c = 0;
c < 3;
c++) {
2060 for (
i = 0;
i < 3;
i++) {
2062 for (j = 0; j < 3; j++)
2063 cam2xyz[
c][
i] +=
s->camera_calibration[
c][j] *
s->color_matrix[j][
i] *
s->as_shot_white[
i];
2070 for (
int c = 0;
c < 3;
c++)
2071 pmin =
fminf(pmin,
s->premultiply[
c]);
2073 for (
int c = 0;
c < 3;
c++)
2074 s->premultiply[
c] /= pmin;
2076 if (
s->bpp %
s->bppcount)
2078 bps =
s->bpp /
s->bppcount;
2079 if (bps < 8 || bps > 32)
2082 if (
s->white_level == 0)
2083 s->white_level = (1LL <<
bps) - 1;
2085 if (
s->white_level <=
s->black_level[0]) {
2086 av_log(avctx,
AV_LOG_ERROR,
"BlackLevel (%g) must be less than WhiteLevel (%"PRId32
")\n",
2087 s->black_level[0],
s->white_level);
2095 if (!
s->is_tiled && !
s->strippos && !
s->stripoff) {
2100 has_tile_bits =
s->is_tiled ||
s->tile_byte_counts_offset ||
s->tile_offsets_offset ||
s->tile_width ||
s->tile_length;
2101 has_strip_bits =
s->strippos ||
s->strips ||
s->stripoff ||
s->rps ||
s->sot ||
s->sstype ||
s->stripsize ||
s->stripsizesoff;
2103 if (has_tile_bits && has_strip_bits) {
2104 int tiled_dng =
s->is_tiled && is_dng;
2114 if (!
s->is_tiled || has_strip_bits) {
2115 if (
s->strips == 1 && !
s->stripsize) {
2117 s->stripsize = avpkt->
size -
s->stripoff;
2120 if (
s->stripsizesoff) {
2121 if (
s->stripsizesoff >= (
unsigned)avpkt->
size)
2124 avpkt->
size -
s->stripsizesoff);
2127 if (
s->strippos >= (
unsigned)avpkt->
size)
2130 avpkt->
size -
s->strippos);
2133 if (
s->rps <= 0 ||
s->rps %
s->subsampling[1]) {
2148 if (is_dng &&
s->is_tiled) {
2152 }
else if (!
s->is_bayer) {
2164 planes =
s->planar ?
s->bppcount : 1;
2165 for (plane = 0; plane <
planes; plane++) {
2166 uint8_t *five_planes =
NULL;
2167 int remaining = avpkt->
size;
2170 dst = p->
data[plane];
2179 for (
i = 0;
i <
s->height;
i +=
s->rps) {
2182 if (
s->stripsizesoff)
2183 ssize =
ff_tget(&stripsizes,
s->sstype, le);
2185 ssize =
s->stripsize;
2188 soff =
ff_tget(&stripdata,
s->sot, le);
2192 if (soff > avpkt->
size || ssize > avpkt->
size - soff || ssize > remaining) {
2199 FFMIN(
s->rps,
s->height -
i))) < 0) {
2207 decoded_height =
FFMIN(
i,
s->height);
2209 if (
s->predictor == 2) {
2214 dst = five_planes ? five_planes : p->
data[plane];
2217 soff =
FFMAX(soff /
s->bppcount, 1);
2218 ssize =
s->width * soff;
2225 for (
i = 0;
i < decoded_height;
i++) {
2226 for (j = soff; j < ssize; j += 2)
2236 for (
i = 0;
i < decoded_height;
i++) {
2237 for (j = soff; j < ssize; j += 2)
2242 for (
i = 0;
i < decoded_height;
i++) {
2243 for (j = soff; j < ssize; j++)
2244 dst[j] += dst[j - soff];
2252 if (
s->predictor == 3) {
2258 dst = five_planes ? five_planes : p->
data[plane];
2261 soff =
FFMAX(soff /
s->bppcount, 1);
2264 ssize =
s->width * soff;
2265 bpc =
FFMAX(soff /
s->bppcount, 1);
2274 for (
i = 0;
i < decoded_height;
i++) {
2281 tmpbuf[j] = dst[j] + tmpbuf[j-
channels];
2288 for (j = 0; j < group_size; j++) {
2289 for (
int k = 0; k < bpc; k++) {
2290 dst[bpc * j + k] = tmpbuf[(bpc - k - 1) * group_size + j];
2298 for (
i = 0;
i < decoded_height;
i++) {
2303 tmpbuf[j] = dst[j] + tmpbuf[j-
channels];
2305 for (j = 0; j < group_size; j++) {
2306 for (
int k = 0; k < bpc; k++) {
2307 dst[bpc * j + k] = tmpbuf[k * group_size + j];
2320 dst = p->
data[plane];
2321 for (
i = 0;
i <
s->height;
i++) {
2322 for (j = 0; j <
stride; j++)
2323 dst[j] =
c - dst[j];
2331 uint8_t *
src = five_planes ? five_planes : p->
data[plane];
2332 dst = p->
data[plane];
2333 for (
i = 0;
i <
s->height;
i++) {
2334 for (j = 0; j <
s->width; j++) {
2335 int k = 255 -
src[x * j + 3];
2336 int r = (255 -
src[x * j ]) * k;
2337 int g = (255 -
src[x * j + 1]) * k;
2338 int b = (255 -
src[x * j + 2]) * k;
2339 dst[4 * j ] =
r * 257 >> 16;
2340 dst[4 * j + 1] =
g * 257 >> 16;
2341 dst[4 * j + 2] =
b * 257 >> 16;
2350 dst = p->
data[plane];
2351 for (
i = 0;
i <
s->height;
i++) {
2352 for (j = 0; j <
s->width; j++) {
2353 uint64_t k = 65535 -
AV_RB16(dst + 8 * j + 6);
2354 uint64_t
r = (65535 -
AV_RB16(dst + 8 * j )) * k;
2355 uint64_t
g = (65535 -
AV_RB16(dst + 8 * j + 2)) * k;
2356 uint64_t
b = (65535 -
AV_RB16(dst + 8 * j + 4)) * k;
2357 AV_WB16(dst + 8 * j ,
r * 65537 >> 32);
2358 AV_WB16(dst + 8 * j + 2,
g * 65537 >> 32);
2359 AV_WB16(dst + 8 * j + 4,
b * 65537 >> 32);
2360 AV_WB16(dst + 8 * j + 6, 65535);
2367 if (
s->planar &&
s->bppcount > 2) {
2374 if (
s->is_bayer &&
s->white_level &&
s->bpp == 16 && !is_dng) {
2375 uint16_t *dst = (uint16_t *)p->
data[0];
2376 for (
i = 0;
i <
s->height;
i++) {
2377 for (j = 0; j <
s->width; j++)
2378 dst[j] =
FFMIN((dst[j] / (
float)
s->white_level) * 65535, 65535);
2398 s->subsampling[1] = 1;
2408 if (!
s->jpgframe || !
s->jpkt)
2416 if (!
s->avctx_mjpeg)
2418 s->avctx_mjpeg->flags = avctx->
flags;
2419 s->avctx_mjpeg->flags2 = avctx->
flags2;
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 const struct @385 planes[]
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)
static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
static const ElemCat * elements[ELEMENT_COUNT]
@ TIFF_PHOTOMETRIC_ICC_LAB
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
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)
char * av_asprintf(const char *fmt,...)
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
@ 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
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static const char * get_geokey_val(int key, uint16_t val)
#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)
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
#define RET_GEOKEY_TYPE(TYPE, array)
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_*.
int(* init)(AVBSFContext *ctx)
@ 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]
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
#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
@ 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...
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_VIDEO_PARAM
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...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
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.
#define RET_GEOKEY_STR(TYPE, array)
@ 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.
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
@ 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