Go to the documentation of this file.
208 unsigned long dest_len = uncompressed_size;
210 if (uncompress(td->
tmp, &dest_len,
src, compressed_size) != Z_OK ||
211 dest_len != uncompressed_size)
216 s->dsp.predictor(td->
tmp, uncompressed_size);
223 int compressed_size,
int uncompressed_size)
226 const int8_t *
s =
src;
227 int ssize = compressed_size;
228 int dsize = uncompressed_size;
229 uint8_t *dend = d + dsize;
238 if ((dsize -= count) < 0 ||
239 (ssize -= count + 1) < 0)
247 if ((dsize -= count) < 0 ||
267 rle(td->
tmp,
src, compressed_size, uncompressed_size);
271 ctx->dsp.predictor(td->
tmp, uncompressed_size);
277 #define USHORT_RANGE (1 << 16)
278 #define BITMAP_SIZE (1 << 13)
285 if ((
i == 0) || (bitmap[
i >> 3] & (1 << (
i & 7))))
299 for (
i = 0;
i < dsize; ++
i)
303 #define HUF_ENCBITS 16 // literal (value) bit length
304 #define HUF_ENCSIZE ((1 << HUF_ENCBITS) + 1) // encoding table size
308 uint64_t
c, n[59] = { 0 };
315 for (
i = 58;
i > 0; --
i) {
316 uint64_t nc = ((
c + n[
i]) >> 1);
325 freq[
i] = l | (n[l]++ << 6);
329 #define SHORT_ZEROCODE_RUN 59
330 #define LONG_ZEROCODE_RUN 63
331 #define SHORTEST_LONG_RUN (2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN)
332 #define LONGEST_LONG_RUN (255 + SHORTEST_LONG_RUN)
342 for (; im <= iM; im++) {
351 if (im + zerun > iM + 1)
361 if (im + zerun > iM + 1)
383 for (
int i = im;
i < iM;
i++) {
387 if (td->
he[j].
len > 32) {
391 if (td->
he[j].
len > 0)
409 if (td->
he[j].
len > 32) {
418 &td->
he[0].
len,
sizeof(td->
he[0]),
sizeof(td->
he[0].
len),
420 &td->
he[0].
sym,
sizeof(td->
he[0]),
sizeof(td->
he[0].
sym), 0);
424 int no, uint16_t *
out)
437 if (oe == 0 || oe +
run > no)
455 uint16_t *
dst,
int dst_size)
461 im = bytestream2_get_le32(gb);
462 iM = bytestream2_get_le32(gb);
464 nBits = bytestream2_get_le32(gb);
475 if (!td->
freq || !td->
he) {
494 static inline void wdec14(uint16_t l, uint16_t
h, uint16_t *
a, uint16_t *
b)
499 int ai = ls + (hi & 1) + (hi >> 1);
501 int16_t bs = ai - hi;
508 #define A_OFFSET (1 << (NBITS - 1))
509 #define MOD_MASK ((1 << NBITS) - 1)
511 static inline void wdec16(uint16_t l, uint16_t
h, uint16_t *
a, uint16_t *
b)
522 int ny,
int oy, uint16_t
mx)
524 int w14 = (
mx < (1 << 14));
525 int n = (nx > ny) ? ny : nx;
538 uint16_t *ey = in + oy * (ny - p2);
539 uint16_t i00, i01, i10, i11;
545 for (; py <= ey; py += oy2) {
547 uint16_t *ex = py + ox * (nx - p2);
549 for (; px <= ex; px += ox2) {
550 uint16_t *p01 = px + ox1;
551 uint16_t *p10 = px + oy1;
552 uint16_t *p11 = p10 + ox1;
555 wdec14(*px, *p10, &i00, &i10);
556 wdec14(*p01, *p11, &i01, &i11);
557 wdec14(i00, i01, px, p01);
558 wdec14(i10, i11, p10, p11);
560 wdec16(*px, *p10, &i00, &i10);
561 wdec16(*p01, *p11, &i01, &i11);
562 wdec16(i00, i01, px, p01);
563 wdec16(i10, i11, p10, p11);
568 uint16_t *p10 = px + oy1;
571 wdec14(*px, *p10, &i00, p10);
573 wdec16(*px, *p10, &i00, p10);
581 uint16_t *ex = py + ox * (nx - p2);
583 for (; px <= ex; px += ox2) {
584 uint16_t *p01 = px + ox1;
587 wdec14(*px, *p01, &i00, p01);
589 wdec16(*px, *p01, &i00, p01);
604 uint16_t maxval, min_non_zero, max_non_zero;
606 uint16_t *
tmp = (uint16_t *)td->
tmp;
625 min_non_zero = bytestream2_get_le16(&gb);
626 max_non_zero = bytestream2_get_le16(&gb);
632 if (min_non_zero <= max_non_zero)
634 max_non_zero - min_non_zero + 1);
645 for (
i = 0;
i <
s->nb_channels;
i++) {
653 for (j = 0; j < pixel_half_size; j++)
655 td->
xsize * pixel_half_size, maxval);
656 ptr += td->
xsize * td->
ysize * pixel_half_size;
664 for (j = 0; j <
s->nb_channels; j++) {
672 tmp_offset += pixel_half_size;
675 s->bbdsp.bswap16_buf(
out, in, td->
xsize * pixel_half_size);
677 memcpy(
out, in, td->
xsize * 2 * pixel_half_size);
687 int compressed_size,
int uncompressed_size,
690 unsigned long dest_len, expected_len = 0;
691 const uint8_t *in = td->
tmp;
695 for (
i = 0;
i <
s->nb_channels;
i++) {
698 }
else if (
s->channels[
i].pixel_type ==
EXR_HALF) {
705 dest_len = expected_len;
707 if (uncompress(td->
tmp, &dest_len,
src, compressed_size) != Z_OK) {
709 }
else if (dest_len != expected_len) {
715 for (
c = 0;
c <
s->nb_channels;
c++) {
717 const uint8_t *ptr[4];
723 ptr[1] = ptr[0] + td->
xsize;
724 ptr[2] = ptr[1] + td->
xsize;
725 in = ptr[2] + td->
xsize;
727 for (j = 0; j < td->
xsize; ++j) {
728 uint32_t
diff = ((unsigned)*(ptr[0]++) << 24) |
729 (*(ptr[1]++) << 16) |
737 ptr[1] = ptr[0] + td->
xsize;
738 in = ptr[1] + td->
xsize;
739 for (j = 0; j < td->
xsize; j++) {
740 uint32_t
diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
748 ptr[1] = ptr[0] +
s->xdelta;
749 ptr[2] = ptr[1] +
s->xdelta;
750 ptr[3] = ptr[2] +
s->xdelta;
751 in = ptr[3] +
s->xdelta;
753 for (j = 0; j <
s->xdelta; ++j) {
754 uint32_t
diff = ((uint32_t)*(ptr[0]++) << 24) |
755 (*(ptr[1]++) << 16) |
756 (*(ptr[2]++) << 8 ) |
772 uint16_t
shift = (
b[ 2] >> 2) & 15;
776 s[ 0] = (
b[0] << 8) |
b[1];
778 s[ 4] =
s[ 0] + ((((
b[ 2] << 4) | (
b[ 3] >> 4)) & 0x3f) <<
shift) -
bias;
779 s[ 8] =
s[ 4] + ((((
b[ 3] << 2) | (
b[ 4] >> 6)) & 0x3f) <<
shift) -
bias;
783 s[ 5] =
s[ 4] + ((((
b[ 5] << 4) | (
b[ 6] >> 4)) & 0x3f) <<
shift) -
bias;
784 s[ 9] =
s[ 8] + ((((
b[ 6] << 2) | (
b[ 7] >> 6)) & 0x3f) <<
shift) -
bias;
788 s[ 6] =
s[ 5] + ((((
b[ 8] << 4) | (
b[ 9] >> 4)) & 0x3f) <<
shift) -
bias;
789 s[10] =
s[ 9] + ((((
b[ 9] << 2) | (
b[10] >> 6)) & 0x3f) <<
shift) -
bias;
793 s[ 7] =
s[ 6] + ((((
b[11] << 4) | (
b[12] >> 4)) & 0x3f) <<
shift) -
bias;
794 s[11] =
s[10] + ((((
b[12] << 2) | (
b[13] >> 6)) & 0x3f) <<
shift) -
bias;
797 for (
i = 0;
i < 16; ++
i) {
809 s[0] = (
b[0] << 8) |
b[1];
816 for (
i = 1;
i < 16;
i++)
823 const int8_t *sr =
src;
824 int stay_to_uncompress = compressed_size;
825 int nb_b44_block_w, nb_b44_block_h;
826 int index_tl_x, index_tl_y, index_out, index_tmp;
827 uint16_t tmp_buffer[16];
829 int target_channel_offset = 0;
832 nb_b44_block_w = td->
xsize / 4;
833 if ((td->
xsize % 4) != 0)
836 nb_b44_block_h = td->
ysize / 4;
837 if ((td->
ysize % 4) != 0)
840 for (
c = 0;
c <
s->nb_channels;
c++) {
842 for (iY = 0; iY < nb_b44_block_h; iY++) {
843 for (iX = 0; iX < nb_b44_block_w; iX++) {
844 if (stay_to_uncompress < 3)
847 if (
src[compressed_size - stay_to_uncompress + 2] == 0xfc) {
850 stay_to_uncompress -= 3;
852 if (stay_to_uncompress < 14)
856 stay_to_uncompress -= 14;
863 for (y = index_tl_y; y <
FFMIN(index_tl_y + 4, td->
ysize); y++) {
864 for (x = index_tl_x; x <
FFMIN(index_tl_x + 4, td->
xsize); x++) {
866 index_tmp = (y-index_tl_y) * 4 + (x-index_tl_x);
873 target_channel_offset += 2;
875 if (stay_to_uncompress < td->ysize * td->
xsize * 4)
878 for (y = 0; y < td->
ysize; y++) {
883 target_channel_offset += 4;
885 stay_to_uncompress -= td->
ysize * td->
xsize * 4;
901 }
else if ((
val >> 8) == 0xff) {
923 float alpha[4], beta[4], theta[4], gamma[4];
941 gamma[0] = theta[0] + theta[1];
942 gamma[1] = theta[3] + theta[2];
943 gamma[2] = theta[3] - theta[2];
944 gamma[3] = theta[0] - theta[1];
946 blk[0 *
step] = gamma[0] + beta[0];
947 blk[1 *
step] = gamma[1] + beta[1];
948 blk[2 *
step] = gamma[2] + beta[2];
949 blk[3 *
step] = gamma[3] + beta[3];
951 blk[4 *
step] = gamma[3] - beta[3];
952 blk[5 *
step] = gamma[2] - beta[2];
953 blk[6 *
step] = gamma[1] - beta[1];
954 blk[7 *
step] = gamma[0] - beta[0];
959 for (
int i = 0;
i < 8;
i++)
962 for (
int i = 0;
i < 8;
i++) {
969 float *
b,
float *
g,
float *
r)
971 *
r = y + 1.5747f * v;
972 *
g = y - 0.1873f *
u - 0.4682f * v;
973 *
b = y + 1.8556f *
u;
993 int64_t ac_size, dc_size, rle_usize, rle_csize, rle_raw_size;
994 int64_t ac_count, dc_count, ac_compression;
995 const int dc_w = td->
xsize >> 3;
996 const int dc_h = td->
ysize >> 3;
1001 if (compressed_size <= 88)
1019 if ( compressed_size < (uint64_t)(lo_size | ac_size | dc_size | rle_csize) || compressed_size < 88LL + lo_size + ac_size + dc_size + rle_csize
1020 || ac_count > (uint64_t)INT_MAX/2
1024 if ((uint64_t)rle_raw_size > INT_MAX) {
1030 skip = bytestream2_get_le16(&gb);
1037 if (lo_usize > uncompressed_size)
1043 unsigned long dest_len;
1046 if (ac_count > 3LL * td->
xsize *
s->scan_lines_per_block)
1049 dest_len = ac_count * 2LL;
1055 switch (ac_compression) {
1062 if (uncompress(td->
ac_data, &dest_len, agb.
buffer, ac_size) != Z_OK ||
1063 dest_len != ac_count * 2LL)
1074 unsigned long dest_len;
1077 if (dc_count != dc_w * dc_h * 3)
1080 dest_len = dc_count * 2LL;
1087 (dest_len != dc_count * 2LL))
1096 if (rle_raw_size > 0 && rle_csize > 0 && rle_usize > 0) {
1097 unsigned long dest_len = rle_usize;
1099 if (2LL * td->
xsize * td->
ysize > rle_raw_size)
1110 if (uncompress(td->
rle_data, &dest_len, gb.
buffer, rle_csize) != Z_OK ||
1111 (dest_len != rle_usize))
1124 for (
int y = 0; y < td->
ysize; y += 8) {
1125 for (
int x = 0; x < td->
xsize; x += 8) {
1126 const int o =
s->nb_channels == 4;
1127 float *yb = td->
block[0];
1129 float *vb = td->
block[2];
1135 for (
int j = 0; j < 3; j++) {
1137 const int idx = (x >> 3) + (y >> 3) * dc_w + dc_w * dc_h * j;
1143 block[0] = dc_val.f;
1150 y * td->
xsize *
s->nb_channels + td->
xsize * (o + 0) + x;
1152 y * td->
xsize *
s->nb_channels + td->
xsize * (o + 1) + x;
1154 y * td->
xsize *
s->nb_channels + td->
xsize * (o + 2) + x;
1156 for (
int yy = 0; yy < bh; yy++) {
1157 for (
int xx = 0; xx < bw; xx++) {
1158 const int idx = xx + yy * 8;
1168 bo += td->
xsize *
s->nb_channels;
1169 go += td->
xsize *
s->nb_channels;
1170 ro += td->
xsize *
s->nb_channels;
1174 y * td->
xsize *
s->nb_channels + td->
xsize * (o + 0) + x;
1176 y * td->
xsize *
s->nb_channels + td->
xsize * (o + 1) + x;
1178 y * td->
xsize *
s->nb_channels + td->
xsize * (o + 2) + x;
1180 for (
int yy = 0; yy < bh; yy++) {
1181 for (
int xx = 0; xx < bw; xx++) {
1182 const int idx = xx + yy * 8;
1184 convert(yb[idx],
ub[idx], vb[idx], &bo[xx], &go[xx], &ro[xx]);
1191 bo += td->
xsize *
s->nb_channels;
1192 go += td->
xsize *
s->nb_channels;
1193 ro += td->
xsize *
s->nb_channels;
1199 if (
s->nb_channels < 4)
1203 for (
int y = 0; y < td->
ysize && have_rle; y++) {
1208 for (
int x = 0; x < td->
xsize; x++)
1209 ao[x] = ai0[x] | (ai1[x] << 8);
1212 for (
int y = 0; y < td->
ysize && have_rle; y++) {
1217 for (
int x = 0; x < td->
xsize; x++) {
1218 uint16_t ha = ai0[x] | (ai1[x] << 8);
1229 int jobnr,
int threadnr)
1234 const uint8_t *channel_buffer[4] = { 0 };
1235 const uint8_t *buf =
s->buf;
1236 uint64_t line_offset, uncompressed_size;
1240 uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
1242 int step =
s->desc->comp[0].step;
1243 int bxmin = 0, axmax = 0, window_xoffset = 0;
1244 int window_xmin, window_xmax, window_ymin, window_ymax;
1245 int data_xoffset, data_yoffset, data_window_offset, xsize, ysize;
1246 int i, x, buf_size =
s->buf_size;
1247 int c, rgb_channel_count;
1248 #if FF_API_EXR_GAMMA
1249 float one_gamma = 1.0f /
s->gamma;
1254 line_offset =
AV_RL64(
s->gb.buffer + jobnr * 8);
1257 if (buf_size < 20 || line_offset > buf_size - 20)
1260 src = buf + line_offset + 20;
1261 if (
s->is_multipart)
1270 if (data_size <= 0 || data_size > buf_size - line_offset - 20)
1273 if (tile_level_x || tile_level_y) {
1278 if (tile_x &&
s->tile_attr.xSize + (
int64_t)
FFMAX(
s->xmin, 0) >= INT_MAX / tile_x )
1280 if (tile_y &&
s->tile_attr.ySize + (
int64_t)
FFMAX(
s->ymin, 0) >= INT_MAX / tile_y )
1283 line =
s->ymin +
s->tile_attr.ySize * tile_y;
1284 col =
s->tile_attr.xSize * tile_x;
1287 s->xmin + col < s->xmin ||
s->xmin + col >
s->xmax)
1290 td->
ysize =
FFMIN(
s->tile_attr.ySize,
s->ydelta - tile_y *
s->tile_attr.ySize);
1291 td->
xsize =
FFMIN(
s->tile_attr.xSize,
s->xdelta - tile_x *
s->tile_attr.xSize);
1293 if (td->
xsize * (uint64_t)
s->current_channel_offset > INT_MAX ||
1300 if (buf_size < 8 || line_offset > buf_size - 8)
1303 src = buf + line_offset + 8;
1304 if (
s->is_multipart)
1312 if (data_size <= 0 || data_size > buf_size - line_offset - 8)
1318 if (td->
xsize * (uint64_t)
s->current_channel_offset > INT_MAX ||
1325 if ((
s->compression ==
EXR_RAW && (data_size != uncompressed_size ||
1326 line_offset > buf_size - uncompressed_size)) ||
1327 (
s->compression !=
EXR_RAW && (data_size > uncompressed_size ||
1328 line_offset > buf_size - data_size))) {
1337 xsize = window_xmax - window_xmin;
1338 ysize = window_ymax - window_ymin;
1341 if (xsize <= 0 || ysize <= 0)
1348 window_xoffset =
FFMAX(0,
s->xmin);
1350 bxmin = window_xoffset *
step;
1354 if(col + td->
xsize ==
s->xdelta) {
1355 window_xmax = avctx->
width;
1363 if (data_size < uncompressed_size || s->is_tile) {
1369 if (data_size < uncompressed_size) {
1377 switch (
s->compression) {
1412 if (
s->channel_offsets[3] >= 0)
1413 channel_buffer[3] =
src + (td->
xsize *
s->channel_offsets[3]) + data_window_offset;
1415 channel_buffer[0] =
src + (td->
xsize *
s->channel_offsets[0]) + data_window_offset;
1416 channel_buffer[1] =
src + (td->
xsize *
s->channel_offsets[1]) + data_window_offset;
1417 channel_buffer[2] =
src + (td->
xsize *
s->channel_offsets[2]) + data_window_offset;
1418 rgb_channel_count = 3;
1420 channel_buffer[0] =
src + (td->
xsize *
s->channel_offsets[1]) + data_window_offset;
1422 channel_buffer[1] = channel_buffer[3];
1423 rgb_channel_count = 1;
1427 for (
c = 0;
c <
s->desc->nb_components;
c++) {
1428 int plane =
s->desc->comp[
c].plane;
1429 ptr = p->
data[plane] + window_ymin * p->
linesize[plane] + (window_xmin *
step) +
s->desc->comp[
c].offset;
1432 const uint8_t *
src = channel_buffer[
c];
1433 uint8_t *ptr_x = ptr + window_xoffset *
step;
1437 memset(ptr, 0, bxmin);
1441 #if FF_API_EXR_GAMMA
1443 for (
int x = 0; x < xsize; x++, ptr_x +=
step) {
1447 }
else if (one_gamma != 1.
f) {
1448 for (
int x = 0; x < xsize; x++, ptr_x +=
step) {
1450 if (
f > 0.0
f &&
c < 3)
1456 for (
int x = 0; x < xsize; x++, ptr_x +=
step)
1460 #if FF_API_EXR_GAMMA
1462 for (
int x = 0; x < xsize; x++, ptr_x +=
step)
1463 AV_WN16A(ptr_x,
s->gamma_table[bytestream_get_le16(&
src)]);
1466 for (
int x = 0; x < xsize; x++, ptr_x +=
step)
1471 memset(ptr_x, 0, axmax);
1478 ptr = p->
data[0] + window_ymin * p->
linesize[0] + (window_xmin *
s->desc->nb_components * 2);
1480 for (
i = 0;
i < ysize;
i++, ptr += p->
linesize[0]) {
1483 const uint8_t *
rgb[3];
1486 for (
c = 0;
c < rgb_channel_count;
c++) {
1487 rgb[
c] = channel_buffer[
c];
1490 if (channel_buffer[3])
1491 a = channel_buffer[3];
1493 ptr_x = (uint16_t *) ptr;
1496 memset(ptr_x, 0, bxmin);
1497 ptr_x += window_xoffset *
s->desc->nb_components;
1499 for (x = 0; x < xsize; x++) {
1500 for (
c = 0;
c < rgb_channel_count;
c++) {
1501 *ptr_x++ = bytestream_get_le32(&
rgb[
c]) >> 16;
1504 if (channel_buffer[3])
1505 *ptr_x++ = bytestream_get_le32(&
a) >> 16;
1509 memset(ptr_x, 0, axmax);
1514 if (channel_buffer[3])
1527 if (!bytestream2_peek_byte(gb))
1531 for (
int i = 0;
i < 2;
i++)
1532 while (bytestream2_get_byte(gb) != 0);
1552 const char *value_name,
1553 const char *value_type,
1554 unsigned int minimum_length)
1560 !strcmp(gb->
buffer, value_name)) {
1562 gb->
buffer += strlen(value_name) + 1;
1563 if (!strcmp(gb->
buffer, value_type)) {
1564 gb->
buffer += strlen(value_type) + 1;
1565 var_size = bytestream2_get_le32(gb);
1571 gb->
buffer -= strlen(value_name) + 1;
1573 "Unknown data type %s for header variable %s.\n",
1574 value_type, value_name);
1586 int layer_match = 0;
1588 int dup_channels = 0;
1590 s->current_channel_offset = 0;
1597 s->channel_offsets[0] = -1;
1598 s->channel_offsets[1] = -1;
1599 s->channel_offsets[2] = -1;
1600 s->channel_offsets[3] = -1;
1606 s->tile_attr.xSize = -1;
1607 s->tile_attr.ySize = -1;
1609 s->is_multipart = 0;
1611 s->current_part = 0;
1618 magic_number = bytestream2_get_le32(gb);
1619 if (magic_number != 20000630) {
1626 version = bytestream2_get_byte(gb);
1632 flags = bytestream2_get_le24(gb);
1637 s->is_multipart = 1;
1647 while (
s->is_multipart &&
s->current_part <
s->selected_part &&
1649 if (bytestream2_peek_byte(gb)) {
1653 if (!bytestream2_peek_byte(gb))
1660 if (!bytestream2_peek_byte(gb)) {
1661 if (!
s->is_multipart)
1664 if (
s->current_part ==
s->selected_part) {
1666 if (bytestream2_peek_byte(gb)) {
1670 if (!bytestream2_peek_byte(gb))
1675 if (!bytestream2_peek_byte(gb))
1681 "chlist", 38)) >= 0) {
1693 int channel_index = -1;
1696 if (strcmp(
s->layer,
"") != 0) {
1697 if (strncmp(ch_gb.
buffer,
s->layer, strlen(
s->layer)) == 0) {
1700 "Channel match layer : %s.\n", ch_gb.
buffer);
1701 ch_gb.
buffer += strlen(
s->layer);
1702 if (*ch_gb.
buffer ==
'.')
1707 "Channel doesn't match layer : %s.\n", ch_gb.
buffer);
1735 "Unsupported channel %.256s.\n", ch_gb.
buffer);
1741 bytestream2_get_byte(&ch_gb))
1750 current_pixel_type = bytestream2_get_le32(&ch_gb);
1753 current_pixel_type);
1759 xsub = bytestream2_get_le32(&ch_gb);
1760 ysub = bytestream2_get_le32(&ch_gb);
1762 if (xsub != 1 || ysub != 1) {
1764 "Subsampling %dx%d",
1770 if (channel_index >= 0 &&
s->channel_offsets[channel_index] == -1) {
1772 s->pixel_type != current_pixel_type) {
1774 "RGB channels not of the same depth.\n");
1778 s->pixel_type = current_pixel_type;
1779 s->channel_offsets[channel_index] =
s->current_channel_offset;
1780 }
else if (channel_index >= 0) {
1782 "Multiple channels with index %d.\n", channel_index);
1783 if (++dup_channels > 10) {
1795 channel = &
s->channels[
s->nb_channels - 1];
1796 channel->pixel_type = current_pixel_type;
1800 if (current_pixel_type ==
EXR_HALF) {
1801 s->current_channel_offset += 2;
1803 s->current_channel_offset += 4;
1810 if (
FFMIN3(
s->channel_offsets[0],
1811 s->channel_offsets[1],
1812 s->channel_offsets[2]) < 0) {
1813 if (
s->channel_offsets[0] < 0)
1815 if (
s->channel_offsets[1] < 0)
1817 if (
s->channel_offsets[2] < 0)
1829 int xmin, ymin, xmax, ymax;
1835 xmin = bytestream2_get_le32(gb);
1836 ymin = bytestream2_get_le32(gb);
1837 xmax = bytestream2_get_le32(gb);
1838 ymax = bytestream2_get_le32(gb);
1840 if (xmin > xmax || ymin > ymax ||
1841 ymax == INT_MAX || xmax == INT_MAX ||
1842 (
unsigned)xmax - xmin >= INT_MAX ||
1843 (
unsigned)ymax - ymin >= INT_MAX) {
1851 s->xdelta = (
s->xmax -
s->xmin) + 1;
1852 s->ydelta = (
s->ymax -
s->ymin) + 1;
1856 "box2i", 34)) >= 0) {
1864 sx = bytestream2_get_le32(gb);
1865 sy = bytestream2_get_le32(gb);
1866 dx = bytestream2_get_le32(gb);
1867 dy = bytestream2_get_le32(gb);
1869 s->w = (unsigned)dx - sx + 1;
1870 s->h = (unsigned)dy - sy + 1;
1874 "lineOrder", 25)) >= 0) {
1881 line_order = bytestream2_get_byte(gb);
1883 if (line_order > 2) {
1891 "float", 31)) >= 0) {
1897 s->sar = bytestream2_get_le32(gb);
1901 "compression", 29)) >= 0) {
1908 s->compression = bytestream2_get_byte(gb);
1912 "Found more than one compression attribute.\n");
1917 "tiledesc", 22)) >= 0) {
1922 "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1924 s->tile_attr.xSize = bytestream2_get_le32(gb);
1925 s->tile_attr.ySize = bytestream2_get_le32(gb);
1927 tileLevel = bytestream2_get_byte(gb);
1928 s->tile_attr.level_mode = tileLevel & 0x0f;
1929 s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1933 s->tile_attr.level_mode);
1940 s->tile_attr.level_round);
1947 "string", 1)) >= 0) {
1948 uint8_t
key[256] = { 0 };
1955 "rational", 33)) >= 0) {
1961 s->avctx->framerate.num = bytestream2_get_le32(gb);
1962 s->avctx->framerate.den = bytestream2_get_le32(gb);
1968 s->chunk_count = bytestream2_get_le32(gb);
1972 "string", 16)) >= 0) {
1973 uint8_t
key[256] = { 0 };
1976 if (strncmp(
"scanlineimage",
key, var_size) &&
1977 strncmp(
"tiledimage",
key, var_size)) {
1984 "preview", 16)) >= 0) {
1985 uint32_t pw = bytestream2_get_le32(gb);
1986 uint32_t
ph = bytestream2_get_le32(gb);
1987 uint64_t psize = pw * (uint64_t)
ph;
1988 if (psize > INT64_MAX / 4) {
2013 uint8_t
name[256] = { 0 };
2014 uint8_t
type[256] = { 0 };
2015 uint8_t
value[8192] = { 0 };
2019 bytestream2_peek_byte(gb) &&
i < 255) {
2020 name[
i++] = bytestream2_get_byte(gb);
2026 bytestream2_peek_byte(gb) &&
i < 255) {
2027 type[
i++] = bytestream2_get_byte(gb);
2030 size = bytestream2_get_le32(gb);
2035 if (!strcmp(
type,
"string"))
2047 if (
s->tile_attr.xSize < 1 ||
s->tile_attr.ySize < 1) {
2077 int i, y,
ret, ymax;
2081 uint64_t start_offset_table;
2082 uint64_t start_next_scanline;
2089 switch (
s->pixel_type) {
2091 if (
s->channel_offsets[3] >= 0) {
2106 if (
s->channel_offsets[3] >= 0) {
2121 if (
s->channel_offsets[3] >= 0) {
2140 #if FF_API_EXR_GAMMA
2143 else if (
s->gamma > 0.9999f &&
s->gamma < 1.0001f)
2147 switch (
s->compression) {
2151 s->scan_lines_per_block = 1;
2155 s->scan_lines_per_block = 16;
2161 s->scan_lines_per_block = 32;
2164 s->scan_lines_per_block = 256;
2173 if (
s->xmin >
s->xmax ||
s->ymin >
s->ymax ||
2174 s->ydelta == 0xFFFFFFFF ||
s->xdelta == 0xFFFFFFFF) {
2192 out_line_size = avctx->
width *
s->desc->comp[0].step;
2195 nb_blocks = ((
s->xdelta +
s->tile_attr.xSize - 1) /
s->tile_attr.xSize) *
2196 ((
s->ydelta +
s->tile_attr.ySize - 1) /
s->tile_attr.ySize);
2198 nb_blocks = (
s->ydelta +
s->scan_lines_per_block - 1) /
2199 s->scan_lines_per_block;
2209 if (!
s->is_tile && bytestream2_peek_le64(gb) == 0) {
2215 if (!
s->offset_table)
2219 start_next_scanline = start_offset_table + nb_blocks * 8;
2222 for (y = 0; y < nb_blocks; y++) {
2224 bytestream2_put_le64(&offset_table_writer, start_next_scanline);
2228 start_next_scanline += (bytestream2_get_le32(gb) + 8);
2234 s->buf = avpkt->
data;
2235 s->buf_size = avpkt->
size;
2239 ptr = picture->
data[
i];
2240 for (y = 0; y <
FFMIN(
s->ymin,
s->h); y++) {
2241 memset(ptr, 0, out_line_size);
2246 s->picture = picture;
2250 ymax =
FFMAX(0,
s->ymax + 1);
2252 if (ymax < avctx->
height)
2255 for (y = ymax; y < avctx->
height; y++) {
2256 memset(ptr, 0, out_line_size);
2270 #if FF_API_EXR_GAMMA
2273 float one_gamma = 1.0
f /
s->gamma;
2288 #if FF_API_EXR_GAMMA
2291 for (
i = 0;
i < 65536; ++
i) {
2293 t.
f = trc_func(t.
f);
2296 }
else if (one_gamma != 1.0
f) {
2297 for (
i = 0;
i < 65536; ++
i) {
2301 s->gamma_table[
i] =
i;
2303 t.
f =
powf(t.
f, one_gamma);
2312 if (!
s->thread_data)
2344 #define OFFSET(x) offsetof(EXRContext, x)
2345 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2347 {
"layer",
"Set the decoding layer",
OFFSET(layer),
2349 {
"part",
"Set the decoding part",
OFFSET(selected_part),
2351 #if FF_API_EXR_GAMMA
2352 {
"gamma",
"Set the float gamma value when decoding (deprecated, use a scaler)",
OFFSET(gamma),
2356 {
"apply_trc",
"color transfer characteristics to apply to EXR linear input (deprecated, use a scaler)",
OFFSET(apply_trc_type),
2358 {
"bt709",
"BT.709", 0,
2360 {
"gamma",
"gamma", 0,
2362 {
"gamma22",
"BT.470 M", 0,
2364 {
"gamma28",
"BT.470 BG", 0,
2366 {
"smpte170m",
"SMPTE 170 M", 0,
2368 {
"smpte240m",
"SMPTE 240 M", 0,
2370 {
"linear",
"Linear", 0,
2374 {
"log_sqrt",
"Log square root", 0,
2376 {
"iec61966_2_4",
"IEC 61966-2-4", 0,
2378 {
"bt1361",
"BT.1361", 0,
2380 {
"iec61966_2_1",
"IEC 61966-2-1", 0,
2382 {
"bt2020_10bit",
"BT.2020 - 10 bit", 0,
2384 {
"bt2020_12bit",
"BT.2020 - 12 bit", 0,
2386 {
"smpte2084",
"SMPTE ST 2084", 0,
2388 {
"smpte428_1",
"SMPTE ST 428-1", 0,
enum ExrTileLevelRound level_round
#define AV_LOG_WARNING
Something somehow does not look correct.
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 int get_bits_left(GetBitContext *gb)
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
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
AVColorTransferCharacteristic
Color Transfer Characteristic.
void ff_init_float2half_tables(Float2HalfTables *t)
uint8_t * uncompressed_data
static av_always_inline int bytestream2_tell(const GetByteContext *g)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
static int decode_header(EXRContext *s, AVFrame *frame)
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
static int get_bits_count(const GetBitContext *s)
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
This structure describes decoded (raw) audio or video data.
@ AVCOL_TRC_NB
Not part of ABI.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
#define u(width, name, range_min, range_max)
static av_cold int decode_init(AVCodecContext *avctx)
static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
static int piz_uncompress(const EXRContext *s, const uint8_t *src, int ssize, int dsize, EXRThreadData *td)
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
static const AVOption options[]
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 int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int b44_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
static int rle(uint8_t *dst, const uint8_t *src, int compressed_size, int uncompressed_size)
static void convert(float y, float u, float v, float *b, float *g, float *r)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
av_csp_trc_function av_csp_trc_func_from_id(enum AVColorTransferCharacteristic trc)
Determine the function needed to apply the given AVColorTransferCharacteristic to linear input.
static av_cold void close(AVCodecParserContext *s)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
EXRTileAttribute tile_attr
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
AVCodec p
The public AVCodec.
static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
enum AVDiscard skip_frame
Skip decoding for selected frames.
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
static double val(void *priv, double ch)
#define AV_PIX_FMT_GRAYF16
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
#define AV_PIX_FMT_GRAY16
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
static __device__ float fabsf(float a)
const FFCodec ff_exr_decoder
static int huf_build_dec_table(const EXRContext *s, EXRThreadData *td, int im, int iM)
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
static float to_linear(float x, float scale)
static av_cold int decode_end(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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)
enum ExrCompr compression
#define FF_CODEC_DECODE_CB(func)
static int check_header_variable(EXRContext *s, const char *value_name, const char *value_type, unsigned int minimum_length)
Check if the variable name corresponds to its data type.
static void huf_canonical_code_table(uint64_t *freq)
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
int current_channel_offset
static int decode_block(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
enum ExrPixelType pixel_type
uint16_t gamma_table[65536]
int64_t max_pixels
The number of pixels per image to maximally accept.
#define SHORTEST_LONG_RUN
static void skip_header_chunk(EXRContext *s)
#define AV_PIX_FMT_GRAYF32
#define CODEC_LONG_NAME(str)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
const AVPixFmtDescriptor * desc
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
@ AVDISCARD_ALL
discard all
#define av_realloc_f(p, o, n)
#define AV_PIX_FMT_RGBA64
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int bias(int x, int c)
#define LONG_ZEROCODE_RUN
#define SHORT_ZEROCODE_RUN
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
av_cold void ff_exrdsp_init(ExrDSPContext *c)
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
static void unpack_14(const uint8_t b[14], uint16_t s[16])
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
#define AV_PIX_FMT_GBRPF16
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
Float2HalfTables f2h_tables
enum ExrPixelType pixel_type
enum ExrTileLevelMode level_mode
EXRThreadData * thread_data
enum AVPictureType pict_type
Picture type of the frame.
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
static void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
static void wav_decode(uint16_t *in, int nx, int ox, int ny, int oy, uint16_t mx)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
static int dwa_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
static int shift(int a, int b)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
#define bytestream2_get_ne16
#define AV_PIX_FMT_GBRPF32
#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.
static int ac_uncompress(const EXRContext *s, GetByteContext *gb, float *block)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
static void idct_1d(float *blk, int step)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
enum AVColorTransferCharacteristic apply_trc_type
int ff_vlc_init_sparse(VLC *vlc, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Build VLC decoding tables suitable for use with get_vlc2().
static void unpack_3(const uint8_t b[3], uint16_t s[16])
#define AV_LOG_INFO
Standard information.
@ AVCOL_TRC_BT709
also ITU-R BT1361
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
static const struct @513 planes[]
static void dct_inverse(float *block)
double(* av_csp_trc_function)(double)
Function pointer representing a double -> double transfer function that performs either an OETF trans...
#define AV_OPT_FLAG_DEPRECATED
Set if option is deprecated, users should refer to AVOption.help text for more information.
Half2FloatTables h2f_tables
#define i(width, name, range_min, range_max)
#define av_malloc_array(a, b)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
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
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
const char * name
Name of the codec implementation.
static int huf_unpack_enc_table(GetByteContext *gb, int32_t im, int32_t iM, uint64_t *freq)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
const uint8_t ff_zigzag_direct[64]
void ff_vlc_free(VLC *vlc)
static int huf_decode(VLC *vlc, GetByteContext *gb, int nbits, int run_sym, int no, uint16_t *out)
static uint32_t half2float(uint16_t h, const Half2FloatTables *t)
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
void ff_init_half2float_tables(Half2FloatTables *t)
static int rle_uncompress(const EXRContext *ctx, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
static uint16_t float2half(uint32_t f, const Float2HalfTables *t)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
main external API structure.
static int pxr24_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
static void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
@ AV_OPT_TYPE_INT
Underlying C type is int.
#define AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF16
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
#define avpriv_request_sample(...)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static int huf_uncompress(const EXRContext *s, EXRThreadData *td, GetByteContext *gb, uint16_t *dst, int dst_size)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static const int16_t alpha[]
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 zip_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
int width
picture width / height.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
The exact code depends on how similar the blocks are and how related they are to the block
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static const AVClass exr_class
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
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
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.