FFmpeg
exr.c
Go to the documentation of this file.
1 /*
2  * OpenEXR (.exr) image decoder
3  * Copyright (c) 2006 Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
4  * Copyright (c) 2009 Jimmy Christensen
5  *
6  * B44/B44A, Tile, UINT32 added by Jokyo Images support by CNC - French National Center for Cinema
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * OpenEXR decoder
28  * @author Jimmy Christensen
29  *
30  * For more information on the OpenEXR format, visit:
31  * http://openexr.com/
32  */
33 
34 #include <float.h>
35 #include <zlib.h>
36 
37 #include "libavutil/avassert.h"
38 #include "libavutil/common.h"
39 #include "libavutil/csp.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/intfloat.h"
42 #include "libavutil/avstring.h"
43 #include "libavutil/opt.h"
44 #include "libavutil/half2float.h"
45 
46 #include "avcodec.h"
47 #include "bytestream.h"
48 
49 #if HAVE_BIGENDIAN
50 #include "bswapdsp.h"
51 #endif
52 
53 #include "codec_internal.h"
54 #include "decode.h"
55 #include "exrdsp.h"
56 #include "get_bits.h"
57 #include "mathops.h"
58 #include "thread.h"
59 
60 enum ExrCompr {
72 };
73 
79 };
80 
86 };
87 
92 };
93 
94 typedef struct HuffEntry {
95  uint8_t len;
96  uint16_t sym;
97  uint32_t code;
98 } HuffEntry;
99 
100 typedef struct EXRChannel {
101  int xsub, ysub;
103 } EXRChannel;
104 
105 typedef struct EXRTileAttribute {
111 
112 typedef struct EXRThreadData {
115 
116  uint8_t *tmp;
117  int tmp_size;
118 
119  uint8_t *bitmap;
120  uint16_t *lut;
121 
122  uint8_t *ac_data;
123  unsigned ac_size;
124 
125  uint8_t *dc_data;
126  unsigned dc_size;
127 
128  uint8_t *rle_data;
129  unsigned rle_size;
130 
131  uint8_t *rle_raw_data;
132  unsigned rle_raw_size;
133 
134  float block[3][64];
135 
136  int ysize, xsize;
137 
139 
140  int run_sym;
142  uint64_t *freq;
144 } EXRThreadData;
145 
146 typedef struct EXRContext {
147  AVClass *class;
151 
152 #if HAVE_BIGENDIAN
153  BswapDSPContext bbdsp;
154 #endif
155 
158  int channel_offsets[4]; // 0 = red, 1 = green, 2 = blue and 3 = alpha
160 
161  int w, h;
162  uint32_t sar;
165  uint32_t xdelta, ydelta;
166 
168 
169  EXRTileAttribute tile_attr; /* header data attribute of tile */
170  int is_tile; /* 0 if scanline, 1 if tile */
173 
174  int is_luma;/* 1 if there is an Y plane */
175 
177  const uint8_t *buf;
178  int buf_size;
179 
183  uint32_t chunk_count;
184 
186 
187  const char *layer;
189 
191  float gamma;
193 
194  uint8_t *offset_table;
195 
197 } EXRContext;
198 
199 static int zip_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size,
200  int uncompressed_size, EXRThreadData *td)
201 {
202  unsigned long dest_len = uncompressed_size;
203 
204  if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK ||
205  dest_len != uncompressed_size)
206  return AVERROR_INVALIDDATA;
207 
208  av_assert1(uncompressed_size % 2 == 0);
209 
210  s->dsp.predictor(td->tmp, uncompressed_size);
211  s->dsp.reorder_pixels(td->uncompressed_data, td->tmp, uncompressed_size);
212 
213  return 0;
214 }
215 
216 static int rle(uint8_t *dst, const uint8_t *src,
217  int compressed_size, int uncompressed_size)
218 {
219  uint8_t *d = dst;
220  const int8_t *s = src;
221  int ssize = compressed_size;
222  int dsize = uncompressed_size;
223  uint8_t *dend = d + dsize;
224  int count;
225 
226  while (ssize > 0) {
227  count = *s++;
228 
229  if (count < 0) {
230  count = -count;
231 
232  if ((dsize -= count) < 0 ||
233  (ssize -= count + 1) < 0)
234  return AVERROR_INVALIDDATA;
235 
236  while (count--)
237  *d++ = *s++;
238  } else {
239  count++;
240 
241  if ((dsize -= count) < 0 ||
242  (ssize -= 2) < 0)
243  return AVERROR_INVALIDDATA;
244 
245  while (count--)
246  *d++ = *s;
247 
248  s++;
249  }
250  }
251 
252  if (dend != d)
253  return AVERROR_INVALIDDATA;
254 
255  return 0;
256 }
257 
258 static int rle_uncompress(const EXRContext *ctx, const uint8_t *src, int compressed_size,
259  int uncompressed_size, EXRThreadData *td)
260 {
261  rle(td->tmp, src, compressed_size, uncompressed_size);
262 
263  av_assert1(uncompressed_size % 2 == 0);
264 
265  ctx->dsp.predictor(td->tmp, uncompressed_size);
266  ctx->dsp.reorder_pixels(td->uncompressed_data, td->tmp, uncompressed_size);
267 
268  return 0;
269 }
270 
271 #define USHORT_RANGE (1 << 16)
272 #define BITMAP_SIZE (1 << 13)
273 
274 static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
275 {
276  int i, k = 0;
277 
278  for (i = 0; i < USHORT_RANGE; i++)
279  if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
280  lut[k++] = i;
281 
282  i = k - 1;
283 
284  memset(lut + k, 0, (USHORT_RANGE - k) * 2);
285 
286  return i;
287 }
288 
289 static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
290 {
291  int i;
292 
293  for (i = 0; i < dsize; ++i)
294  dst[i] = lut[dst[i]];
295 }
296 
297 #define HUF_ENCBITS 16 // literal (value) bit length
298 #define HUF_ENCSIZE ((1 << HUF_ENCBITS) + 1) // encoding table size
299 
300 static void huf_canonical_code_table(uint64_t *freq)
301 {
302  uint64_t c, n[59] = { 0 };
303  int i;
304 
305  for (i = 0; i < HUF_ENCSIZE; i++)
306  n[freq[i]] += 1;
307 
308  c = 0;
309  for (i = 58; i > 0; --i) {
310  uint64_t nc = ((c + n[i]) >> 1);
311  n[i] = c;
312  c = nc;
313  }
314 
315  for (i = 0; i < HUF_ENCSIZE; ++i) {
316  int l = freq[i];
317 
318  if (l > 0)
319  freq[i] = l | (n[l]++ << 6);
320  }
321 }
322 
323 #define SHORT_ZEROCODE_RUN 59
324 #define LONG_ZEROCODE_RUN 63
325 #define SHORTEST_LONG_RUN (2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN)
326 #define LONGEST_LONG_RUN (255 + SHORTEST_LONG_RUN)
327 
329  int32_t im, int32_t iM, uint64_t *freq)
330 {
331  GetBitContext gbit;
332  int ret = init_get_bits8(&gbit, gb->buffer, bytestream2_get_bytes_left(gb));
333  if (ret < 0)
334  return ret;
335 
336  for (; im <= iM; im++) {
337  uint64_t l = freq[im] = get_bits(&gbit, 6);
338 
339  if (l == LONG_ZEROCODE_RUN) {
340  int zerun = get_bits(&gbit, 8) + SHORTEST_LONG_RUN;
341 
342  if (im + zerun > iM + 1)
343  return AVERROR_INVALIDDATA;
344 
345  while (zerun--)
346  freq[im++] = 0;
347 
348  im--;
349  } else if (l >= SHORT_ZEROCODE_RUN) {
350  int zerun = l - SHORT_ZEROCODE_RUN + 2;
351 
352  if (im + zerun > iM + 1)
353  return AVERROR_INVALIDDATA;
354 
355  while (zerun--)
356  freq[im++] = 0;
357 
358  im--;
359  }
360  }
361 
362  bytestream2_skip(gb, (get_bits_count(&gbit) + 7) / 8);
364 
365  return 0;
366 }
367 
368 static int huf_build_dec_table(const EXRContext *s,
369  EXRThreadData *td, int im, int iM)
370 {
371  int j = 0;
372 
373  td->run_sym = -1;
374  for (int i = im; i < iM; i++) {
375  td->he[j].sym = i;
376  td->he[j].len = td->freq[i] & 63;
377  td->he[j].code = td->freq[i] >> 6;
378  if (td->he[j].len > 32) {
379  avpriv_request_sample(s->avctx, "Too big code length");
380  return AVERROR_PATCHWELCOME;
381  }
382  if (td->he[j].len > 0)
383  j++;
384  else
385  td->run_sym = i;
386  }
387 
388  if (im > 0)
389  td->run_sym = 0;
390  else if (iM < 65535)
391  td->run_sym = 65535;
392 
393  if (td->run_sym == -1) {
394  avpriv_request_sample(s->avctx, "No place for run symbol");
395  return AVERROR_PATCHWELCOME;
396  }
397 
398  td->he[j].sym = td->run_sym;
399  td->he[j].len = td->freq[iM] & 63;
400  if (td->he[j].len > 32) {
401  avpriv_request_sample(s->avctx, "Too big code length");
402  return AVERROR_PATCHWELCOME;
403  }
404  td->he[j].code = td->freq[iM] >> 6;
405  j++;
406 
407  ff_vlc_free(&td->vlc);
408  return ff_vlc_init_sparse(&td->vlc, 12, j,
409  &td->he[0].len, sizeof(td->he[0]), sizeof(td->he[0].len),
410  &td->he[0].code, sizeof(td->he[0]), sizeof(td->he[0].code),
411  &td->he[0].sym, sizeof(td->he[0]), sizeof(td->he[0].sym), 0);
412 }
413 
414 static int huf_decode(VLC *vlc, GetByteContext *gb, int nbits, int run_sym,
415  int no, uint16_t *out)
416 {
417  GetBitContext gbit;
418  int oe = 0;
419 
420  init_get_bits(&gbit, gb->buffer, nbits);
421  while (get_bits_left(&gbit) > 0 && oe < no) {
422  uint16_t x = get_vlc2(&gbit, vlc->table, 12, 3);
423 
424  if (x == run_sym) {
425  int run = get_bits(&gbit, 8);
426  uint16_t fill;
427 
428  if (oe == 0 || oe + run > no)
429  return AVERROR_INVALIDDATA;
430 
431  fill = out[oe - 1];
432 
433  while (run-- > 0)
434  out[oe++] = fill;
435  } else {
436  out[oe++] = x;
437  }
438  }
439 
440  return 0;
441 }
442 
443 static int huf_uncompress(const EXRContext *s,
444  EXRThreadData *td,
445  GetByteContext *gb,
446  uint16_t *dst, int dst_size)
447 {
448  int32_t im, iM;
449  uint32_t nBits;
450  int ret;
451 
452  im = bytestream2_get_le32(gb);
453  iM = bytestream2_get_le32(gb);
454  bytestream2_skip(gb, 4);
455  nBits = bytestream2_get_le32(gb);
456  if (im < 0 || im >= HUF_ENCSIZE ||
457  iM < 0 || iM >= HUF_ENCSIZE)
458  return AVERROR_INVALIDDATA;
459 
460  bytestream2_skip(gb, 4);
461 
462  if (!td->freq)
463  td->freq = av_malloc_array(HUF_ENCSIZE, sizeof(*td->freq));
464  if (!td->he)
465  td->he = av_calloc(HUF_ENCSIZE, sizeof(*td->he));
466  if (!td->freq || !td->he) {
467  ret = AVERROR(ENOMEM);
468  return ret;
469  }
470 
471  memset(td->freq, 0, sizeof(*td->freq) * HUF_ENCSIZE);
472  if ((ret = huf_unpack_enc_table(gb, im, iM, td->freq)) < 0)
473  return ret;
474 
475  if (nBits > 8 * bytestream2_get_bytes_left(gb)) {
477  return ret;
478  }
479 
480  if ((ret = huf_build_dec_table(s, td, im, iM)) < 0)
481  return ret;
482  return huf_decode(&td->vlc, gb, nBits, td->run_sym, dst_size, dst);
483 }
484 
485 static inline void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
486 {
487  int16_t ls = l;
488  int16_t hs = h;
489  int hi = hs;
490  int ai = ls + (hi & 1) + (hi >> 1);
491  int16_t as = ai;
492  int16_t bs = ai - hi;
493 
494  *a = as;
495  *b = bs;
496 }
497 
498 #define NBITS 16
499 #define A_OFFSET (1 << (NBITS - 1))
500 #define MOD_MASK ((1 << NBITS) - 1)
501 
502 static inline void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
503 {
504  int m = l;
505  int d = h;
506  int bb = (m - (d >> 1)) & MOD_MASK;
507  int aa = (d + bb - A_OFFSET) & MOD_MASK;
508  *b = bb;
509  *a = aa;
510 }
511 
512 static void wav_decode(uint16_t *in, int nx, int ox,
513  int ny, int oy, uint16_t mx)
514 {
515  int w14 = (mx < (1 << 14));
516  int n = (nx > ny) ? ny : nx;
517  int p = 1;
518  int p2;
519 
520  while (p <= n)
521  p <<= 1;
522 
523  p >>= 1;
524  p2 = p;
525  p >>= 1;
526 
527  while (p >= 1) {
528  uint16_t *py = in;
529  uint16_t *ey = in + oy * (ny - p2);
530  uint16_t i00, i01, i10, i11;
531  int oy1 = oy * p;
532  int oy2 = oy * p2;
533  int ox1 = ox * p;
534  int ox2 = ox * p2;
535 
536  for (; py <= ey; py += oy2) {
537  uint16_t *px = py;
538  uint16_t *ex = py + ox * (nx - p2);
539 
540  for (; px <= ex; px += ox2) {
541  uint16_t *p01 = px + ox1;
542  uint16_t *p10 = px + oy1;
543  uint16_t *p11 = p10 + ox1;
544 
545  if (w14) {
546  wdec14(*px, *p10, &i00, &i10);
547  wdec14(*p01, *p11, &i01, &i11);
548  wdec14(i00, i01, px, p01);
549  wdec14(i10, i11, p10, p11);
550  } else {
551  wdec16(*px, *p10, &i00, &i10);
552  wdec16(*p01, *p11, &i01, &i11);
553  wdec16(i00, i01, px, p01);
554  wdec16(i10, i11, p10, p11);
555  }
556  }
557 
558  if (nx & p) {
559  uint16_t *p10 = px + oy1;
560 
561  if (w14)
562  wdec14(*px, *p10, &i00, p10);
563  else
564  wdec16(*px, *p10, &i00, p10);
565 
566  *px = i00;
567  }
568  }
569 
570  if (ny & p) {
571  uint16_t *px = py;
572  uint16_t *ex = py + ox * (nx - p2);
573 
574  for (; px <= ex; px += ox2) {
575  uint16_t *p01 = px + ox1;
576 
577  if (w14)
578  wdec14(*px, *p01, &i00, p01);
579  else
580  wdec16(*px, *p01, &i00, p01);
581 
582  *px = i00;
583  }
584  }
585 
586  p2 = p;
587  p >>= 1;
588  }
589 }
590 
591 static int piz_uncompress(const EXRContext *s, const uint8_t *src, int ssize,
592  int dsize, EXRThreadData *td)
593 {
594  GetByteContext gb;
595  uint16_t maxval, min_non_zero, max_non_zero;
596  uint16_t *ptr;
597  uint16_t *tmp = (uint16_t *)td->tmp;
598  uint16_t *out;
599  uint16_t *in;
600  int ret, i, j;
601  int pixel_half_size;/* 1 for half, 2 for float and uint32 */
603  int tmp_offset;
604 
605  if (!td->bitmap)
606  td->bitmap = av_malloc(BITMAP_SIZE);
607  if (!td->lut)
608  td->lut = av_malloc(1 << 17);
609  if (!td->bitmap || !td->lut) {
610  av_freep(&td->bitmap);
611  av_freep(&td->lut);
612  return AVERROR(ENOMEM);
613  }
614 
615  bytestream2_init(&gb, src, ssize);
616  min_non_zero = bytestream2_get_le16(&gb);
617  max_non_zero = bytestream2_get_le16(&gb);
618 
619  if (max_non_zero >= BITMAP_SIZE)
620  return AVERROR_INVALIDDATA;
621 
622  memset(td->bitmap, 0, FFMIN(min_non_zero, BITMAP_SIZE));
623  if (min_non_zero <= max_non_zero)
624  bytestream2_get_buffer(&gb, td->bitmap + min_non_zero,
625  max_non_zero - min_non_zero + 1);
626  memset(td->bitmap + max_non_zero + 1, 0, BITMAP_SIZE - max_non_zero - 1);
627 
628  maxval = reverse_lut(td->bitmap, td->lut);
629 
630  bytestream2_skip(&gb, 4);
631  ret = huf_uncompress(s, td, &gb, tmp, dsize / sizeof(uint16_t));
632  if (ret)
633  return ret;
634 
635  ptr = tmp;
636  for (i = 0; i < s->nb_channels; i++) {
637  channel = &s->channels[i];
638 
639  if (channel->pixel_type == EXR_HALF)
640  pixel_half_size = 1;
641  else
642  pixel_half_size = 2;
643 
644  for (j = 0; j < pixel_half_size; j++)
645  wav_decode(ptr + j, td->xsize, pixel_half_size, td->ysize,
646  td->xsize * pixel_half_size, maxval);
647  ptr += td->xsize * td->ysize * pixel_half_size;
648  }
649 
650  apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));
651 
652  out = (uint16_t *)td->uncompressed_data;
653  for (i = 0; i < td->ysize; i++) {
654  tmp_offset = 0;
655  for (j = 0; j < s->nb_channels; j++) {
656  channel = &s->channels[j];
657  if (channel->pixel_type == EXR_HALF)
658  pixel_half_size = 1;
659  else
660  pixel_half_size = 2;
661 
662  in = tmp + tmp_offset * td->xsize * td->ysize + i * td->xsize * pixel_half_size;
663  tmp_offset += pixel_half_size;
664 
665 #if HAVE_BIGENDIAN
666  s->bbdsp.bswap16_buf(out, in, td->xsize * pixel_half_size);
667 #else
668  memcpy(out, in, td->xsize * 2 * pixel_half_size);
669 #endif
670  out += td->xsize * pixel_half_size;
671  }
672  }
673 
674  return 0;
675 }
676 
677 static int pxr24_uncompress(const EXRContext *s, const uint8_t *src,
678  int compressed_size, int uncompressed_size,
679  EXRThreadData *td)
680 {
681  unsigned long dest_len, expected_len = 0;
682  const uint8_t *in = td->tmp;
683  uint8_t *out;
684  int c, i, j;
685 
686  for (i = 0; i < s->nb_channels; i++) {
687  if (s->channels[i].pixel_type == EXR_FLOAT) {
688  expected_len += (td->xsize * td->ysize * 3);/* PRX 24 store float in 24 bit instead of 32 */
689  } else if (s->channels[i].pixel_type == EXR_HALF) {
690  expected_len += (td->xsize * td->ysize * 2);
691  } else {//UINT 32
692  expected_len += (td->xsize * td->ysize * 4);
693  }
694  }
695 
696  dest_len = expected_len;
697 
698  if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK) {
699  return AVERROR_INVALIDDATA;
700  } else if (dest_len != expected_len) {
701  return AVERROR_INVALIDDATA;
702  }
703 
704  out = td->uncompressed_data;
705  for (i = 0; i < td->ysize; i++)
706  for (c = 0; c < s->nb_channels; c++) {
707  EXRChannel *channel = &s->channels[c];
708  const uint8_t *ptr[4];
709  uint32_t pixel = 0;
710 
711  switch (channel->pixel_type) {
712  case EXR_FLOAT:
713  ptr[0] = in;
714  ptr[1] = ptr[0] + td->xsize;
715  ptr[2] = ptr[1] + td->xsize;
716  in = ptr[2] + td->xsize;
717 
718  for (j = 0; j < td->xsize; ++j) {
719  uint32_t diff = ((unsigned)*(ptr[0]++) << 24) |
720  (*(ptr[1]++) << 16) |
721  (*(ptr[2]++) << 8);
722  pixel += diff;
723  bytestream_put_le32(&out, pixel);
724  }
725  break;
726  case EXR_HALF:
727  ptr[0] = in;
728  ptr[1] = ptr[0] + td->xsize;
729  in = ptr[1] + td->xsize;
730  for (j = 0; j < td->xsize; j++) {
731  uint32_t diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
732 
733  pixel += diff;
734  bytestream_put_le16(&out, pixel);
735  }
736  break;
737  case EXR_UINT:
738  ptr[0] = in;
739  ptr[1] = ptr[0] + s->xdelta;
740  ptr[2] = ptr[1] + s->xdelta;
741  ptr[3] = ptr[2] + s->xdelta;
742  in = ptr[3] + s->xdelta;
743 
744  for (j = 0; j < s->xdelta; ++j) {
745  uint32_t diff = ((uint32_t)*(ptr[0]++) << 24) |
746  (*(ptr[1]++) << 16) |
747  (*(ptr[2]++) << 8 ) |
748  (*(ptr[3]++));
749  pixel += diff;
750  bytestream_put_le32(&out, pixel);
751  }
752  break;
753  default:
754  return AVERROR_INVALIDDATA;
755  }
756  }
757 
758  return 0;
759 }
760 
761 static void unpack_14(const uint8_t b[14], uint16_t s[16])
762 {
763  uint16_t shift = (b[ 2] >> 2) & 15;
764  uint16_t bias = (0x20 << shift);
765  int i;
766 
767  s[ 0] = (b[0] << 8) | b[1];
768 
769  s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
770  s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
771  s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
772 
773  s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
774  s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
775  s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
776  s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
777 
778  s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
779  s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
780  s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
781  s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
782 
783  s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
784  s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
785  s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
786  s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
787 
788  for (i = 0; i < 16; ++i) {
789  if (s[i] & 0x8000)
790  s[i] &= 0x7fff;
791  else
792  s[i] = ~s[i];
793  }
794 }
795 
796 static void unpack_3(const uint8_t b[3], uint16_t s[16])
797 {
798  int i;
799 
800  s[0] = (b[0] << 8) | b[1];
801 
802  if (s[0] & 0x8000)
803  s[0] &= 0x7fff;
804  else
805  s[0] = ~s[0];
806 
807  for (i = 1; i < 16; i++)
808  s[i] = s[0];
809 }
810 
811 
812 static int b44_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size,
813  int uncompressed_size, EXRThreadData *td) {
814  const int8_t *sr = src;
815  int stay_to_uncompress = compressed_size;
816  int nb_b44_block_w, nb_b44_block_h;
817  int index_tl_x, index_tl_y, index_out, index_tmp;
818  uint16_t tmp_buffer[16]; /* B44 use 4x4 half float pixel */
819  int c, iY, iX, y, x;
820  int target_channel_offset = 0;
821 
822  /* calc B44 block count */
823  nb_b44_block_w = td->xsize / 4;
824  if ((td->xsize % 4) != 0)
825  nb_b44_block_w++;
826 
827  nb_b44_block_h = td->ysize / 4;
828  if ((td->ysize % 4) != 0)
829  nb_b44_block_h++;
830 
831  for (c = 0; c < s->nb_channels; c++) {
832  if (s->channels[c].pixel_type == EXR_HALF) {/* B44 only compress half float data */
833  for (iY = 0; iY < nb_b44_block_h; iY++) {
834  for (iX = 0; iX < nb_b44_block_w; iX++) {/* For each B44 block */
835  if (stay_to_uncompress < 3)
836  return AVERROR_INVALIDDATA;
837 
838  if (src[compressed_size - stay_to_uncompress + 2] == 0xfc) { /* B44A block */
839  unpack_3(sr, tmp_buffer);
840  sr += 3;
841  stay_to_uncompress -= 3;
842  } else {/* B44 Block */
843  if (stay_to_uncompress < 14)
844  return AVERROR_INVALIDDATA;
845  unpack_14(sr, tmp_buffer);
846  sr += 14;
847  stay_to_uncompress -= 14;
848  }
849 
850  /* copy data to uncompress buffer (B44 block can exceed target resolution)*/
851  index_tl_x = iX * 4;
852  index_tl_y = iY * 4;
853 
854  for (y = index_tl_y; y < FFMIN(index_tl_y + 4, td->ysize); y++) {
855  for (x = index_tl_x; x < FFMIN(index_tl_x + 4, td->xsize); x++) {
856  index_out = target_channel_offset * td->xsize + y * td->channel_line_size + 2 * x;
857  index_tmp = (y-index_tl_y) * 4 + (x-index_tl_x);
858  td->uncompressed_data[index_out] = tmp_buffer[index_tmp] & 0xff;
859  td->uncompressed_data[index_out + 1] = tmp_buffer[index_tmp] >> 8;
860  }
861  }
862  }
863  }
864  target_channel_offset += 2;
865  } else {/* Float or UINT 32 channel */
866  if (stay_to_uncompress < td->ysize * td->xsize * 4)
867  return AVERROR_INVALIDDATA;
868 
869  for (y = 0; y < td->ysize; y++) {
870  index_out = target_channel_offset * td->xsize + y * td->channel_line_size;
871  memcpy(&td->uncompressed_data[index_out], sr, td->xsize * 4);
872  sr += td->xsize * 4;
873  }
874  target_channel_offset += 4;
875 
876  stay_to_uncompress -= td->ysize * td->xsize * 4;
877  }
878  }
879 
880  return 0;
881 }
882 
883 static int ac_uncompress(const EXRContext *s, GetByteContext *gb, float *block)
884 {
885  int ret = 0, n = 1;
886 
887  while (n < 64) {
888  uint16_t val = bytestream2_get_ne16(gb);
889 
890  if (val == 0xff00) {
891  n = 64;
892  } else if ((val >> 8) == 0xff) {
893  n += val & 0xff;
894  } else {
895  ret = n;
896  block[ff_zigzag_direct[n]] = av_int2float(half2float(val, &s->h2f_tables));
897  n++;
898  }
899  }
900 
901  return ret;
902 }
903 
904 static void idct_1d(float *blk, int step)
905 {
906  const float a = .5f * cosf( M_PI / 4.f);
907  const float b = .5f * cosf( M_PI / 16.f);
908  const float c = .5f * cosf( M_PI / 8.f);
909  const float d = .5f * cosf(3.f*M_PI / 16.f);
910  const float e = .5f * cosf(5.f*M_PI / 16.f);
911  const float f = .5f * cosf(3.f*M_PI / 8.f);
912  const float g = .5f * cosf(7.f*M_PI / 16.f);
913 
914  float alpha[4], beta[4], theta[4], gamma[4];
915 
916  alpha[0] = c * blk[2 * step];
917  alpha[1] = f * blk[2 * step];
918  alpha[2] = c * blk[6 * step];
919  alpha[3] = f * blk[6 * step];
920 
921  beta[0] = b * blk[1 * step] + d * blk[3 * step] + e * blk[5 * step] + g * blk[7 * step];
922  beta[1] = d * blk[1 * step] - g * blk[3 * step] - b * blk[5 * step] - e * blk[7 * step];
923  beta[2] = e * blk[1 * step] - b * blk[3 * step] + g * blk[5 * step] + d * blk[7 * step];
924  beta[3] = g * blk[1 * step] - e * blk[3 * step] + d * blk[5 * step] - b * blk[7 * step];
925 
926  theta[0] = a * (blk[0 * step] + blk[4 * step]);
927  theta[3] = a * (blk[0 * step] - blk[4 * step]);
928 
929  theta[1] = alpha[0] + alpha[3];
930  theta[2] = alpha[1] - alpha[2];
931 
932  gamma[0] = theta[0] + theta[1];
933  gamma[1] = theta[3] + theta[2];
934  gamma[2] = theta[3] - theta[2];
935  gamma[3] = theta[0] - theta[1];
936 
937  blk[0 * step] = gamma[0] + beta[0];
938  blk[1 * step] = gamma[1] + beta[1];
939  blk[2 * step] = gamma[2] + beta[2];
940  blk[3 * step] = gamma[3] + beta[3];
941 
942  blk[4 * step] = gamma[3] - beta[3];
943  blk[5 * step] = gamma[2] - beta[2];
944  blk[6 * step] = gamma[1] - beta[1];
945  blk[7 * step] = gamma[0] - beta[0];
946 }
947 
948 static void dct_inverse(float *block)
949 {
950  for (int i = 0; i < 8; i++)
951  idct_1d(block + i, 8);
952 
953  for (int i = 0; i < 8; i++) {
954  idct_1d(block, 1);
955  block += 8;
956  }
957 }
958 
959 static void convert(float y, float u, float v,
960  float *b, float *g, float *r)
961 {
962  *r = y + 1.5747f * v;
963  *g = y - 0.1873f * u - 0.4682f * v;
964  *b = y + 1.8556f * u;
965 }
966 
967 static float to_linear(float x, float scale)
968 {
969  float ax = fabsf(x);
970 
971  if (ax <= 1.f) {
972  return FFSIGN(x) * powf(ax, 2.2f * scale);
973  } else {
974  const float log_base = expf(2.2f * scale);
975 
976  return FFSIGN(x) * powf(log_base, ax - 1.f);
977  }
978 }
979 
980 static int dwa_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size,
981  int uncompressed_size, EXRThreadData *td)
982 {
983  int64_t version, lo_usize, lo_size;
984  int64_t ac_size, dc_size, rle_usize, rle_csize, rle_raw_size;
985  int64_t ac_count, dc_count, ac_compression;
986  const int dc_w = td->xsize >> 3;
987  const int dc_h = td->ysize >> 3;
988  GetByteContext gb, agb;
989  int skip, ret;
990 
991  if (compressed_size <= 88)
992  return AVERROR_INVALIDDATA;
993 
994  version = AV_RL64(src + 0);
995  if (version != 2)
996  return AVERROR_INVALIDDATA;
997 
998  lo_usize = AV_RL64(src + 8);
999  lo_size = AV_RL64(src + 16);
1000  ac_size = AV_RL64(src + 24);
1001  dc_size = AV_RL64(src + 32);
1002  rle_csize = AV_RL64(src + 40);
1003  rle_usize = AV_RL64(src + 48);
1004  rle_raw_size = AV_RL64(src + 56);
1005  ac_count = AV_RL64(src + 64);
1006  dc_count = AV_RL64(src + 72);
1007  ac_compression = AV_RL64(src + 80);
1008 
1009  if ( compressed_size < (uint64_t)(lo_size | ac_size | dc_size | rle_csize) || compressed_size < 88LL + lo_size + ac_size + dc_size + rle_csize
1010  || ac_count > (uint64_t)INT_MAX/2
1011  )
1012  return AVERROR_INVALIDDATA;
1013 
1014  bytestream2_init(&gb, src + 88, compressed_size - 88);
1015  skip = bytestream2_get_le16(&gb);
1016  if (skip < 2)
1017  return AVERROR_INVALIDDATA;
1018 
1019  bytestream2_skip(&gb, skip - 2);
1020 
1021  if (lo_size > 0) {
1022  if (lo_usize > uncompressed_size)
1023  return AVERROR_INVALIDDATA;
1024  bytestream2_skip(&gb, lo_size);
1025  }
1026 
1027  if (ac_size > 0) {
1028  unsigned long dest_len;
1029  GetByteContext agb = gb;
1030 
1031  if (ac_count > 3LL * td->xsize * s->scan_lines_per_block)
1032  return AVERROR_INVALIDDATA;
1033 
1034  dest_len = ac_count * 2LL;
1035 
1036  av_fast_padded_malloc(&td->ac_data, &td->ac_size, dest_len);
1037  if (!td->ac_data)
1038  return AVERROR(ENOMEM);
1039 
1040  switch (ac_compression) {
1041  case 0:
1042  ret = huf_uncompress(s, td, &agb, (int16_t *)td->ac_data, ac_count);
1043  if (ret < 0)
1044  return ret;
1045  break;
1046  case 1:
1047  if (uncompress(td->ac_data, &dest_len, agb.buffer, ac_size) != Z_OK ||
1048  dest_len != ac_count * 2LL)
1049  return AVERROR_INVALIDDATA;
1050  break;
1051  default:
1052  return AVERROR_INVALIDDATA;
1053  }
1054 
1055  bytestream2_skip(&gb, ac_size);
1056  }
1057 
1058  {
1059  unsigned long dest_len;
1060  GetByteContext agb = gb;
1061 
1062  if (dc_count != dc_w * dc_h * 3)
1063  return AVERROR_INVALIDDATA;
1064 
1065  dest_len = dc_count * 2LL;
1066 
1067  av_fast_padded_malloc(&td->dc_data, &td->dc_size, FFALIGN(dest_len, 64) * 2);
1068  if (!td->dc_data)
1069  return AVERROR(ENOMEM);
1070 
1071  if (uncompress(td->dc_data + FFALIGN(dest_len, 64), &dest_len, agb.buffer, dc_size) != Z_OK ||
1072  (dest_len != dc_count * 2LL))
1073  return AVERROR_INVALIDDATA;
1074 
1075  s->dsp.predictor(td->dc_data + FFALIGN(dest_len, 64), dest_len);
1076  s->dsp.reorder_pixels(td->dc_data, td->dc_data + FFALIGN(dest_len, 64), dest_len);
1077 
1078  bytestream2_skip(&gb, dc_size);
1079  }
1080 
1081  if (rle_raw_size > 0 && rle_csize > 0 && rle_usize > 0) {
1082  unsigned long dest_len = rle_usize;
1083 
1084  av_fast_padded_malloc(&td->rle_data, &td->rle_size, rle_usize);
1085  if (!td->rle_data)
1086  return AVERROR(ENOMEM);
1087 
1088  av_fast_padded_malloc(&td->rle_raw_data, &td->rle_raw_size, rle_raw_size);
1089  if (!td->rle_raw_data)
1090  return AVERROR(ENOMEM);
1091 
1092  if (uncompress(td->rle_data, &dest_len, gb.buffer, rle_csize) != Z_OK ||
1093  (dest_len != rle_usize))
1094  return AVERROR_INVALIDDATA;
1095 
1096  ret = rle(td->rle_raw_data, td->rle_data, rle_usize, rle_raw_size);
1097  if (ret < 0)
1098  return ret;
1099  bytestream2_skip(&gb, rle_csize);
1100  }
1101 
1102  bytestream2_init(&agb, td->ac_data, ac_count * 2);
1103 
1104  for (int y = 0; y < td->ysize; y += 8) {
1105  for (int x = 0; x < td->xsize; x += 8) {
1106  memset(td->block, 0, sizeof(td->block));
1107 
1108  for (int j = 0; j < 3; j++) {
1109  float *block = td->block[j];
1110  const int idx = (x >> 3) + (y >> 3) * dc_w + dc_w * dc_h * j;
1111  uint16_t *dc = (uint16_t *)td->dc_data;
1112  union av_intfloat32 dc_val;
1113 
1114  dc_val.i = half2float(dc[idx], &s->h2f_tables);
1115 
1116  block[0] = dc_val.f;
1117  ac_uncompress(s, &agb, block);
1118  dct_inverse(block);
1119  }
1120 
1121  {
1122  const int o = s->nb_channels == 4;
1123  float *bo = ((float *)td->uncompressed_data) +
1124  y * td->xsize * s->nb_channels + td->xsize * (o + 0) + x;
1125  float *go = ((float *)td->uncompressed_data) +
1126  y * td->xsize * s->nb_channels + td->xsize * (o + 1) + x;
1127  float *ro = ((float *)td->uncompressed_data) +
1128  y * td->xsize * s->nb_channels + td->xsize * (o + 2) + x;
1129  float *yb = td->block[0];
1130  float *ub = td->block[1];
1131  float *vb = td->block[2];
1132 
1133  for (int yy = 0; yy < 8; yy++) {
1134  for (int xx = 0; xx < 8; xx++) {
1135  const int idx = xx + yy * 8;
1136 
1137  convert(yb[idx], ub[idx], vb[idx], &bo[xx], &go[xx], &ro[xx]);
1138 
1139  bo[xx] = to_linear(bo[xx], 1.f);
1140  go[xx] = to_linear(go[xx], 1.f);
1141  ro[xx] = to_linear(ro[xx], 1.f);
1142  }
1143 
1144  bo += td->xsize * s->nb_channels;
1145  go += td->xsize * s->nb_channels;
1146  ro += td->xsize * s->nb_channels;
1147  }
1148  }
1149  }
1150  }
1151 
1152  if (s->nb_channels < 4)
1153  return 0;
1154 
1155  for (int y = 0; y < td->ysize && td->rle_raw_data; y++) {
1156  uint32_t *ao = ((uint32_t *)td->uncompressed_data) + y * td->xsize * s->nb_channels;
1157  uint8_t *ai0 = td->rle_raw_data + y * td->xsize;
1158  uint8_t *ai1 = td->rle_raw_data + y * td->xsize + rle_raw_size / 2;
1159 
1160  for (int x = 0; x < td->xsize; x++) {
1161  uint16_t ha = ai0[x] | (ai1[x] << 8);
1162 
1163  ao[x] = half2float(ha, &s->h2f_tables);
1164  }
1165  }
1166 
1167  return 0;
1168 }
1169 
1170 static int decode_block(AVCodecContext *avctx, void *tdata,
1171  int jobnr, int threadnr)
1172 {
1173  const EXRContext *s = avctx->priv_data;
1174  AVFrame *const p = s->picture;
1175  EXRThreadData *td = &s->thread_data[threadnr];
1176  const uint8_t *channel_buffer[4] = { 0 };
1177  const uint8_t *buf = s->buf;
1178  uint64_t line_offset, uncompressed_size;
1179  uint8_t *ptr;
1180  uint32_t data_size;
1181  int line, col = 0;
1182  uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
1183  const uint8_t *src;
1184  int step = s->desc->flags & AV_PIX_FMT_FLAG_FLOAT ? 4 : 2 * s->desc->nb_components;
1185  int bxmin = 0, axmax = 0, window_xoffset = 0;
1186  int window_xmin, window_xmax, window_ymin, window_ymax;
1187  int data_xoffset, data_yoffset, data_window_offset, xsize, ysize;
1188  int i, x, buf_size = s->buf_size;
1189  int c, rgb_channel_count;
1190  float one_gamma = 1.0f / s->gamma;
1191  av_csp_trc_function trc_func = av_csp_trc_func_from_id(s->apply_trc_type);
1192  int ret;
1193 
1194  line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
1195 
1196  if (s->is_tile) {
1197  if (buf_size < 20 || line_offset > buf_size - 20)
1198  return AVERROR_INVALIDDATA;
1199 
1200  src = buf + line_offset + 20;
1201  if (s->is_multipart)
1202  src += 4;
1203 
1204  tile_x = AV_RL32(src - 20);
1205  tile_y = AV_RL32(src - 16);
1206  tile_level_x = AV_RL32(src - 12);
1207  tile_level_y = AV_RL32(src - 8);
1208 
1209  data_size = AV_RL32(src - 4);
1210  if (data_size <= 0 || data_size > buf_size - line_offset - 20)
1211  return AVERROR_INVALIDDATA;
1212 
1213  if (tile_level_x || tile_level_y) { /* tile level, is not the full res level */
1214  avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
1215  return AVERROR_PATCHWELCOME;
1216  }
1217 
1218  if (tile_x && s->tile_attr.xSize + (int64_t)FFMAX(s->xmin, 0) >= INT_MAX / tile_x )
1219  return AVERROR_INVALIDDATA;
1220  if (tile_y && s->tile_attr.ySize + (int64_t)FFMAX(s->ymin, 0) >= INT_MAX / tile_y )
1221  return AVERROR_INVALIDDATA;
1222 
1223  line = s->ymin + s->tile_attr.ySize * tile_y;
1224  col = s->tile_attr.xSize * tile_x;
1225 
1226  if (line < s->ymin || line > s->ymax ||
1227  s->xmin + col < s->xmin || s->xmin + col > s->xmax)
1228  return AVERROR_INVALIDDATA;
1229 
1230  td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tile_y * s->tile_attr.ySize);
1231  td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tile_x * s->tile_attr.xSize);
1232 
1233  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1234  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1235  return AVERROR_INVALIDDATA;
1236 
1237  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1238  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1239  } else {
1240  if (buf_size < 8 || line_offset > buf_size - 8)
1241  return AVERROR_INVALIDDATA;
1242 
1243  src = buf + line_offset + 8;
1244  if (s->is_multipart)
1245  src += 4;
1246  line = AV_RL32(src - 8);
1247 
1248  if (line < s->ymin || line > s->ymax)
1249  return AVERROR_INVALIDDATA;
1250 
1251  data_size = AV_RL32(src - 4);
1252  if (data_size <= 0 || data_size > buf_size - line_offset - 8)
1253  return AVERROR_INVALIDDATA;
1254 
1255  td->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1); /* s->ydelta - line ?? */
1256  td->xsize = s->xdelta;
1257 
1258  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1259  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1260  return AVERROR_INVALIDDATA;
1261 
1262  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1263  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1264 
1265  if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
1266  line_offset > buf_size - uncompressed_size)) ||
1267  (s->compression != EXR_RAW && (data_size > uncompressed_size ||
1268  line_offset > buf_size - data_size))) {
1269  return AVERROR_INVALIDDATA;
1270  }
1271  }
1272 
1273  window_xmin = FFMIN(avctx->width, FFMAX(0, s->xmin + col));
1274  window_xmax = FFMIN(avctx->width, FFMAX(0, s->xmin + col + td->xsize));
1275  window_ymin = FFMIN(avctx->height, FFMAX(0, line ));
1276  window_ymax = FFMIN(avctx->height, FFMAX(0, line + td->ysize));
1277  xsize = window_xmax - window_xmin;
1278  ysize = window_ymax - window_ymin;
1279 
1280  /* tile or scanline not visible skip decoding */
1281  if (xsize <= 0 || ysize <= 0)
1282  return 0;
1283 
1284  /* is the first tile or is a scanline */
1285  if(col == 0) {
1286  window_xmin = 0;
1287  /* pixels to add at the left of the display window */
1288  window_xoffset = FFMAX(0, s->xmin);
1289  /* bytes to add at the left of the display window */
1290  bxmin = window_xoffset * step;
1291  }
1292 
1293  /* is the last tile or is a scanline */
1294  if(col + td->xsize == s->xdelta) {
1295  window_xmax = avctx->width;
1296  /* bytes to add at the right of the display window */
1297  axmax = FFMAX(0, (avctx->width - (s->xmax + 1))) * step;
1298  }
1299 
1300  if (avctx->max_pixels && uncompressed_size > avctx->max_pixels * 16LL)
1301  return AVERROR_INVALIDDATA;
1302 
1303  if (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
1304  av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
1305  if (!td->tmp)
1306  return AVERROR(ENOMEM);
1307  }
1308 
1309  if (data_size < uncompressed_size) {
1310  av_fast_padded_malloc(&td->uncompressed_data,
1311  &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
1312 
1313  if (!td->uncompressed_data)
1314  return AVERROR(ENOMEM);
1315 
1317  switch (s->compression) {
1318  case EXR_ZIP1:
1319  case EXR_ZIP16:
1320  ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
1321  break;
1322  case EXR_PIZ:
1323  ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
1324  break;
1325  case EXR_PXR24:
1326  ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
1327  break;
1328  case EXR_RLE:
1329  ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
1330  break;
1331  case EXR_B44:
1332  case EXR_B44A:
1333  ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
1334  break;
1335  case EXR_DWAA:
1336  case EXR_DWAB:
1337  ret = dwa_uncompress(s, src, data_size, uncompressed_size, td);
1338  break;
1339  }
1340  if (ret < 0) {
1341  av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
1342  return ret;
1343  }
1344  src = td->uncompressed_data;
1345  }
1346 
1347  /* offsets to crop data outside display window */
1348  data_xoffset = FFABS(FFMIN(0, s->xmin + col)) * (s->pixel_type == EXR_HALF ? 2 : 4);
1349  data_yoffset = FFABS(FFMIN(0, line));
1350  data_window_offset = (data_yoffset * td->channel_line_size) + data_xoffset;
1351 
1352  if (!s->is_luma) {
1353  channel_buffer[0] = src + (td->xsize * s->channel_offsets[0]) + data_window_offset;
1354  channel_buffer[1] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1355  channel_buffer[2] = src + (td->xsize * s->channel_offsets[2]) + data_window_offset;
1356  rgb_channel_count = 3;
1357  } else { /* put y data in the first channel_buffer */
1358  channel_buffer[0] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1359  rgb_channel_count = 1;
1360  }
1361  if (s->channel_offsets[3] >= 0)
1362  channel_buffer[3] = src + (td->xsize * s->channel_offsets[3]) + data_window_offset;
1363 
1364  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
1365  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
1366  int channel_count = s->channel_offsets[3] >= 0 ? 4 : rgb_channel_count;
1367  if (s->is_luma) {
1368  channel_buffer[1] = channel_buffer[0];
1369  channel_buffer[2] = channel_buffer[0];
1370  }
1371 
1372  for (c = 0; c < channel_count; c++) {
1373  int plane = s->desc->comp[c].plane;
1374  ptr = p->data[plane] + window_ymin * p->linesize[plane] + (window_xmin * 4);
1375 
1376  for (i = 0; i < ysize; i++, ptr += p->linesize[plane]) {
1377  const uint8_t *src;
1378  union av_intfloat32 *ptr_x;
1379 
1380  src = channel_buffer[c];
1381  ptr_x = (union av_intfloat32 *)ptr;
1382 
1383  // Zero out the start if xmin is not 0
1384  memset(ptr_x, 0, bxmin);
1385  ptr_x += window_xoffset;
1386 
1387  if (s->pixel_type == EXR_FLOAT ||
1388  s->compression == EXR_DWAA ||
1389  s->compression == EXR_DWAB) {
1390  // 32-bit
1391  union av_intfloat32 t;
1392  if (trc_func && c < 3) {
1393  for (x = 0; x < xsize; x++) {
1394  t.i = bytestream_get_le32(&src);
1395  t.f = trc_func(t.f);
1396  *ptr_x++ = t;
1397  }
1398  } else if (one_gamma != 1.f) {
1399  for (x = 0; x < xsize; x++) {
1400  t.i = bytestream_get_le32(&src);
1401  if (t.f > 0.0f && c < 3) /* avoid negative values */
1402  t.f = powf(t.f, one_gamma);
1403  *ptr_x++ = t;
1404  }
1405  } else {
1406  for (x = 0; x < xsize; x++) {
1407  t.i = bytestream_get_le32(&src);
1408  *ptr_x++ = t;
1409  }
1410  }
1411  } else if (s->pixel_type == EXR_HALF) {
1412  // 16-bit
1413  if (c < 3 || !trc_func) {
1414  for (x = 0; x < xsize; x++) {
1415  *ptr_x++ = s->gamma_table[bytestream_get_le16(&src)];
1416  }
1417  } else {
1418  for (x = 0; x < xsize; x++) {
1419  ptr_x[0].i = half2float(bytestream_get_le16(&src), &s->h2f_tables);
1420  ptr_x++;
1421  }
1422  }
1423  }
1424 
1425  // Zero out the end if xmax+1 is not w
1426  memset(ptr_x, 0, axmax);
1427  channel_buffer[c] += td->channel_line_size;
1428  }
1429  }
1430  } else {
1431 
1432  av_assert1(s->pixel_type == EXR_UINT);
1433  ptr = p->data[0] + window_ymin * p->linesize[0] + (window_xmin * s->desc->nb_components * 2);
1434 
1435  for (i = 0; i < ysize; i++, ptr += p->linesize[0]) {
1436 
1437  const uint8_t * a;
1438  const uint8_t *rgb[3];
1439  uint16_t *ptr_x;
1440 
1441  for (c = 0; c < rgb_channel_count; c++) {
1442  rgb[c] = channel_buffer[c];
1443  }
1444 
1445  if (channel_buffer[3])
1446  a = channel_buffer[3];
1447 
1448  ptr_x = (uint16_t *) ptr;
1449 
1450  // Zero out the start if xmin is not 0
1451  memset(ptr_x, 0, bxmin);
1452  ptr_x += window_xoffset * s->desc->nb_components;
1453 
1454  for (x = 0; x < xsize; x++) {
1455  for (c = 0; c < rgb_channel_count; c++) {
1456  *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
1457  }
1458 
1459  if (channel_buffer[3])
1460  *ptr_x++ = bytestream_get_le32(&a) >> 16;
1461  }
1462 
1463  // Zero out the end if xmax+1 is not w
1464  memset(ptr_x, 0, axmax);
1465 
1466  channel_buffer[0] += td->channel_line_size;
1467  channel_buffer[1] += td->channel_line_size;
1468  channel_buffer[2] += td->channel_line_size;
1469  if (channel_buffer[3])
1470  channel_buffer[3] += td->channel_line_size;
1471  }
1472  }
1473 
1474  return 0;
1475 }
1476 
1478 {
1479  GetByteContext *gb = &s->gb;
1480 
1481  while (bytestream2_get_bytes_left(gb) > 0) {
1482  if (!bytestream2_peek_byte(gb))
1483  break;
1484 
1485  // Process unknown variables
1486  for (int i = 0; i < 2; i++) // value_name and value_type
1487  while (bytestream2_get_byte(gb) != 0);
1488 
1489  // Skip variable length
1490  bytestream2_skip(gb, bytestream2_get_le32(gb));
1491  }
1492 }
1493 
1494 /**
1495  * Check if the variable name corresponds to its data type.
1496  *
1497  * @param s the EXRContext
1498  * @param value_name name of the variable to check
1499  * @param value_type type of the variable to check
1500  * @param minimum_length minimum length of the variable data
1501  *
1502  * @return bytes to read containing variable data
1503  * -1 if variable is not found
1504  * 0 if buffer ended prematurely
1505  */
1507  const char *value_name,
1508  const char *value_type,
1509  unsigned int minimum_length)
1510 {
1511  GetByteContext *gb = &s->gb;
1512  int var_size = -1;
1513 
1514  if (bytestream2_get_bytes_left(gb) >= minimum_length &&
1515  !strcmp(gb->buffer, value_name)) {
1516  // found value_name, jump to value_type (null terminated strings)
1517  gb->buffer += strlen(value_name) + 1;
1518  if (!strcmp(gb->buffer, value_type)) {
1519  gb->buffer += strlen(value_type) + 1;
1520  var_size = bytestream2_get_le32(gb);
1521  // don't go read past boundaries
1522  if (var_size > bytestream2_get_bytes_left(gb))
1523  var_size = 0;
1524  } else {
1525  // value_type not found, reset the buffer
1526  gb->buffer -= strlen(value_name) + 1;
1527  av_log(s->avctx, AV_LOG_WARNING,
1528  "Unknown data type %s for header variable %s.\n",
1529  value_type, value_name);
1530  }
1531  }
1532 
1533  return var_size;
1534 }
1535 
1537 {
1538  AVDictionary *metadata = NULL;
1539  GetByteContext *gb = &s->gb;
1540  int magic_number, version, flags;
1541  int layer_match = 0;
1542  int ret;
1543  int dup_channels = 0;
1544 
1545  s->current_channel_offset = 0;
1546  s->xmin = ~0;
1547  s->xmax = ~0;
1548  s->ymin = ~0;
1549  s->ymax = ~0;
1550  s->xdelta = ~0;
1551  s->ydelta = ~0;
1552  s->channel_offsets[0] = -1;
1553  s->channel_offsets[1] = -1;
1554  s->channel_offsets[2] = -1;
1555  s->channel_offsets[3] = -1;
1556  s->pixel_type = EXR_UNKNOWN;
1557  s->compression = EXR_UNKN;
1558  s->nb_channels = 0;
1559  s->w = 0;
1560  s->h = 0;
1561  s->tile_attr.xSize = -1;
1562  s->tile_attr.ySize = -1;
1563  s->is_tile = 0;
1564  s->is_multipart = 0;
1565  s->is_luma = 0;
1566  s->current_part = 0;
1567 
1568  if (bytestream2_get_bytes_left(gb) < 10) {
1569  av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
1570  return AVERROR_INVALIDDATA;
1571  }
1572 
1573  magic_number = bytestream2_get_le32(gb);
1574  if (magic_number != 20000630) {
1575  /* As per documentation of OpenEXR, it is supposed to be
1576  * int 20000630 little-endian */
1577  av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
1578  return AVERROR_INVALIDDATA;
1579  }
1580 
1581  version = bytestream2_get_byte(gb);
1582  if (version != 2) {
1583  avpriv_report_missing_feature(s->avctx, "Version %d", version);
1584  return AVERROR_PATCHWELCOME;
1585  }
1586 
1587  flags = bytestream2_get_le24(gb);
1588 
1589  if (flags & 0x02)
1590  s->is_tile = 1;
1591  if (flags & 0x10)
1592  s->is_multipart = 1;
1593  if (flags & 0x08) {
1594  avpriv_report_missing_feature(s->avctx, "deep data");
1595  return AVERROR_PATCHWELCOME;
1596  }
1597 
1598  // Parse the header
1599  while (bytestream2_get_bytes_left(gb) > 0) {
1600  int var_size;
1601 
1602  while (s->is_multipart && s->current_part < s->selected_part &&
1603  bytestream2_get_bytes_left(gb) > 0) {
1604  if (bytestream2_peek_byte(gb)) {
1606  } else {
1607  bytestream2_skip(gb, 1);
1608  if (!bytestream2_peek_byte(gb))
1609  break;
1610  }
1611  bytestream2_skip(gb, 1);
1612  s->current_part++;
1613  }
1614 
1615  if (!bytestream2_peek_byte(gb)) {
1616  if (!s->is_multipart)
1617  break;
1618  bytestream2_skip(gb, 1);
1619  if (s->current_part == s->selected_part) {
1620  while (bytestream2_get_bytes_left(gb) > 0) {
1621  if (bytestream2_peek_byte(gb)) {
1623  } else {
1624  bytestream2_skip(gb, 1);
1625  if (!bytestream2_peek_byte(gb))
1626  break;
1627  }
1628  }
1629  }
1630  if (!bytestream2_peek_byte(gb))
1631  break;
1632  s->current_part++;
1633  }
1634 
1635  if ((var_size = check_header_variable(s, "channels",
1636  "chlist", 38)) >= 0) {
1637  GetByteContext ch_gb;
1638  if (!var_size) {
1640  goto fail;
1641  }
1642 
1643  bytestream2_init(&ch_gb, gb->buffer, var_size);
1644 
1645  while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
1647  enum ExrPixelType current_pixel_type;
1648  int channel_index = -1;
1649  int xsub, ysub;
1650 
1651  if (strcmp(s->layer, "") != 0) {
1652  if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
1653  layer_match = 1;
1654  av_log(s->avctx, AV_LOG_INFO,
1655  "Channel match layer : %s.\n", ch_gb.buffer);
1656  ch_gb.buffer += strlen(s->layer);
1657  if (*ch_gb.buffer == '.')
1658  ch_gb.buffer++; /* skip dot if not given */
1659  } else {
1660  layer_match = 0;
1661  av_log(s->avctx, AV_LOG_INFO,
1662  "Channel doesn't match layer : %s.\n", ch_gb.buffer);
1663  }
1664  } else {
1665  layer_match = 1;
1666  }
1667 
1668  if (layer_match) { /* only search channel if the layer match is valid */
1669  if (!av_strcasecmp(ch_gb.buffer, "R") ||
1670  !av_strcasecmp(ch_gb.buffer, "X") ||
1671  !av_strcasecmp(ch_gb.buffer, "U")) {
1672  channel_index = 0;
1673  s->is_luma = 0;
1674  } else if (!av_strcasecmp(ch_gb.buffer, "G") ||
1675  !av_strcasecmp(ch_gb.buffer, "V")) {
1676  channel_index = 1;
1677  s->is_luma = 0;
1678  } else if (!av_strcasecmp(ch_gb.buffer, "Y")) {
1679  channel_index = 1;
1680  s->is_luma = 1;
1681  } else if (!av_strcasecmp(ch_gb.buffer, "B") ||
1682  !av_strcasecmp(ch_gb.buffer, "Z") ||
1683  !av_strcasecmp(ch_gb.buffer, "W")) {
1684  channel_index = 2;
1685  s->is_luma = 0;
1686  } else if (!av_strcasecmp(ch_gb.buffer, "A")) {
1687  channel_index = 3;
1688  } else {
1689  av_log(s->avctx, AV_LOG_WARNING,
1690  "Unsupported channel %.256s.\n", ch_gb.buffer);
1691  }
1692  }
1693 
1694  /* skip until you get a 0 */
1695  while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1696  bytestream2_get_byte(&ch_gb))
1697  continue;
1698 
1699  if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1700  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1702  goto fail;
1703  }
1704 
1705  current_pixel_type = bytestream2_get_le32(&ch_gb);
1706  if (current_pixel_type >= EXR_UNKNOWN) {
1707  avpriv_report_missing_feature(s->avctx, "Pixel type %d",
1708  current_pixel_type);
1710  goto fail;
1711  }
1712 
1713  bytestream2_skip(&ch_gb, 4);
1714  xsub = bytestream2_get_le32(&ch_gb);
1715  ysub = bytestream2_get_le32(&ch_gb);
1716 
1717  if (xsub != 1 || ysub != 1) {
1719  "Subsampling %dx%d",
1720  xsub, ysub);
1722  goto fail;
1723  }
1724 
1725  if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
1726  if (s->pixel_type != EXR_UNKNOWN &&
1727  s->pixel_type != current_pixel_type) {
1728  av_log(s->avctx, AV_LOG_ERROR,
1729  "RGB channels not of the same depth.\n");
1731  goto fail;
1732  }
1733  s->pixel_type = current_pixel_type;
1734  s->channel_offsets[channel_index] = s->current_channel_offset;
1735  } else if (channel_index >= 0) {
1736  av_log(s->avctx, AV_LOG_WARNING,
1737  "Multiple channels with index %d.\n", channel_index);
1738  if (++dup_channels > 10) {
1740  goto fail;
1741  }
1742  }
1743 
1744  s->channels = av_realloc(s->channels,
1745  ++s->nb_channels * sizeof(EXRChannel));
1746  if (!s->channels) {
1747  ret = AVERROR(ENOMEM);
1748  goto fail;
1749  }
1750  channel = &s->channels[s->nb_channels - 1];
1751  channel->pixel_type = current_pixel_type;
1752  channel->xsub = xsub;
1753  channel->ysub = ysub;
1754 
1755  if (current_pixel_type == EXR_HALF) {
1756  s->current_channel_offset += 2;
1757  } else {/* Float or UINT32 */
1758  s->current_channel_offset += 4;
1759  }
1760  }
1761 
1762  /* Check if all channels are set with an offset or if the channels
1763  * are causing an overflow */
1764  if (!s->is_luma) {/* if we expected to have at least 3 channels */
1765  if (FFMIN3(s->channel_offsets[0],
1766  s->channel_offsets[1],
1767  s->channel_offsets[2]) < 0) {
1768  if (s->channel_offsets[0] < 0)
1769  av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1770  if (s->channel_offsets[1] < 0)
1771  av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1772  if (s->channel_offsets[2] < 0)
1773  av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1775  goto fail;
1776  }
1777  }
1778 
1779  // skip one last byte and update main gb
1780  gb->buffer = ch_gb.buffer + 1;
1781  continue;
1782  } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1783  31)) >= 0) {
1784  int xmin, ymin, xmax, ymax;
1785  if (!var_size) {
1787  goto fail;
1788  }
1789 
1790  xmin = bytestream2_get_le32(gb);
1791  ymin = bytestream2_get_le32(gb);
1792  xmax = bytestream2_get_le32(gb);
1793  ymax = bytestream2_get_le32(gb);
1794 
1795  if (xmin > xmax || ymin > ymax ||
1796  ymax == INT_MAX || xmax == INT_MAX ||
1797  (unsigned)xmax - xmin >= INT_MAX ||
1798  (unsigned)ymax - ymin >= INT_MAX) {
1800  goto fail;
1801  }
1802  s->xmin = xmin;
1803  s->xmax = xmax;
1804  s->ymin = ymin;
1805  s->ymax = ymax;
1806  s->xdelta = (s->xmax - s->xmin) + 1;
1807  s->ydelta = (s->ymax - s->ymin) + 1;
1808 
1809  continue;
1810  } else if ((var_size = check_header_variable(s, "displayWindow",
1811  "box2i", 34)) >= 0) {
1812  int32_t sx, sy, dx, dy;
1813 
1814  if (!var_size) {
1816  goto fail;
1817  }
1818 
1819  sx = bytestream2_get_le32(gb);
1820  sy = bytestream2_get_le32(gb);
1821  dx = bytestream2_get_le32(gb);
1822  dy = bytestream2_get_le32(gb);
1823 
1824  s->w = (unsigned)dx - sx + 1;
1825  s->h = (unsigned)dy - sy + 1;
1826 
1827  continue;
1828  } else if ((var_size = check_header_variable(s, "lineOrder",
1829  "lineOrder", 25)) >= 0) {
1830  int line_order;
1831  if (!var_size) {
1833  goto fail;
1834  }
1835 
1836  line_order = bytestream2_get_byte(gb);
1837  av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1838  if (line_order > 2) {
1839  av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1841  goto fail;
1842  }
1843 
1844  continue;
1845  } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1846  "float", 31)) >= 0) {
1847  if (!var_size) {
1849  goto fail;
1850  }
1851 
1852  s->sar = bytestream2_get_le32(gb);
1853 
1854  continue;
1855  } else if ((var_size = check_header_variable(s, "compression",
1856  "compression", 29)) >= 0) {
1857  if (!var_size) {
1859  goto fail;
1860  }
1861 
1862  if (s->compression == EXR_UNKN)
1863  s->compression = bytestream2_get_byte(gb);
1864  else {
1865  bytestream2_skip(gb, 1);
1866  av_log(s->avctx, AV_LOG_WARNING,
1867  "Found more than one compression attribute.\n");
1868  }
1869 
1870  continue;
1871  } else if ((var_size = check_header_variable(s, "tiles",
1872  "tiledesc", 22)) >= 0) {
1873  uint8_t tileLevel;
1874 
1875  if (!s->is_tile)
1876  av_log(s->avctx, AV_LOG_WARNING,
1877  "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1878 
1879  s->tile_attr.xSize = bytestream2_get_le32(gb);
1880  s->tile_attr.ySize = bytestream2_get_le32(gb);
1881 
1882  tileLevel = bytestream2_get_byte(gb);
1883  s->tile_attr.level_mode = tileLevel & 0x0f;
1884  s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1885 
1886  if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN) {
1887  avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
1888  s->tile_attr.level_mode);
1890  goto fail;
1891  }
1892 
1893  if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
1894  avpriv_report_missing_feature(s->avctx, "Tile level round %d",
1895  s->tile_attr.level_round);
1897  goto fail;
1898  }
1899 
1900  continue;
1901  } else if ((var_size = check_header_variable(s, "writer",
1902  "string", 1)) >= 0) {
1903  uint8_t key[256] = { 0 };
1904 
1905  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1906  av_dict_set(&metadata, "writer", key, 0);
1907 
1908  continue;
1909  } else if ((var_size = check_header_variable(s, "framesPerSecond",
1910  "rational", 33)) >= 0) {
1911  if (!var_size) {
1913  goto fail;
1914  }
1915 
1916  s->avctx->framerate.num = bytestream2_get_le32(gb);
1917  s->avctx->framerate.den = bytestream2_get_le32(gb);
1918 
1919  continue;
1920  } else if ((var_size = check_header_variable(s, "chunkCount",
1921  "int", 23)) >= 0) {
1922 
1923  s->chunk_count = bytestream2_get_le32(gb);
1924 
1925  continue;
1926  } else if ((var_size = check_header_variable(s, "type",
1927  "string", 16)) >= 0) {
1928  uint8_t key[256] = { 0 };
1929 
1930  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1931  if (strncmp("scanlineimage", key, var_size) &&
1932  strncmp("tiledimage", key, var_size)) {
1934  goto fail;
1935  }
1936 
1937  continue;
1938  } else if ((var_size = check_header_variable(s, "preview",
1939  "preview", 16)) >= 0) {
1940  uint32_t pw = bytestream2_get_le32(gb);
1941  uint32_t ph = bytestream2_get_le32(gb);
1942  uint64_t psize = pw * ph;
1943  if (psize > INT64_MAX / 4) {
1945  goto fail;
1946  }
1947  psize *= 4;
1948 
1949  if ((int64_t)psize >= bytestream2_get_bytes_left(gb)) {
1951  goto fail;
1952  }
1953 
1954  bytestream2_skip(gb, psize);
1955 
1956  continue;
1957  }
1958 
1959  // Check if there are enough bytes for a header
1960  if (bytestream2_get_bytes_left(gb) <= 9) {
1961  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1963  goto fail;
1964  }
1965 
1966  // Process unknown variables
1967  {
1968  uint8_t name[256] = { 0 };
1969  uint8_t type[256] = { 0 };
1970  uint8_t value[8192] = { 0 };
1971  int i = 0, size;
1972 
1973  while (bytestream2_get_bytes_left(gb) > 0 &&
1974  bytestream2_peek_byte(gb) && i < 255) {
1975  name[i++] = bytestream2_get_byte(gb);
1976  }
1977 
1978  bytestream2_skip(gb, 1);
1979  i = 0;
1980  while (bytestream2_get_bytes_left(gb) > 0 &&
1981  bytestream2_peek_byte(gb) && i < 255) {
1982  type[i++] = bytestream2_get_byte(gb);
1983  }
1984  bytestream2_skip(gb, 1);
1985  size = bytestream2_get_le32(gb);
1986 
1987  bytestream2_get_buffer(gb, value, FFMIN(sizeof(value) - 1, size));
1988  if (size > sizeof(value) - 1)
1989  bytestream2_skip(gb, size - (sizeof(value) - 1));
1990  if (!strcmp(type, "string"))
1991  av_dict_set(&metadata, name, value, 0);
1992  }
1993  }
1994 
1995  if (s->compression == EXR_UNKN) {
1996  av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
1998  goto fail;
1999  }
2000 
2001  if (s->is_tile) {
2002  if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
2003  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
2005  goto fail;
2006  }
2007  }
2008 
2009  if (bytestream2_get_bytes_left(gb) <= 0) {
2010  av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
2012  goto fail;
2013  }
2014 
2015  frame->metadata = metadata;
2016 
2017  // aaand we are done
2018  bytestream2_skip(gb, 1);
2019  return 0;
2020 fail:
2021  av_dict_free(&metadata);
2022  return ret;
2023 }
2024 
2025 static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
2026  int *got_frame, AVPacket *avpkt)
2027 {
2028  EXRContext *s = avctx->priv_data;
2029  GetByteContext *gb = &s->gb;
2030  uint8_t *ptr;
2031 
2032  int i, y, ret, ymax;
2033  int planes;
2034  int out_line_size;
2035  int nb_blocks; /* nb scanline or nb tile */
2036  uint64_t start_offset_table;
2037  uint64_t start_next_scanline;
2038 
2039  bytestream2_init(gb, avpkt->data, avpkt->size);
2040 
2041  if ((ret = decode_header(s, picture)) < 0)
2042  return ret;
2043 
2044  if ((s->compression == EXR_DWAA || s->compression == EXR_DWAB) &&
2045  s->pixel_type == EXR_HALF) {
2046  s->current_channel_offset *= 2;
2047  for (int i = 0; i < 4; i++)
2048  s->channel_offsets[i] *= 2;
2049  }
2050 
2051  switch (s->pixel_type) {
2052  case EXR_FLOAT:
2053  case EXR_HALF:
2054  if (s->channel_offsets[3] >= 0) {
2055  if (!s->is_luma) {
2056  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2057  } else {
2058  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
2059  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2060  }
2061  } else {
2062  if (!s->is_luma) {
2063  avctx->pix_fmt = AV_PIX_FMT_GBRPF32;
2064  } else {
2065  avctx->pix_fmt = AV_PIX_FMT_GRAYF32;
2066  }
2067  }
2068  break;
2069  case EXR_UINT:
2070  if (s->channel_offsets[3] >= 0) {
2071  if (!s->is_luma) {
2072  avctx->pix_fmt = AV_PIX_FMT_RGBA64;
2073  } else {
2074  avctx->pix_fmt = AV_PIX_FMT_YA16;
2075  }
2076  } else {
2077  if (!s->is_luma) {
2078  avctx->pix_fmt = AV_PIX_FMT_RGB48;
2079  } else {
2080  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
2081  }
2082  }
2083  break;
2084  default:
2085  av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
2086  return AVERROR_INVALIDDATA;
2087  }
2088 
2089  if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
2090  avctx->color_trc = s->apply_trc_type;
2091  else if (s->gamma > 0.9999f && s->gamma < 1.0001f)
2092  avctx->color_trc = AVCOL_TRC_LINEAR;
2093 
2094  switch (s->compression) {
2095  case EXR_RAW:
2096  case EXR_RLE:
2097  case EXR_ZIP1:
2098  s->scan_lines_per_block = 1;
2099  break;
2100  case EXR_PXR24:
2101  case EXR_ZIP16:
2102  s->scan_lines_per_block = 16;
2103  break;
2104  case EXR_PIZ:
2105  case EXR_B44:
2106  case EXR_B44A:
2107  case EXR_DWAA:
2108  s->scan_lines_per_block = 32;
2109  break;
2110  case EXR_DWAB:
2111  s->scan_lines_per_block = 256;
2112  break;
2113  default:
2114  avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
2115  return AVERROR_PATCHWELCOME;
2116  }
2117 
2118  /* Verify the xmin, xmax, ymin and ymax before setting the actual image size.
2119  * It's possible for the data window can larger or outside the display window */
2120  if (s->xmin > s->xmax || s->ymin > s->ymax ||
2121  s->ydelta == 0xFFFFFFFF || s->xdelta == 0xFFFFFFFF) {
2122  av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
2123  return AVERROR_INVALIDDATA;
2124  }
2125 
2126  if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
2127  return ret;
2128 
2129  ff_set_sar(s->avctx, av_d2q(av_int2float(s->sar), 255));
2130 
2131  if (avctx->skip_frame >= AVDISCARD_ALL)
2132  return avpkt->size;
2133 
2134  s->desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2135  if (!s->desc)
2136  return AVERROR_INVALIDDATA;
2137 
2138  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
2139  planes = s->desc->nb_components;
2140  out_line_size = avctx->width * 4;
2141  } else {
2142  planes = 1;
2143  out_line_size = avctx->width * 2 * s->desc->nb_components;
2144  }
2145 
2146  if (s->is_tile) {
2147  nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
2148  ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
2149  } else { /* scanline */
2150  nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
2151  s->scan_lines_per_block;
2152  }
2153 
2154  if ((ret = ff_thread_get_buffer(avctx, picture, 0)) < 0)
2155  return ret;
2156 
2157  if (bytestream2_get_bytes_left(gb)/8 < nb_blocks)
2158  return AVERROR_INVALIDDATA;
2159 
2160  // check offset table and recreate it if need
2161  if (!s->is_tile && bytestream2_peek_le64(gb) == 0) {
2162  PutByteContext offset_table_writer;
2163 
2164  av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
2165 
2166  s->offset_table = av_realloc_f(s->offset_table, nb_blocks, 8);
2167  if (!s->offset_table)
2168  return AVERROR(ENOMEM);
2169 
2170  start_offset_table = bytestream2_tell(gb);
2171  start_next_scanline = start_offset_table + nb_blocks * 8;
2172  bytestream2_init_writer(&offset_table_writer, s->offset_table, nb_blocks * 8);
2173 
2174  for (y = 0; y < nb_blocks; y++) {
2175  /* write offset of prev scanline in offset table */
2176  bytestream2_put_le64(&offset_table_writer, start_next_scanline);
2177 
2178  /* get len of next scanline */
2179  bytestream2_seek(gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
2180  start_next_scanline += (bytestream2_get_le32(gb) + 8);
2181  }
2182  bytestream2_init(gb, s->offset_table, nb_blocks * 8);
2183  }
2184 
2185  // save pointer we are going to use in decode_block
2186  s->buf = avpkt->data;
2187  s->buf_size = avpkt->size;
2188 
2189  // Zero out the start if ymin is not 0
2190  for (i = 0; i < planes; i++) {
2191  ptr = picture->data[i];
2192  for (y = 0; y < FFMIN(s->ymin, s->h); y++) {
2193  memset(ptr, 0, out_line_size);
2194  ptr += picture->linesize[i];
2195  }
2196  }
2197 
2198  s->picture = picture;
2199 
2200  avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
2201 
2202  ymax = FFMAX(0, s->ymax + 1);
2203  // Zero out the end if ymax+1 is not h
2204  if (ymax < avctx->height)
2205  for (i = 0; i < planes; i++) {
2206  ptr = picture->data[i] + (ymax * picture->linesize[i]);
2207  for (y = ymax; y < avctx->height; y++) {
2208  memset(ptr, 0, out_line_size);
2209  ptr += picture->linesize[i];
2210  }
2211  }
2212 
2213  picture->pict_type = AV_PICTURE_TYPE_I;
2214  *got_frame = 1;
2215 
2216  return avpkt->size;
2217 }
2218 
2220 {
2221  EXRContext *s = avctx->priv_data;
2222  uint32_t i;
2223  union av_intfloat32 t;
2224  float one_gamma = 1.0f / s->gamma;
2225  av_csp_trc_function trc_func = NULL;
2226 
2227  ff_init_half2float_tables(&s->h2f_tables);
2228 
2229  s->avctx = avctx;
2230 
2231  ff_exrdsp_init(&s->dsp);
2232 
2233 #if HAVE_BIGENDIAN
2234  ff_bswapdsp_init(&s->bbdsp);
2235 #endif
2236 
2237  trc_func = av_csp_trc_func_from_id(s->apply_trc_type);
2238  if (trc_func) {
2239  for (i = 0; i < 65536; ++i) {
2240  t.i = half2float(i, &s->h2f_tables);
2241  t.f = trc_func(t.f);
2242  s->gamma_table[i] = t;
2243  }
2244  } else {
2245  if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
2246  for (i = 0; i < 65536; ++i) {
2247  s->gamma_table[i].i = half2float(i, &s->h2f_tables);
2248  }
2249  } else {
2250  for (i = 0; i < 65536; ++i) {
2251  t.i = half2float(i, &s->h2f_tables);
2252  /* If negative value we reuse half value */
2253  if (t.f <= 0.0f) {
2254  s->gamma_table[i] = t;
2255  } else {
2256  t.f = powf(t.f, one_gamma);
2257  s->gamma_table[i] = t;
2258  }
2259  }
2260  }
2261  }
2262 
2263  // allocate thread data, used for non EXR_RAW compression types
2264  s->thread_data = av_calloc(avctx->thread_count, sizeof(*s->thread_data));
2265  if (!s->thread_data)
2266  return AVERROR(ENOMEM);
2267 
2268  return 0;
2269 }
2270 
2272 {
2273  EXRContext *s = avctx->priv_data;
2274  int i;
2275  for (i = 0; i < avctx->thread_count; i++) {
2276  EXRThreadData *td = &s->thread_data[i];
2277  av_freep(&td->uncompressed_data);
2278  av_freep(&td->tmp);
2279  av_freep(&td->bitmap);
2280  av_freep(&td->lut);
2281  av_freep(&td->he);
2282  av_freep(&td->freq);
2283  av_freep(&td->ac_data);
2284  av_freep(&td->dc_data);
2285  av_freep(&td->rle_data);
2286  av_freep(&td->rle_raw_data);
2287  ff_vlc_free(&td->vlc);
2288  }
2289 
2290  av_freep(&s->thread_data);
2291  av_freep(&s->channels);
2292  av_freep(&s->offset_table);
2293 
2294  return 0;
2295 }
2296 
2297 #define OFFSET(x) offsetof(EXRContext, x)
2298 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2299 static const AVOption options[] = {
2300  { "layer", "Set the decoding layer", OFFSET(layer),
2301  AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
2302  { "part", "Set the decoding part", OFFSET(selected_part),
2303  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
2304  { "gamma", "Set the float gamma value when decoding", OFFSET(gamma),
2305  AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD },
2306 
2307  // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
2308  { "apply_trc", "color transfer characteristics to apply to EXR linear input", OFFSET(apply_trc_type),
2309  AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD, .unit = "apply_trc_type"},
2310  { "bt709", "BT.709", 0,
2311  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2312  { "gamma", "gamma", 0,
2313  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2314  { "gamma22", "BT.470 M", 0,
2315  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2316  { "gamma28", "BT.470 BG", 0,
2317  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2318  { "smpte170m", "SMPTE 170 M", 0,
2319  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2320  { "smpte240m", "SMPTE 240 M", 0,
2321  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2322  { "linear", "Linear", 0,
2323  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2324  { "log", "Log", 0,
2325  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2326  { "log_sqrt", "Log square root", 0,
2327  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2328  { "iec61966_2_4", "IEC 61966-2-4", 0,
2329  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2330  { "bt1361", "BT.1361", 0,
2331  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2332  { "iec61966_2_1", "IEC 61966-2-1", 0,
2333  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2334  { "bt2020_10bit", "BT.2020 - 10 bit", 0,
2335  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2336  { "bt2020_12bit", "BT.2020 - 12 bit", 0,
2337  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2338  { "smpte2084", "SMPTE ST 2084", 0,
2339  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2340  { "smpte428_1", "SMPTE ST 428-1", 0,
2341  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2342 
2343  { NULL },
2344 };
2345 
2346 static const AVClass exr_class = {
2347  .class_name = "EXR",
2348  .item_name = av_default_item_name,
2349  .option = options,
2350  .version = LIBAVUTIL_VERSION_INT,
2351 };
2352 
2354  .p.name = "exr",
2355  CODEC_LONG_NAME("OpenEXR image"),
2356  .p.type = AVMEDIA_TYPE_VIDEO,
2357  .p.id = AV_CODEC_ID_EXR,
2358  .priv_data_size = sizeof(EXRContext),
2359  .init = decode_init,
2360  .close = decode_end,
2362  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2364  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2365  .p.priv_class = &exr_class,
2366 };
bswapdsp.h
EXRTileAttribute::level_round
enum ExrTileLevelRound level_round
Definition: exr.c:109
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
EXRThreadData
Definition: exr.c:112
td
#define td
Definition: regdef.h:70
name
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
Definition: writing_filters.txt:88
EXR_TILE_ROUND_DOWN
@ EXR_TILE_ROUND_DOWN
Definition: exr.c:90
Half2FloatTables
Definition: half2float.h:27
EXRThreadData::uncompressed_size
int uncompressed_size
Definition: exr.c:114
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
r
const char * r
Definition: vf_curves.c:126
AVERROR
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
opt.h
EXRThreadData::rle_raw_size
unsigned rle_raw_size
Definition: exr.c:132
EXRTileAttribute
Definition: exr.c:105
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:584
out
FILE * out
Definition: movenc.c:54
EXRThreadData::lut
uint16_t * lut
Definition: exr.c:120
GetByteContext
Definition: bytestream.h:33
EXR_TILE_LEVEL_ONE
@ EXR_TILE_LEVEL_ONE
Definition: exr.c:82
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:250
EXRThreadData::uncompressed_data
uint8_t * uncompressed_data
Definition: exr.c:113
VD
#define VD
Definition: exr.c:2298
HuffEntry::len
uint8_t len
Definition: exr.c:95
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:593
decode_header
static int decode_header(EXRContext *s, AVFrame *frame)
Definition: exr.c:1536
EXRContext::layer
const char * layer
Definition: exr.c:187
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: exr.c:2025
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:2998
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
EXRContext::chunk_count
uint32_t chunk_count
Definition: exr.c:183
EXRContext::picture
AVFrame * picture
Definition: exr.c:148
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:606
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
EXRThreadData::rle_data
uint8_t * rle_data
Definition: exr.c:128
step
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
Definition: rate_distortion.txt:58
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1026
AVPacket::data
uint8_t * data
Definition: packet.h:522
av_intfloat32::i
uint32_t i
Definition: intfloat.h:28
ExrPixelType
ExrPixelType
Definition: exr.c:74
AVOption
AVOption.
Definition: opt.h:294
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:587
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: exr.c:2219
reverse_lut
static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
Definition: exr.c:274
expf
#define expf(x)
Definition: libm.h:283
FFCodec
Definition: codec_internal.h:127
EXRThreadData::vlc
VLC vlc
Definition: exr.c:143
float.h
AVCOL_TRC_BT2020_12
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:600
EXRThreadData::ysize
int ysize
Definition: exr.c:136
piz_uncompress
static int piz_uncompress(const EXRContext *s, const uint8_t *src, int ssize, int dsize, EXRThreadData *td)
Definition: exr.c:591
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
options
static const AVOption options[]
Definition: exr.c:2299
EXRThreadData::tmp_size
int tmp_size
Definition: exr.c:117
intfloat.h
EXRThreadData::dc_data
uint8_t * dc_data
Definition: exr.c:125
ff_set_dimensions
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.
Definition: utils.c:94
EXRThreadData::rle_size
unsigned rle_size
Definition: exr.c:129
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
thread.h
b44_uncompress
static int b44_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:812
rle
static int rle(uint8_t *dst, const uint8_t *src, int compressed_size, int uncompressed_size)
Definition: exr.c:216
convert
static void convert(float y, float u, float v, float *b, float *g, float *r)
Definition: exr.c:959
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
EXRContext::channel_offsets
int channel_offsets[4]
Definition: exr.c:158
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
ff_thread_get_buffer
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
EXR_B44A
@ EXR_B44A
Definition: exr.c:68
av_csp_trc_func_from_id
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.
Definition: csp.c:291
EXR_HALF
@ EXR_HALF
Definition: exr.c:76
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
rgb
Definition: rpzaenc.c:60
EXR_DWAA
@ EXR_DWAA
Definition: exr.c:69
EXRContext::tile_attr
EXRTileAttribute tile_attr
Definition: exr.c:169
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
apply_lut
static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
Definition: exr.c:289
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:598
cosf
#define cosf(x)
Definition: libm.h:78
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1770
fail
#define fail()
Definition: checkasm.h:179
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1536
EXR_TILE_LEVEL_RIPMAP
@ EXR_TILE_LEVEL_RIPMAP
Definition: exr.c:84
EXR_TILE_ROUND_UNKNOWN
@ EXR_TILE_ROUND_UNKNOWN
Definition: exr.c:91
FFSIGN
#define FFSIGN(a)
Definition: common.h:73
GetBitContext
Definition: get_bits.h:108
ub
#define ub(width, name)
Definition: cbs_h2645.c:400
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:590
EXRContext::current_part
int current_part
Definition: exr.c:172
val
static double val(void *priv, double ch)
Definition: aeval.c:78
type
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
Definition: writing_filters.txt:86
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:466
AVCOL_TRC_LOG_SQRT
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
Definition: pixfmt.h:595
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
EXRContext::avctx
AVCodecContext * avctx
Definition: exr.c:149
ff_exr_decoder
const FFCodec ff_exr_decoder
Definition: exr.c:2353
AVCOL_TRC_SMPTEST428_1
@ AVCOL_TRC_SMPTEST428_1
Definition: pixfmt.h:604
huf_build_dec_table
static int huf_build_dec_table(const EXRContext *s, EXRThreadData *td, int im, int iM)
Definition: exr.c:368
EXRThreadData::he
HuffEntry * he
Definition: exr.c:141
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:589
av_image_check_size2
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...
Definition: imgutils.c:289
EXRContext::scan_lines_per_block
int scan_lines_per_block
Definition: exr.c:167
EXRContext::h
int h
Definition: exr.c:161
EXRThreadData::rle_raw_data
uint8_t * rle_raw_data
Definition: exr.c:131
EXR_DWAB
@ EXR_DWAB
Definition: exr.c:70
ExrDSPContext
Definition: exrdsp.h:25
EXRThreadData::channel_line_size
int channel_line_size
Definition: exr.c:138
USHORT_RANGE
#define USHORT_RANGE
Definition: exr.c:271
avassert.h
to_linear
static float to_linear(float x, float scale)
Definition: exr.c:967
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: exr.c:2271
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
EXRContext::sar
uint32_t sar
Definition: exr.c:162
EXRThreadData::ac_size
unsigned ac_size
Definition: exr.c:123
EXR_FLOAT
@ EXR_FLOAT
Definition: exr.c:77
BITMAP_SIZE
#define BITMAP_SIZE
Definition: exr.c:272
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
EXRContext::compression
enum ExrCompr compression
Definition: exr.c:156
EXRThreadData::ac_data
uint8_t * ac_data
Definition: exr.c:122
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
check_header_variable
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.
Definition: exr.c:1506
s
#define s(width, name)
Definition: cbs_vp9.c:198
huf_canonical_code_table
static void huf_canonical_code_table(uint64_t *freq)
Definition: exr.c:300
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:597
g
const char * g
Definition: vf_curves.c:127
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
EXRContext::current_channel_offset
int current_channel_offset
Definition: exr.c:182
HuffEntry::sym
uint16_t sym
Definition: exr.c:96
EXRContext::xmax
int32_t xmax
Definition: exr.c:163
decode_block
static int decode_block(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
Definition: exr.c:1170
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
EXRChannel::pixel_type
enum ExrPixelType pixel_type
Definition: exr.c:102
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
get_bits.h
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1963
SHORTEST_LONG_RUN
#define SHORTEST_LONG_RUN
Definition: exr.c:325
blk
#define blk(i)
Definition: sha.c:186
skip_header_chunk
static void skip_header_chunk(EXRContext *s)
Definition: exr.c:1477
key
const char * key
Definition: hwcontext_opencl.c:179
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:515
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
EXR_ZIP1
@ EXR_ZIP1
Definition: exr.c:63
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
EXRContext::desc
const AVPixFmtDescriptor * desc
Definition: exr.c:159
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:32
EXRContext::is_luma
int is_luma
Definition: exr.c:174
AV_CODEC_ID_EXR
@ AV_CODEC_ID_EXR
Definition: codec_id.h:232
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:472
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
exrdsp.h
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:203
bias
static int bias(int x, int c)
Definition: vqcdec.c:114
LONG_ZEROCODE_RUN
#define LONG_ZEROCODE_RUN
Definition: exr.c:324
pixel
uint8_t pixel
Definition: tiny_ssim.c:41
SHORT_ZEROCODE_RUN
#define SHORT_ZEROCODE_RUN
Definition: exr.c:323
AVCOL_TRC_IEC61966_2_4
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:596
EXR_RLE
@ EXR_RLE
Definition: exr.c:62
EXR_TILE_ROUND_UP
@ EXR_TILE_ROUND_UP
Definition: exr.c:89
EXRChannel::ysub
int ysub
Definition: exr.c:101
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
EXRThreadData::block
float block[3][64]
Definition: exr.c:134
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:109
mathops.h
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
ff_exrdsp_init
av_cold void ff_exrdsp_init(ExrDSPContext *c)
Definition: exrdsp.c:59
EXRContext::w
int w
Definition: exr.c:161
AVCOL_TRC_BT2020_10
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
Definition: pixfmt.h:599
av_intfloat32
Definition: intfloat.h:27
unpack_14
static void unpack_14(const uint8_t b[14], uint16_t s[16])
Definition: exr.c:761
EXR_PIZ
@ EXR_PIZ
Definition: exr.c:65
A_OFFSET
#define A_OFFSET
Definition: exr.c:499
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
c
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
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
EXRThreadData::bitmap
uint8_t * bitmap
Definition: exr.c:119
PutByteContext
Definition: bytestream.h:37
EXRContext::pixel_type
enum ExrPixelType pixel_type
Definition: exr.c:157
EXRTileAttribute::level_mode
enum ExrTileLevelMode level_mode
Definition: exr.c:108
EXRChannel::xsub
int xsub
Definition: exr.c:101
EXRContext::thread_data
EXRThreadData * thread_data
Definition: exr.c:185
EXR_RAW
@ EXR_RAW
Definition: exr.c:61
planes
static const struct @378 planes[]
f
f
Definition: af_crystalizer.c:121
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
wdec14
static void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:485
AVPacket::size
int size
Definition: packet.h:523
wav_decode
static void wav_decode(uint16_t *in, int nx, int ox, int ny, int oy, uint16_t mx)
Definition: exr.c:512
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
dc
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]
Definition: snow.txt:400
powf
#define powf(x, y)
Definition: libm.h:50
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:592
codec_internal.h
MOD_MASK
#define MOD_MASK
Definition: exr.c:500
dwa_uncompress
static int dwa_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:980
shift
static int shift(int a, int b)
Definition: bonk.c:262
AVCOL_TRC_SMPTEST2084
@ AVCOL_TRC_SMPTEST2084
Definition: pixfmt.h:602
AVCOL_TRC_LOG
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
Definition: pixfmt.h:594
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
EXRTileAttribute::xSize
int32_t xSize
Definition: exr.c:106
bytestream2_get_ne16
#define bytestream2_get_ne16
Definition: bytestream.h:119
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:512
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:468
size
int size
Definition: twinvq_data.h:10344
EXRThreadData::tmp
uint8_t * tmp
Definition: exr.c:116
EXRContext::is_tile
int is_tile
Definition: exr.c:170
EXR_TILE_LEVEL_MIPMAP
@ EXR_TILE_LEVEL_MIPMAP
Definition: exr.c:83
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#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...
Definition: codec_internal.h:54
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
EXRContext::gamma
float gamma
Definition: exr.c:191
ac_uncompress
static int ac_uncompress(const EXRContext *s, GetByteContext *gb, float *block)
Definition: exr.c:883
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
EXRContext::gb
GetByteContext gb
Definition: exr.c:176
idct_1d
static void idct_1d(float *blk, int step)
Definition: exr.c:904
height
#define height
a
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
Definition: undefined.txt:41
EXRContext::ymin
int32_t ymin
Definition: exr.c:164
csp.h
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
line
Definition: graph2dot.c:48
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:225
EXR_ZIP16
@ EXR_ZIP16
Definition: exr.c:64
EXRContext::apply_trc_type
enum AVColorTransferCharacteristic apply_trc_type
Definition: exr.c:190
ff_vlc_init_sparse
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().
Definition: vlc.c:250
version
version
Definition: libkvazaar.c:321
M_PI
#define M_PI
Definition: mathematics.h:67
half2float.h
unpack_3
static void unpack_3(const uint8_t b[3], uint16_t s[16])
Definition: exr.c:796
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:586
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
dct_inverse
static void dct_inverse(float *block)
Definition: exr.c:948
av_csp_trc_function
double(* av_csp_trc_function)(double)
Function pointer representing a double -> double transfer function that performs an EOTF transfer inv...
Definition: csp.h:87
EXRContext::selected_part
int selected_part
Definition: exr.c:188
EXRContext::h2f_tables
Half2FloatTables h2f_tables
Definition: exr.c:196
ExrTileLevelRound
ExrTileLevelRound
Definition: exr.c:88
OFFSET
#define OFFSET(x)
Definition: exr.c:2297
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:467
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
FFMIN3
#define FFMIN3(a, b, c)
Definition: macros.h:50
EXRContext::offset_table
uint8_t * offset_table
Definition: exr.c:194
HUF_ENCSIZE
#define HUF_ENCSIZE
Definition: exr.c:298
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
EXRContext::buf
const uint8_t * buf
Definition: exr.c:177
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
EXRThreadData::xsize
int xsize
Definition: exr.c:136
av_fast_padded_malloc
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...
Definition: utils.c:52
EXR_PXR24
@ EXR_PXR24
Definition: exr.c:66
value
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
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
EXR_UINT
@ EXR_UINT
Definition: exr.c:75
huf_unpack_enc_table
static int huf_unpack_enc_table(GetByteContext *gb, int32_t im, int32_t iM, uint64_t *freq)
Definition: exr.c:328
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
EXR_B44
@ EXR_B44
Definition: exr.c:67
avcodec.h
EXRContext::nb_channels
int nb_channels
Definition: exr.c:181
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:577
ret
ret
Definition: filter_design.txt:187
huf_decode
static int huf_decode(VLC *vlc, GetByteContext *gb, int nbits, int run_sym, int no, uint16_t *out)
Definition: exr.c:414
half2float
static uint32_t half2float(uint16_t h, const Half2FloatTables *t)
Definition: half2float.h:39
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
ff_init_half2float_tables
void ff_init_half2float_tables(Half2FloatTables *t)
Definition: half2float.c:39
rle_uncompress
static int rle_uncompress(const EXRContext *ctx, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:258
EXRContext::gamma_table
union av_intfloat32 gamma_table[65536]
Definition: exr.c:192
EXRThreadData::dc_size
unsigned dc_size
Definition: exr.c:126
HuffEntry::code
uint32_t code
Definition: exr.c:97
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
EXRThreadData::freq
uint64_t * freq
Definition: exr.c:142
EXRContext::is_multipart
int is_multipart
Definition: exr.c:171
AVCodecContext
main external API structure.
Definition: avcodec.h:445
pxr24_uncompress
static int pxr24_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:677
EXRContext::channels
EXRChannel * channels
Definition: exr.c:180
EXR_UNKNOWN
@ EXR_UNKNOWN
Definition: exr.c:78
EXRContext::ymax
int32_t ymax
Definition: exr.c:164
EXRContext::ydelta
uint32_t ydelta
Definition: exr.c:165
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
VLC
Definition: vlc.h:36
wdec16
static void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:502
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:513
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:708
EXRThreadData::run_sym
int run_sym
Definition: exr.c:140
HuffEntry
Definition: exr.c:94
VLC::table
VLCElem * table
Definition: vlc.h:38
AVCOL_TRC_SMPTE170M
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:591
EXR_TILE_LEVEL_UNKNOWN
@ EXR_TILE_LEVEL_UNKNOWN
Definition: exr.c:85
av_intfloat32::f
float f
Definition: intfloat.h:29
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
huf_uncompress
static int huf_uncompress(const EXRContext *s, EXRThreadData *td, GetByteContext *gb, uint16_t *dst, int dst_size)
Definition: exr.c:443
ExrCompr
ExrCompr
Definition: exr.c:60
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
zip_uncompress
static int zip_uncompress(const EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:199
EXRContext::buf_size
int buf_size
Definition: exr.c:178
d
d
Definition: ffmpeg_filter.c:424
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
ExrTileLevelMode
ExrTileLevelMode
Definition: exr.c:81
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
EXRTileAttribute::ySize
int32_t ySize
Definition: exr.c:107
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
exr_class
static const AVClass exr_class
Definition: exr.c:2346
BswapDSPContext
Definition: bswapdsp.h:24
h
h
Definition: vp9dsp_template.c:2038
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
EXRContext::xmin
int32_t xmin
Definition: exr.c:163
EXRContext::xdelta
uint32_t xdelta
Definition: exr.c:165
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AVCodecContext::execute2
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.
Definition: avcodec.h:1585
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
line
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
Definition: swscale.txt:40
channel
channel
Definition: ebur128.h:39
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
EXRContext::dsp
ExrDSPContext dsp
Definition: exr.c:150
EXR_UNKN
@ EXR_UNKN
Definition: exr.c:71
EXRContext
Definition: exr.c:146
EXRChannel
Definition: exr.c:100