Go to the documentation of this file.
32 #define LZMA_API_STATIC
117 if (
s->tiff_type < tiff_type)
118 s->tiff_type = tiff_type;
124 for (
i = 0;
i <
s->geotag_count;
i++) {
125 if (
s->geotags[
i].val)
132 #define RET_GEOKEY(TYPE, array, element)\
133 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
134 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_name_type_map))\
135 return ff_tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element;
180 #define RET_GEOKEY_VAL(TYPE, array)\
181 if (val >= TIFF_##TYPE##_OFFSET &&\
182 val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\
183 return av_strdup(ff_tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]);
243 uint64_t component_len;
244 if (!sep) sep =
", ";
245 component_len = 24LL + strlen(sep);
246 if (count >= (INT_MAX - 1)/component_len)
248 ap =
av_malloc(component_len * count + 1);
253 for (
i = 0;
i < count;
i++) {
254 unsigned l =
snprintf(ap, component_len,
"%.15g%s", dp[
i], sep);
255 if(l >= component_len) {
261 ap0[strlen(ap0) - strlen(sep)] =
'\0';
278 int is_single_comp,
int is_u16);
281 unsigned int bpp,
uint8_t* dst,
287 while (--
width >= 0) {
299 while (--
width >= 0) {
307 while (--
width >= 0) {
315 uint16_t *dst16 = (uint16_t *)dst;
321 for (
int i = 0;
i <
s->width;
i++) {
340 if (!
s->deinvert_buf)
352 uint16_t *dst = (uint16_t *)(p->
data[0] + lnum * p->
linesize[0]);
356 for (
int i = 0;
i <
s->width;
i++) {
365 int w = (
s->width - 1) /
s->subsampling[0] + 1;
368 if (
s->width %
s->subsampling[0] ||
s->height %
s->subsampling[1]) {
369 for (
i = 0;
i <
w;
i++) {
370 for (j = 0; j <
s->subsampling[1]; j++)
371 for (k = 0; k <
s->subsampling[0]; k++)
373 FFMIN(
i *
s->subsampling[0] + k,
s->width-1)] = *
src++;
378 for (
i = 0;
i <
w;
i++) {
379 for (j = 0; j <
s->subsampling[1]; j++)
380 for (k = 0; k <
s->subsampling[0]; k++)
382 i *
s->subsampling[0] + k] = *
src++;
393 z_stream zstream = { 0 };
396 zstream.next_in =
src;
397 zstream.avail_in =
size;
398 zstream.next_out = dst;
399 zstream.avail_out = *
len;
400 zret = inflateInit(&zstream);
405 zret =
inflate(&zstream, Z_SYNC_FLUSH);
406 inflateEnd(&zstream);
407 *
len = zstream.total_out;
408 return zret == Z_STREAM_END ? Z_OK : zret;
413 int strip_start,
int is_yuv)
416 unsigned long outlen;
418 outlen =
width * lines;
427 src =
s->deinvert_buf;
429 ret = tiff_uncompress(zbuf, &outlen,
src,
size);
432 "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
446 line +=
s->subsampling[1] - 1;
460 lzma_stream stream = LZMA_STREAM_INIT;
464 stream.avail_in =
size;
465 stream.next_out = dst;
466 stream.avail_out = *
len;
467 ret = lzma_stream_decoder(&stream, UINT64_MAX, 0);
468 if (
ret != LZMA_OK) {
472 ret = lzma_code(&stream, LZMA_RUN);
474 *
len = stream.total_out;
475 return ret == LZMA_STREAM_END ? LZMA_OK :
ret;
480 int strip_start,
int is_yuv)
482 uint64_t outlen =
width * (uint64_t)lines;
492 src =
s->deinvert_buf;
494 ret = tiff_uncompress_lzma(buf, &outlen,
src,
size);
495 if (
ret != LZMA_OK) {
497 "Uncompressing failed (%"PRIu64
" of %"PRIu64
") with error %d\n", outlen,
511 line +=
s->subsampling[1] - 1;
529 src2 =
s->fax_buffer;
533 "Error allocating temporary buffer\n");
537 if (!
s->fill_order) {
545 s->compr,
s->fax_opts);
562 int width = ((
s->width *
s->bpp) + 7) >> 3;
566 desc->nb_components >= 3;
576 int bytes_per_row = (((
s->width - 1) /
s->subsampling[0] + 1) *
s->bpp *
577 s->subsampling[0] *
s->subsampling[1] + 7) >> 3;
579 if (
s->yuv_line ==
NULL) {
586 width = (
s->width - 1) /
s->subsampling[0] + 1;
596 if (
s->yuv_line ==
NULL) {
607 strip_start, is_yuv);
610 "zlib support not enabled, "
611 "deflate compression not supported\n");
618 strip_start, is_yuv);
621 "LZMA support not enabled\n");
629 ssrc =
src =
s->deinvert_buf;
640 if (pixels <
width) {
649 line +=
s->subsampling[1] - 1;
682 if (is_dng &&
stride == 0)
699 if (!
s->fill_order) {
710 int is_u16, pixel_size_bytes, pixel_size_bits,
elements;
712 is_u16 = (
s->bpp > 8);
713 pixel_size_bits = (is_u16 ? 16 : 8);
714 pixel_size_bytes = (is_u16 ?
sizeof(uint16_t) :
sizeof(
uint8_t));
716 elements =
width / pixel_size_bytes * pixel_size_bits /
s->bpp *
s->bppcount;
732 for (pixels = 0; pixels <
width;) {
743 "Copy went out of bounds\n");
750 }
else if (
code != -128) {
754 "Run went out of bounds\n");
772 line +=
s->subsampling[1] - 1;
786 uint16_t black_level,
787 float scale_factor) {
798 value_norm = (float)
value * scale_factor;
807 uint16_t black_level,
808 float scale_factor) {
814 int width,
int height,
int is_single_comp,
int is_u16)
819 scale_factor = 1.0f / (
s->white_level -
s->black_level);
821 if (is_single_comp) {
828 uint16_t *dst_u16 = (uint16_t *)dst;
829 uint16_t *src_u16 = (uint16_t *)
src;
832 for (col = 0; col <
width; col++)
836 dst += dst_stride *
sizeof(uint16_t);
837 dst_u16 = (uint16_t *)dst;
840 for (col = 0; col <
width; col++)
843 dst += dst_stride *
sizeof(uint16_t);
844 src += src_stride *
sizeof(uint16_t);
851 uint16_t *dst_u16 = (uint16_t *)dst;
852 uint16_t *src_u16 = (uint16_t *)
src;
854 for (col = 0; col <
width; col++)
857 dst += dst_stride *
sizeof(uint16_t);
858 src += src_stride *
sizeof(uint16_t);
862 for (col = 0; col <
width; col++)
873 int tile_byte_count,
int dst_x,
int dst_y,
int w,
int h)
879 int is_single_comp, is_u16, pixel_size;
885 jpkt.
size = tile_byte_count;
891 mjpegdecctx->
bayer = 1;
914 is_single_comp = (
s->avctx_mjpeg->width ==
w * 2 &&
s->avctx_mjpeg->height ==
h / 2);
916 is_u16 = (
s->bpp > 8);
917 pixel_size = (is_u16 ?
sizeof(uint16_t) :
sizeof(
uint8_t));
919 if (is_single_comp && !is_u16) {
925 dst_offset = dst_x +
frame->linesize[0] * dst_y / pixel_size;
926 dst_data =
frame->data[0] + dst_offset * pixel_size;
927 src_data =
s->jpgframe->data[0];
931 frame->linesize[0] / pixel_size,
933 s->jpgframe->linesize[0] / pixel_size,
948 int tile_offset_offset, tile_offset;
949 int tile_byte_count_offset, tile_byte_count;
950 int tile_count_x, tile_count_y;
951 int tile_width, tile_length;
952 int has_width_leftover, has_height_leftover;
953 int tile_x = 0, tile_y = 0;
954 int pos_x = 0, pos_y = 0;
957 s->jpgframe->width =
s->tile_width;
958 s->jpgframe->height =
s->tile_length;
960 s->avctx_mjpeg->width =
s->tile_width;
961 s->avctx_mjpeg->height =
s->tile_length;
963 has_width_leftover = (
s->width %
s->tile_width != 0);
964 has_height_leftover = (
s->height %
s->tile_length != 0);
967 tile_count_x = (
s->width +
s->tile_width - 1) /
s->tile_width;
968 tile_count_y = (
s->height +
s->tile_length - 1) /
s->tile_length;
971 for (tile_idx = 0; tile_idx <
s->tile_count; tile_idx++) {
972 tile_x = tile_idx % tile_count_x;
973 tile_y = tile_idx / tile_count_x;
975 if (has_width_leftover && tile_x == tile_count_x - 1)
976 tile_width =
s->width %
s->tile_width;
978 tile_width =
s->tile_width;
980 if (has_height_leftover && tile_y == tile_count_y - 1)
981 tile_length =
s->height %
s->tile_length;
983 tile_length =
s->tile_length;
986 tile_offset_offset =
s->tile_offsets_offset + tile_idx *
sizeof(
int);
991 tile_byte_count_offset =
s->tile_byte_counts_offset + tile_idx *
sizeof(
int);
1005 pos_x += tile_width;
1006 if (tile_x == tile_count_x - 1) {
1008 pos_y += tile_length;
1014 frame->key_frame = 1;
1023 s->jpgframe->width =
s->width;
1024 s->jpgframe->height =
s->height;
1026 s->avctx_mjpeg->width =
s->width;
1027 s->avctx_mjpeg->height =
s->height;
1035 int create_gray_palette = 0;
1038 if (
s->bpp >= 100 ||
s->bppcount >= 10) {
1040 "Unsupported image parameters: bpp=%d, bppcount=%d\n",
1041 s->bpp,
s->bppcount);
1045 switch (
s->planar * 1000 +
s->bpp * 10 +
s->bppcount +
s->is_bayer * 10000) {
1047 if (!
s->palette_is_set) {
1054 if (!
s->palette_is_set) {
1055 create_gray_palette = 1;
1109 if (
s->subsampling[0] == 1 &&
s->subsampling[1] == 1) {
1111 }
else if (
s->subsampling[0] == 2 &&
s->subsampling[1] == 1) {
1113 }
else if (
s->subsampling[0] == 4 &&
s->subsampling[1] == 1) {
1115 }
else if (
s->subsampling[0] == 1 &&
s->subsampling[1] == 2) {
1117 }
else if (
s->subsampling[0] == 2 &&
s->subsampling[1] == 2) {
1119 }
else if (
s->subsampling[0] == 4 &&
s->subsampling[1] == 4) {
1145 "bpp=40 without PHOTOMETRIC_SEPARATED is unsupported\n");
1169 "This format is not supported (bpp=%d, bppcount=%d)\n",
1170 s->bpp,
s->bppcount);
1178 desc->nb_components < 3) {
1184 if (
s->width !=
s->avctx->width ||
s->height !=
s->avctx->height) {
1192 if (!create_gray_palette)
1193 memcpy(
frame->f->data[1],
s->palette,
sizeof(
s->palette));
1197 uint32_t *pal = (uint32_t *)
frame->f->data[1];
1198 for (
i = 0;
i < 1<<
s->bpp;
i++)
1199 pal[
i] = 0xFFU << 24 |
i * 255 / ((1<<
s->bpp) - 1) * 0x010101;
1210 if (
s->res[0] &&
s->res[1] &&
s->res[2] &&
s->res[3]) {
1211 uint64_t num =
s->res[2] * (uint64_t)
s->res[1];
1212 uint64_t den =
s->res[0] * (uint64_t)
s->res[3];
1213 if (num > INT64_MAX || den > INT64_MAX) {
1217 av_reduce(&
s->avctx->sample_aspect_ratio.num, &
s->avctx->sample_aspect_ratio.den,
1218 num, den, INT32_MAX);
1219 if (!
s->avctx->sample_aspect_ratio.den)
1220 s->avctx->sample_aspect_ratio = (
AVRational) {0, 1};
1267 s->is_thumbnail = (
value != 0);
1278 "This format is not supported (bpp=%d, %d components)\n",
1282 s->bppcount = count;
1293 for (
i = 0;
i < count;
i++)
1304 "Samples per pixel requires a single value, many provided\n");
1309 "Samples per pixel %d is too large\n",
value);
1312 if (
s->bppcount == 1)
1362 if (
value > INT_MAX) {
1364 "strippos %u too large\n",
value);
1378 if (
value > INT_MAX) {
1380 "stripsize %u too large\n",
value);
1383 s->stripsizesoff = 0;
1387 s->stripsizesoff = off;
1397 s->tile_offsets_offset = off;
1398 s->tile_count = count;
1402 s->tile_byte_counts_offset = off;
1420 for (
int i = 0;
i <
FFMIN(count, 1 <<
s->bpp);
i++)
1433 s->black_level =
value / value2;
1438 s->black_level =
value / value2;
1477 "PhotometricInterpretation 0x%04X",
1482 "unknown\n",
value);
1487 if (value < 1 || value > 2) {
1489 "Unknown FillOrder value %d, trying default one\n",
value);
1492 s->fill_order =
value - 1;
1497 if (count / 3 > 256 ||
1501 pal_gb[0] = pal_gb[1] = pal_gb[2] =
s->gb;
1511 for (
i = 0;
i < count / 3;
i++) {
1512 uint32_t p = 0xFF000000;
1518 s->palette_is_set = 1;
1529 for (
i = 0;
i < count;
i++) {
1531 if (
s->subsampling[
i] <= 0) {
1533 s->subsampling[
i] = 1;
1546 #define ADD_METADATA(count, name, sep)\
1547 if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\
1548 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
1561 if (
s->geotag_count) {
1568 if (
s->geotag_count > count / 4 - 1) {
1569 s->geotag_count = count / 4 - 1;
1573 ||
s->geotag_count == 0) {
1574 s->geotag_count = 0;
1580 s->geotag_count = 0;
1583 for (
i = 0;
i <
s->geotag_count;
i++) {
1588 if (!
s->geotags[
i].type)
1595 if (count >= INT_MAX /
sizeof(int64_t))
1604 for (
i = 0;
i < count;
i++)
1606 for (
i = 0;
i <
s->geotag_count;
i++) {
1608 if (
s->geotags[
i].count == 0
1609 ||
s->geotags[
i].offset +
s->geotags[
i].count > count) {
1611 }
else if (
s->geotags[
i].val) {
1614 char *ap =
doubles2str(&dp[
s->geotags[
i].offset],
s->geotags[
i].count,
", ");
1620 s->geotags[
i].val = ap;
1628 for (
i = 0;
i <
s->geotag_count;
i++) {
1630 if (
s->geotags[
i].count == 0
1631 ||
s->geotags[
i].offset +
s->geotags[
i].count > count) {
1639 if (
s->geotags[
i].val)
1647 ap[
s->geotags[
i].count - 1] =
'\0';
1648 s->geotags[
i].val = ap;
1703 bytestream2_seek(&
s->gb, count *
sizeof(uint16_t) -
sizeof(uint16_t), SEEK_CUR);
1710 unsigned int ver[4];
1717 ver[0], ver[1], ver[2], ver[3]);
1732 "Unknown or unsupported tag %d/0x%0X\n",
1740 "This format is not supported (bpp=%d, %d components)\n",
1755 unsigned off, last_off;
1758 unsigned soff, ssize;
1762 int retry_for_subifd, retry_for_page;
1764 int has_tile_bits, has_strip_bits;
1772 }
else if (off >= UINT_MAX - 14 || avpkt->
size < off + 14) {
1781 s->is_thumbnail = 0;
1782 s->bppcount =
s->bpp = 1;
1792 for (
i = 0;
i < 65536;
i++)
1798 s->stripsizesoff =
s->strippos = 0;
1804 for (
i = 0;
i < entries;
i++) {
1809 if (
s->get_thumbnail && !
s->is_thumbnail) {
1815 retry_for_subifd =
s->sub_ifd && (
s->get_subimage || (!
s->get_thumbnail &&
s->is_thumbnail));
1817 retry_for_page =
s->get_page &&
s->cur_page + 1 <
s->get_page;
1820 if (retry_for_page) {
1823 }
else if (retry_for_subifd) {
1828 if (retry_for_subifd || retry_for_page) {
1833 if (off <= last_off) {
1837 if (off >= UINT_MAX - 14 || avpkt->
size < off + 14) {
1849 for (
i = 0;
i<
s->geotag_count;
i++) {
1869 if (
s->white_level == 0)
1870 s->white_level = (1 <<
s->bpp) - 1;
1872 if (
s->white_level <=
s->black_level) {
1873 av_log(avctx,
AV_LOG_ERROR,
"BlackLevel (%"PRId32
") must be less than WhiteLevel (%"PRId32
")\n",
1874 s->black_level,
s->white_level);
1878 if (
s->bpp %
s->bppcount)
1880 bps =
s->bpp /
s->bppcount;
1881 if (bps < 8 || bps > 32)
1887 if (!
s->is_tiled && !
s->strippos && !
s->stripoff) {
1892 has_tile_bits =
s->is_tiled ||
s->tile_byte_counts_offset ||
s->tile_offsets_offset ||
s->tile_width ||
s->tile_length ||
s->tile_count;
1893 has_strip_bits =
s->strippos ||
s->strips ||
s->stripoff ||
s->rps ||
s->sot ||
s->sstype ||
s->stripsize ||
s->stripsizesoff;
1895 if (has_tile_bits && has_strip_bits) {
1905 if (
s->strips == 1 && !
s->stripsize) {
1907 s->stripsize = avpkt->
size -
s->stripoff;
1910 if (
s->stripsizesoff) {
1911 if (
s->stripsizesoff >= (
unsigned)avpkt->
size)
1914 avpkt->
size -
s->stripsizesoff);
1917 if (
s->strippos >= (
unsigned)avpkt->
size)
1920 avpkt->
size -
s->strippos);
1923 if (
s->rps <= 0 ||
s->rps %
s->subsampling[1]) {
1938 if (is_dng &&
s->is_tiled) {
1942 }
else if (!
s->is_bayer) {
1954 planes =
s->planar ?
s->bppcount : 1;
1955 for (plane = 0; plane <
planes; plane++) {
1957 int remaining = avpkt->
size;
1960 dst = p->
data[plane];
1969 for (
i = 0;
i <
s->height;
i +=
s->rps) {
1972 if (
s->stripsizesoff)
1973 ssize =
ff_tget(&stripsizes,
s->sstype, le);
1975 ssize =
s->stripsize;
1978 soff =
ff_tget(&stripdata,
s->sot, le);
1982 if (soff > avpkt->
size || ssize > avpkt->
size - soff || ssize > remaining) {
1989 FFMIN(
s->rps,
s->height -
i))) < 0) {
1997 decoded_height =
FFMIN(
i,
s->height);
1999 if (
s->predictor == 2) {
2004 dst = five_planes ? five_planes : p->
data[plane];
2007 soff =
FFMAX(soff /
s->bppcount, 1);
2008 ssize =
s->width * soff;
2015 for (
i = 0;
i < decoded_height;
i++) {
2016 for (j = soff; j < ssize; j += 2)
2026 for (
i = 0;
i < decoded_height;
i++) {
2027 for (j = soff; j < ssize; j += 2)
2032 for (
i = 0;
i < decoded_height;
i++) {
2033 for (j = soff; j < ssize; j++)
2034 dst[j] += dst[j - soff];
2042 dst = p->
data[plane];
2043 for (
i = 0;
i <
s->height;
i++) {
2044 for (j = 0; j <
stride; j++)
2045 dst[j] =
c - dst[j];
2054 dst = p->
data[plane];
2055 for (
i = 0;
i <
s->height;
i++) {
2056 for (j = 0; j <
s->width; j++) {
2057 int k = 255 -
src[
x * j + 3];
2058 int r = (255 -
src[
x * j ]) * k;
2059 int g = (255 -
src[
x * j + 1]) * k;
2060 int b = (255 -
src[
x * j + 2]) * k;
2061 dst[4 * j ] =
r * 257 >> 16;
2062 dst[4 * j + 1] =
g * 257 >> 16;
2063 dst[4 * j + 2] =
b * 257 >> 16;
2072 dst = p->
data[plane];
2073 for (
i = 0;
i <
s->height;
i++) {
2074 for (j = 0; j <
s->width; j++) {
2075 uint64_t k = 65535 -
AV_RB16(dst + 8 * j + 6);
2076 uint64_t
r = (65535 -
AV_RB16(dst + 8 * j )) * k;
2077 uint64_t
g = (65535 -
AV_RB16(dst + 8 * j + 2)) * k;
2078 uint64_t
b = (65535 -
AV_RB16(dst + 8 * j + 4)) * k;
2079 AV_WB16(dst + 8 * j ,
r * 65537 >> 32);
2080 AV_WB16(dst + 8 * j + 2,
g * 65537 >> 32);
2081 AV_WB16(dst + 8 * j + 4,
b * 65537 >> 32);
2082 AV_WB16(dst + 8 * j + 6, 65535);
2089 if (
s->planar &&
s->bppcount > 2) {
2096 if (
s->is_bayer &&
s->white_level &&
s->bpp == 16 && !is_dng) {
2097 uint16_t *dst = (uint16_t *)p->
data[0];
2098 for (
i = 0;
i <
s->height;
i++) {
2099 for (j = 0; j <
s->width; j++)
2100 dst[j] =
FFMIN((dst[j] / (
float)
s->white_level) * 65535, 65535);
2119 s->subsampling[1] = 1;
2136 if (!
s->avctx_mjpeg)
2138 s->avctx_mjpeg->flags = avctx->
flags;
2139 s->avctx_mjpeg->flags2 = avctx->
flags2;
2140 s->avctx_mjpeg->dct_algo = avctx->
dct_algo;
2141 s->avctx_mjpeg->idct_algo = avctx->
idct_algo;
2158 s->deinvert_buf_size = 0;
2160 s->yuv_line_size = 0;
2162 s->fax_buffer_size = 0;
2168 #define OFFSET(x) offsetof(TiffContext, x)
enum AVColorTransferCharacteristic color_trc
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
static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p)
static av_cold int init(AVCodecContext *avctx)
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
#define FFSWAP(type, a, b)
@ 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.
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
static uint16_t av_always_inline dng_process_color16(uint16_t value, const uint16_t *lut, uint16_t black_level, float scale_factor)
Map stored raw sensor values into linear reference values (see: DNG Specification - Chapter 5)
static int init_image(TiffContext *s, ThreadFrame *frame)
@ TIFF_PROJ_COORD_TRANS_GEOKEY
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
static char * doubles2str(double *dp, int count, const char *sep)
unsigned int fax_buffer_size
@ 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_cold int end(AVCodecContext *avctx)
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)
@ TIFF_PHOTOMETRIC_ITU_LAB
const uint8_t ff_reverse[256]
#define RET_GEOKEY_VAL(TYPE, array)
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
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...
@ 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.
static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
Clip a signed integer value into the 0-65535 range.
#define AV_PIX_FMT_BAYER_GRBG16
@ TIFF_PHOTOMETRIC_WHITE_IS_ZERO
@ TIFF_GEOG_PRIME_MERIDIAN_GEOKEY
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define TIFF_GEO_KEY_UNDEFINED
static const AVOption tiff_options[]
@ TIFF_PHOTOMETRIC_LINEAR_RAW
@ TIFF_PHOTOMETRIC_ALPHA_MASK
static int dng_decode_strip(AVCodecContext *avctx, AVFrame *frame)
@ 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
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 void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
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 AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). 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
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
@ 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
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.
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)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
@ 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.
@ 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 avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
@ 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.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
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
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.
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.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#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
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
#define AV_EF_EXPLODE
abort decoding on minor error detection
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)
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...
int flags2
AV_CODEC_FLAG2_*.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Call avcodec_open2 recursively by decrementing counter, unlocking mutex, calling the function and the...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
@ 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).
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
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
@ 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)
static const struct @315 planes[]
@ TIFF_PHOTOMETRIC_LOG_LUV
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
@ 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.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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_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_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
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
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo ug o o w
static const char * get_geokey_name(int key)
#define AV_INPUT_BUFFER_PADDING_SIZE
#define FF_ARRAY_ELEMS(a)
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
const TiffGeoTagKeyName ff_tiff_proj_cs_type_codes[]
main external API structure.
#define ADD_METADATA(count, name, sep)
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 ...
static uint16_t av_always_inline dng_process_color8(uint16_t value, const uint16_t *lut, uint16_t black_level, float scale_factor)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static int shift(int a, int b)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
char * av_strdup(const char *s)
Duplicate a string.
@ 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)
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.
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
#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 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, size in bytes of each picture line.
@ 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
const TiffGeoTagKeyName ff_tiff_projection_codes[]
#define AV_PIX_FMT_BAYER_RGGB16
static int dng_decode_tiles(AVCodecContext *avctx, AVFrame *frame, AVPacket *avpkt)
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
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
@ TIFF_GT_RASTER_TYPE_GEOKEY