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  * exr_flt2uint() and exr_halflt2uint() is credited to Reimar Döffinger.
34  * exr_half2float() is credited to Aaftab Munshi, Dan Ginsburg, Dave Shreiner.
35  */
36 
37 #include <float.h>
38 #include <zlib.h>
39 
40 #include "libavutil/avassert.h"
41 #include "libavutil/common.h"
42 #include "libavutil/imgutils.h"
43 #include "libavutil/intfloat.h"
44 #include "libavutil/opt.h"
45 #include "libavutil/color_utils.h"
46 
47 #include "avcodec.h"
48 #include "bytestream.h"
49 
50 #if HAVE_BIGENDIAN
51 #include "bswapdsp.h"
52 #endif
53 
54 #include "exrdsp.h"
55 #include "get_bits.h"
56 #include "internal.h"
57 #include "mathops.h"
58 #include "thread.h"
59 
60 enum ExrCompr {
72 };
73 
79 };
80 
86 };
87 
92 };
93 
94 typedef struct EXRChannel {
95  int xsub, ysub;
97 } EXRChannel;
98 
99 typedef struct EXRTileAttribute {
105 
106 typedef struct EXRThreadData {
109 
111  int tmp_size;
112 
114  uint16_t *lut;
115 
116  int ysize, xsize;
117 
119 } EXRThreadData;
120 
121 typedef struct EXRContext {
122  AVClass *class;
126 
127 #if HAVE_BIGENDIAN
128  BswapDSPContext bbdsp;
129 #endif
130 
133  int channel_offsets[4]; // 0 = red, 1 = green, 2 = blue and 3 = alpha
135 
136  int w, h;
137  uint32_t xmax, xmin;
138  uint32_t ymax, ymin;
139  uint32_t xdelta, ydelta;
140 
142 
143  EXRTileAttribute tile_attr; /* header data attribute of tile */
144  int is_tile; /* 0 if scanline, 1 if tile */
145 
146  int is_luma;/* 1 if there is an Y plane */
147 
149  const uint8_t *buf;
150  int buf_size;
151 
155 
157 
158  const char *layer;
159 
161  float gamma;
162  uint16_t gamma_table[65536];
163 } EXRContext;
164 
165 /* -15 stored using a single precision bias of 127 */
166 #define HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP 0x38000000
167 
168 /* max exponent value in single precision that will be converted
169  * to Inf or Nan when stored as a half-float */
170 #define HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP 0x47800000
171 
172 /* 255 is the max exponent biased value */
173 #define FLOAT_MAX_BIASED_EXP (0xFF << 23)
174 
175 #define HALF_FLOAT_MAX_BIASED_EXP (0x1F << 10)
176 
177 /**
178  * Convert a half float as a uint16_t into a full float.
179  *
180  * @param hf half float as uint16_t
181  *
182  * @return float value
183  */
184 static union av_intfloat32 exr_half2float(uint16_t hf)
185 {
186  unsigned int sign = (unsigned int) (hf >> 15);
187  unsigned int mantissa = (unsigned int) (hf & ((1 << 10) - 1));
188  unsigned int exp = (unsigned int) (hf & HALF_FLOAT_MAX_BIASED_EXP);
189  union av_intfloat32 f;
190 
192  // we have a half-float NaN or Inf
193  // half-float NaNs will be converted to a single precision NaN
194  // half-float Infs will be converted to a single precision Inf
196  if (mantissa)
197  mantissa = (1 << 23) - 1; // set all bits to indicate a NaN
198  } else if (exp == 0x0) {
199  // convert half-float zero/denorm to single precision value
200  if (mantissa) {
201  mantissa <<= 1;
203  // check for leading 1 in denorm mantissa
204  while ((mantissa & (1 << 10))) {
205  // for every leading 0, decrement single precision exponent by 1
206  // and shift half-float mantissa value to the left
207  mantissa <<= 1;
208  exp -= (1 << 23);
209  }
210  // clamp the mantissa to 10 bits
211  mantissa &= ((1 << 10) - 1);
212  // shift left to generate single-precision mantissa of 23 bits
213  mantissa <<= 13;
214  }
215  } else {
216  // shift left to generate single-precision mantissa of 23 bits
217  mantissa <<= 13;
218  // generate single precision biased exponent value
220  }
221 
222  f.i = (sign << 31) | exp | mantissa;
223 
224  return f;
225 }
226 
227 
228 /**
229  * Convert from 32-bit float as uint32_t to uint16_t.
230  *
231  * @param v 32-bit float
232  *
233  * @return normalized 16-bit unsigned int
234  */
235 static inline uint16_t exr_flt2uint(int32_t v)
236 {
237  int32_t exp = v >> 23;
238  // "HACK": negative values result in exp< 0, so clipping them to 0
239  // is also handled by this condition, avoids explicit check for sign bit.
240  if (exp <= 127 + 7 - 24) // we would shift out all bits anyway
241  return 0;
242  if (exp >= 127)
243  return 0xffff;
244  v &= 0x007fffff;
245  return (v + (1 << 23)) >> (127 + 7 - exp);
246 }
247 
248 /**
249  * Convert from 16-bit float as uint16_t to uint16_t.
250  *
251  * @param v 16-bit float
252  *
253  * @return normalized 16-bit unsigned int
254  */
255 static inline uint16_t exr_halflt2uint(uint16_t v)
256 {
257  unsigned exp = 14 - (v >> 10);
258  if (exp >= 14) {
259  if (exp == 14)
260  return (v >> 9) & 1;
261  else
262  return (v & 0x8000) ? 0 : 0xffff;
263  }
264  v <<= 6;
265  return (v + (1 << 16)) >> (exp + 1);
266 }
267 
268 static int zip_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
269  int uncompressed_size, EXRThreadData *td)
270 {
271  unsigned long dest_len = uncompressed_size;
272 
273  if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK ||
274  dest_len != uncompressed_size)
275  return AVERROR_INVALIDDATA;
276 
277  av_assert1(uncompressed_size % 2 == 0);
278 
279  s->dsp.predictor(td->tmp, uncompressed_size);
280  s->dsp.reorder_pixels(td->uncompressed_data, td->tmp, uncompressed_size);
281 
282  return 0;
283 }
284 
285 static int rle_uncompress(EXRContext *ctx, const uint8_t *src, int compressed_size,
286  int uncompressed_size, EXRThreadData *td)
287 {
288  uint8_t *d = td->tmp;
289  const int8_t *s = src;
290  int ssize = compressed_size;
291  int dsize = uncompressed_size;
292  uint8_t *dend = d + dsize;
293  int count;
294 
295  while (ssize > 0) {
296  count = *s++;
297 
298  if (count < 0) {
299  count = -count;
300 
301  if ((dsize -= count) < 0 ||
302  (ssize -= count + 1) < 0)
303  return AVERROR_INVALIDDATA;
304 
305  while (count--)
306  *d++ = *s++;
307  } else {
308  count++;
309 
310  if ((dsize -= count) < 0 ||
311  (ssize -= 2) < 0)
312  return AVERROR_INVALIDDATA;
313 
314  while (count--)
315  *d++ = *s;
316 
317  s++;
318  }
319  }
320 
321  if (dend != d)
322  return AVERROR_INVALIDDATA;
323 
324  av_assert1(uncompressed_size % 2 == 0);
325 
326  ctx->dsp.predictor(td->tmp, uncompressed_size);
327  ctx->dsp.reorder_pixels(td->uncompressed_data, td->tmp, uncompressed_size);
328 
329  return 0;
330 }
331 
332 #define USHORT_RANGE (1 << 16)
333 #define BITMAP_SIZE (1 << 13)
334 
335 static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
336 {
337  int i, k = 0;
338 
339  for (i = 0; i < USHORT_RANGE; i++)
340  if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
341  lut[k++] = i;
342 
343  i = k - 1;
344 
345  memset(lut + k, 0, (USHORT_RANGE - k) * 2);
346 
347  return i;
348 }
349 
350 static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
351 {
352  int i;
353 
354  for (i = 0; i < dsize; ++i)
355  dst[i] = lut[dst[i]];
356 }
357 
358 #define HUF_ENCBITS 16 // literal (value) bit length
359 #define HUF_DECBITS 14 // decoding bit size (>= 8)
360 
361 #define HUF_ENCSIZE ((1 << HUF_ENCBITS) + 1) // encoding table size
362 #define HUF_DECSIZE (1 << HUF_DECBITS) // decoding table size
363 #define HUF_DECMASK (HUF_DECSIZE - 1)
364 
365 typedef struct HufDec {
366  int len;
367  int lit;
368  int *p;
369 } HufDec;
370 
371 static void huf_canonical_code_table(uint64_t *hcode)
372 {
373  uint64_t c, n[59] = { 0 };
374  int i;
375 
376  for (i = 0; i < HUF_ENCSIZE; ++i)
377  n[hcode[i]] += 1;
378 
379  c = 0;
380  for (i = 58; i > 0; --i) {
381  uint64_t nc = ((c + n[i]) >> 1);
382  n[i] = c;
383  c = nc;
384  }
385 
386  for (i = 0; i < HUF_ENCSIZE; ++i) {
387  int l = hcode[i];
388 
389  if (l > 0)
390  hcode[i] = l | (n[l]++ << 6);
391  }
392 }
393 
394 #define SHORT_ZEROCODE_RUN 59
395 #define LONG_ZEROCODE_RUN 63
396 #define SHORTEST_LONG_RUN (2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN)
397 #define LONGEST_LONG_RUN (255 + SHORTEST_LONG_RUN)
398 
400  int32_t im, int32_t iM, uint64_t *hcode)
401 {
402  GetBitContext gbit;
403  int ret = init_get_bits8(&gbit, gb->buffer, bytestream2_get_bytes_left(gb));
404  if (ret < 0)
405  return ret;
406 
407  for (; im <= iM; im++) {
408  uint64_t l = hcode[im] = get_bits(&gbit, 6);
409 
410  if (l == LONG_ZEROCODE_RUN) {
411  int zerun = get_bits(&gbit, 8) + SHORTEST_LONG_RUN;
412 
413  if (im + zerun > iM + 1)
414  return AVERROR_INVALIDDATA;
415 
416  while (zerun--)
417  hcode[im++] = 0;
418 
419  im--;
420  } else if (l >= SHORT_ZEROCODE_RUN) {
421  int zerun = l - SHORT_ZEROCODE_RUN + 2;
422 
423  if (im + zerun > iM + 1)
424  return AVERROR_INVALIDDATA;
425 
426  while (zerun--)
427  hcode[im++] = 0;
428 
429  im--;
430  }
431  }
432 
433  bytestream2_skip(gb, (get_bits_count(&gbit) + 7) / 8);
435 
436  return 0;
437 }
438 
439 static int huf_build_dec_table(const uint64_t *hcode, int im,
440  int iM, HufDec *hdecod)
441 {
442  for (; im <= iM; im++) {
443  uint64_t c = hcode[im] >> 6;
444  int i, l = hcode[im] & 63;
445 
446  if (c >> l)
447  return AVERROR_INVALIDDATA;
448 
449  if (l > HUF_DECBITS) {
450  HufDec *pl = hdecod + (c >> (l - HUF_DECBITS));
451  if (pl->len)
452  return AVERROR_INVALIDDATA;
453 
454  pl->lit++;
455 
456  pl->p = av_realloc(pl->p, pl->lit * sizeof(int));
457  if (!pl->p)
458  return AVERROR(ENOMEM);
459 
460  pl->p[pl->lit - 1] = im;
461  } else if (l) {
462  HufDec *pl = hdecod + (c << (HUF_DECBITS - l));
463 
464  for (i = 1 << (HUF_DECBITS - l); i > 0; i--, pl++) {
465  if (pl->len || pl->p)
466  return AVERROR_INVALIDDATA;
467  pl->len = l;
468  pl->lit = im;
469  }
470  }
471  }
472 
473  return 0;
474 }
475 
476 #define get_char(c, lc, gb) \
477 { \
478  c = (c << 8) | bytestream2_get_byte(gb); \
479  lc += 8; \
480 }
481 
482 #define get_code(po, rlc, c, lc, gb, out, oe, outb) \
483 { \
484  if (po == rlc) { \
485  if (lc < 8) \
486  get_char(c, lc, gb); \
487  lc -= 8; \
488  \
489  cs = c >> lc; \
490  \
491  if (out + cs > oe || out == outb) \
492  return AVERROR_INVALIDDATA; \
493  \
494  s = out[-1]; \
495  \
496  while (cs-- > 0) \
497  *out++ = s; \
498  } else if (out < oe) { \
499  *out++ = po; \
500  } else { \
501  return AVERROR_INVALIDDATA; \
502  } \
503 }
504 
505 static int huf_decode(const uint64_t *hcode, const HufDec *hdecod,
506  GetByteContext *gb, int nbits,
507  int rlc, int no, uint16_t *out)
508 {
509  uint64_t c = 0;
510  uint16_t *outb = out;
511  uint16_t *oe = out + no;
512  const uint8_t *ie = gb->buffer + (nbits + 7) / 8; // input byte size
513  uint8_t cs;
514  uint16_t s;
515  int i, lc = 0;
516 
517  while (gb->buffer < ie) {
518  get_char(c, lc, gb);
519 
520  while (lc >= HUF_DECBITS) {
521  const HufDec pl = hdecod[(c >> (lc - HUF_DECBITS)) & HUF_DECMASK];
522 
523  if (pl.len) {
524  lc -= pl.len;
525  get_code(pl.lit, rlc, c, lc, gb, out, oe, outb);
526  } else {
527  int j;
528 
529  if (!pl.p)
530  return AVERROR_INVALIDDATA;
531 
532  for (j = 0; j < pl.lit; j++) {
533  int l = hcode[pl.p[j]] & 63;
534 
535  while (lc < l && bytestream2_get_bytes_left(gb) > 0)
536  get_char(c, lc, gb);
537 
538  if (lc >= l) {
539  if ((hcode[pl.p[j]] >> 6) ==
540  ((c >> (lc - l)) & ((1LL << l) - 1))) {
541  lc -= l;
542  get_code(pl.p[j], rlc, c, lc, gb, out, oe, outb);
543  break;
544  }
545  }
546  }
547 
548  if (j == pl.lit)
549  return AVERROR_INVALIDDATA;
550  }
551  }
552  }
553 
554  i = (8 - nbits) & 7;
555  c >>= i;
556  lc -= i;
557 
558  while (lc > 0) {
559  const HufDec pl = hdecod[(c << (HUF_DECBITS - lc)) & HUF_DECMASK];
560 
561  if (pl.len && lc >= pl.len) {
562  lc -= pl.len;
563  get_code(pl.lit, rlc, c, lc, gb, out, oe, outb);
564  } else {
565  return AVERROR_INVALIDDATA;
566  }
567  }
568 
569  if (out - outb != no)
570  return AVERROR_INVALIDDATA;
571  return 0;
572 }
573 
575  uint16_t *dst, int dst_size)
576 {
577  int32_t src_size, im, iM;
578  uint32_t nBits;
579  uint64_t *freq;
580  HufDec *hdec;
581  int ret, i;
582 
583  src_size = bytestream2_get_le32(gb);
584  im = bytestream2_get_le32(gb);
585  iM = bytestream2_get_le32(gb);
586  bytestream2_skip(gb, 4);
587  nBits = bytestream2_get_le32(gb);
588  if (im < 0 || im >= HUF_ENCSIZE ||
589  iM < 0 || iM >= HUF_ENCSIZE ||
590  src_size < 0)
591  return AVERROR_INVALIDDATA;
592 
593  bytestream2_skip(gb, 4);
594 
595  freq = av_mallocz_array(HUF_ENCSIZE, sizeof(*freq));
596  hdec = av_mallocz_array(HUF_DECSIZE, sizeof(*hdec));
597  if (!freq || !hdec) {
598  ret = AVERROR(ENOMEM);
599  goto fail;
600  }
601 
602  if ((ret = huf_unpack_enc_table(gb, im, iM, freq)) < 0)
603  goto fail;
604 
605  if (nBits > 8 * bytestream2_get_bytes_left(gb)) {
607  goto fail;
608  }
609 
610  if ((ret = huf_build_dec_table(freq, im, iM, hdec)) < 0)
611  goto fail;
612  ret = huf_decode(freq, hdec, gb, nBits, iM, dst_size, dst);
613 
614 fail:
615  for (i = 0; i < HUF_DECSIZE; i++)
616  if (hdec)
617  av_freep(&hdec[i].p);
618 
619  av_free(freq);
620  av_free(hdec);
621 
622  return ret;
623 }
624 
625 static inline void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
626 {
627  int16_t ls = l;
628  int16_t hs = h;
629  int hi = hs;
630  int ai = ls + (hi & 1) + (hi >> 1);
631  int16_t as = ai;
632  int16_t bs = ai - hi;
633 
634  *a = as;
635  *b = bs;
636 }
637 
638 #define NBITS 16
639 #define A_OFFSET (1 << (NBITS - 1))
640 #define MOD_MASK ((1 << NBITS) - 1)
641 
642 static inline void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
643 {
644  int m = l;
645  int d = h;
646  int bb = (m - (d >> 1)) & MOD_MASK;
647  int aa = (d + bb - A_OFFSET) & MOD_MASK;
648  *b = bb;
649  *a = aa;
650 }
651 
652 static void wav_decode(uint16_t *in, int nx, int ox,
653  int ny, int oy, uint16_t mx)
654 {
655  int w14 = (mx < (1 << 14));
656  int n = (nx > ny) ? ny : nx;
657  int p = 1;
658  int p2;
659 
660  while (p <= n)
661  p <<= 1;
662 
663  p >>= 1;
664  p2 = p;
665  p >>= 1;
666 
667  while (p >= 1) {
668  uint16_t *py = in;
669  uint16_t *ey = in + oy * (ny - p2);
670  uint16_t i00, i01, i10, i11;
671  int oy1 = oy * p;
672  int oy2 = oy * p2;
673  int ox1 = ox * p;
674  int ox2 = ox * p2;
675 
676  for (; py <= ey; py += oy2) {
677  uint16_t *px = py;
678  uint16_t *ex = py + ox * (nx - p2);
679 
680  for (; px <= ex; px += ox2) {
681  uint16_t *p01 = px + ox1;
682  uint16_t *p10 = px + oy1;
683  uint16_t *p11 = p10 + ox1;
684 
685  if (w14) {
686  wdec14(*px, *p10, &i00, &i10);
687  wdec14(*p01, *p11, &i01, &i11);
688  wdec14(i00, i01, px, p01);
689  wdec14(i10, i11, p10, p11);
690  } else {
691  wdec16(*px, *p10, &i00, &i10);
692  wdec16(*p01, *p11, &i01, &i11);
693  wdec16(i00, i01, px, p01);
694  wdec16(i10, i11, p10, p11);
695  }
696  }
697 
698  if (nx & p) {
699  uint16_t *p10 = px + oy1;
700 
701  if (w14)
702  wdec14(*px, *p10, &i00, p10);
703  else
704  wdec16(*px, *p10, &i00, p10);
705 
706  *px = i00;
707  }
708  }
709 
710  if (ny & p) {
711  uint16_t *px = py;
712  uint16_t *ex = py + ox * (nx - p2);
713 
714  for (; px <= ex; px += ox2) {
715  uint16_t *p01 = px + ox1;
716 
717  if (w14)
718  wdec14(*px, *p01, &i00, p01);
719  else
720  wdec16(*px, *p01, &i00, p01);
721 
722  *px = i00;
723  }
724  }
725 
726  p2 = p;
727  p >>= 1;
728  }
729 }
730 
731 static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
732  int dsize, EXRThreadData *td)
733 {
734  GetByteContext gb;
735  uint16_t maxval, min_non_zero, max_non_zero;
736  uint16_t *ptr;
737  uint16_t *tmp = (uint16_t *)td->tmp;
738  uint16_t *out;
739  uint16_t *in;
740  int ret, i, j;
741  int pixel_half_size;/* 1 for half, 2 for float and uint32 */
743  int tmp_offset;
744 
745  if (!td->bitmap)
746  td->bitmap = av_malloc(BITMAP_SIZE);
747  if (!td->lut)
748  td->lut = av_malloc(1 << 17);
749  if (!td->bitmap || !td->lut) {
750  av_freep(&td->bitmap);
751  av_freep(&td->lut);
752  return AVERROR(ENOMEM);
753  }
754 
755  bytestream2_init(&gb, src, ssize);
756  min_non_zero = bytestream2_get_le16(&gb);
757  max_non_zero = bytestream2_get_le16(&gb);
758 
759  if (max_non_zero >= BITMAP_SIZE)
760  return AVERROR_INVALIDDATA;
761 
762  memset(td->bitmap, 0, FFMIN(min_non_zero, BITMAP_SIZE));
763  if (min_non_zero <= max_non_zero)
764  bytestream2_get_buffer(&gb, td->bitmap + min_non_zero,
765  max_non_zero - min_non_zero + 1);
766  memset(td->bitmap + max_non_zero + 1, 0, BITMAP_SIZE - max_non_zero - 1);
767 
768  maxval = reverse_lut(td->bitmap, td->lut);
769 
770  ret = huf_uncompress(&gb, tmp, dsize / sizeof(uint16_t));
771  if (ret)
772  return ret;
773 
774  ptr = tmp;
775  for (i = 0; i < s->nb_channels; i++) {
776  channel = &s->channels[i];
777 
778  if (channel->pixel_type == EXR_HALF)
779  pixel_half_size = 1;
780  else
781  pixel_half_size = 2;
782 
783  for (j = 0; j < pixel_half_size; j++)
784  wav_decode(ptr + j, td->xsize, pixel_half_size, td->ysize,
785  td->xsize * pixel_half_size, maxval);
786  ptr += td->xsize * td->ysize * pixel_half_size;
787  }
788 
789  apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));
790 
791  out = (uint16_t *)td->uncompressed_data;
792  for (i = 0; i < td->ysize; i++) {
793  tmp_offset = 0;
794  for (j = 0; j < s->nb_channels; j++) {
795  channel = &s->channels[j];
796  if (channel->pixel_type == EXR_HALF)
797  pixel_half_size = 1;
798  else
799  pixel_half_size = 2;
800 
801  in = tmp + tmp_offset * td->xsize * td->ysize + i * td->xsize * pixel_half_size;
802  tmp_offset += pixel_half_size;
803 
804 #if HAVE_BIGENDIAN
805  s->bbdsp.bswap16_buf(out, in, td->xsize * pixel_half_size);
806 #else
807  memcpy(out, in, td->xsize * 2 * pixel_half_size);
808 #endif
809  out += td->xsize * pixel_half_size;
810  }
811  }
812 
813  return 0;
814 }
815 
817  int compressed_size, int uncompressed_size,
818  EXRThreadData *td)
819 {
820  unsigned long dest_len, expected_len = 0;
821  const uint8_t *in = td->tmp;
822  uint8_t *out;
823  int c, i, j;
824 
825  for (i = 0; i < s->nb_channels; i++) {
826  if (s->channels[i].pixel_type == EXR_FLOAT) {
827  expected_len += (td->xsize * td->ysize * 3);/* PRX 24 store float in 24 bit instead of 32 */
828  } else if (s->channels[i].pixel_type == EXR_HALF) {
829  expected_len += (td->xsize * td->ysize * 2);
830  } else {//UINT 32
831  expected_len += (td->xsize * td->ysize * 4);
832  }
833  }
834 
835  dest_len = expected_len;
836 
837  if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK) {
838  return AVERROR_INVALIDDATA;
839  } else if (dest_len != expected_len) {
840  return AVERROR_INVALIDDATA;
841  }
842 
843  out = td->uncompressed_data;
844  for (i = 0; i < td->ysize; i++)
845  for (c = 0; c < s->nb_channels; c++) {
846  EXRChannel *channel = &s->channels[c];
847  const uint8_t *ptr[4];
848  uint32_t pixel = 0;
849 
850  switch (channel->pixel_type) {
851  case EXR_FLOAT:
852  ptr[0] = in;
853  ptr[1] = ptr[0] + td->xsize;
854  ptr[2] = ptr[1] + td->xsize;
855  in = ptr[2] + td->xsize;
856 
857  for (j = 0; j < td->xsize; ++j) {
858  uint32_t diff = ((unsigned)*(ptr[0]++) << 24) |
859  (*(ptr[1]++) << 16) |
860  (*(ptr[2]++) << 8);
861  pixel += diff;
862  bytestream_put_le32(&out, pixel);
863  }
864  break;
865  case EXR_HALF:
866  ptr[0] = in;
867  ptr[1] = ptr[0] + td->xsize;
868  in = ptr[1] + td->xsize;
869  for (j = 0; j < td->xsize; j++) {
870  uint32_t diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
871 
872  pixel += diff;
873  bytestream_put_le16(&out, pixel);
874  }
875  break;
876  case EXR_UINT:
877  ptr[0] = in;
878  ptr[1] = ptr[0] + s->xdelta;
879  ptr[2] = ptr[1] + s->xdelta;
880  ptr[3] = ptr[2] + s->xdelta;
881  in = ptr[3] + s->xdelta;
882 
883  for (j = 0; j < s->xdelta; ++j) {
884  uint32_t diff = ((uint32_t)*(ptr[0]++) << 24) |
885  (*(ptr[1]++) << 16) |
886  (*(ptr[2]++) << 8 ) |
887  (*(ptr[3]++));
888  pixel += diff;
889  bytestream_put_le32(&out, pixel);
890  }
891  break;
892  default:
893  return AVERROR_INVALIDDATA;
894  }
895  }
896 
897  return 0;
898 }
899 
900 static void unpack_14(const uint8_t b[14], uint16_t s[16])
901 {
902  unsigned short shift = (b[ 2] >> 2) & 15;
903  unsigned short bias = (0x20 << shift);
904  int i;
905 
906  s[ 0] = (b[0] << 8) | b[1];
907 
908  s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
909  s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
910  s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
911 
912  s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
913  s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
914  s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
915  s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
916 
917  s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
918  s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
919  s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
920  s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
921 
922  s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
923  s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
924  s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
925  s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
926 
927  for (i = 0; i < 16; ++i) {
928  if (s[i] & 0x8000)
929  s[i] &= 0x7fff;
930  else
931  s[i] = ~s[i];
932  }
933 }
934 
935 static void unpack_3(const uint8_t b[3], uint16_t s[16])
936 {
937  int i;
938 
939  s[0] = (b[0] << 8) | b[1];
940 
941  if (s[0] & 0x8000)
942  s[0] &= 0x7fff;
943  else
944  s[0] = ~s[0];
945 
946  for (i = 1; i < 16; i++)
947  s[i] = s[0];
948 }
949 
950 
951 static int b44_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
952  int uncompressed_size, EXRThreadData *td) {
953  const int8_t *sr = src;
954  int stay_to_uncompress = compressed_size;
955  int nb_b44_block_w, nb_b44_block_h;
956  int index_tl_x, index_tl_y, index_out, index_tmp;
957  uint16_t tmp_buffer[16]; /* B44 use 4x4 half float pixel */
958  int c, iY, iX, y, x;
959  int target_channel_offset = 0;
960 
961  /* calc B44 block count */
962  nb_b44_block_w = td->xsize / 4;
963  if ((td->xsize % 4) != 0)
964  nb_b44_block_w++;
965 
966  nb_b44_block_h = td->ysize / 4;
967  if ((td->ysize % 4) != 0)
968  nb_b44_block_h++;
969 
970  for (c = 0; c < s->nb_channels; c++) {
971  if (s->channels[c].pixel_type == EXR_HALF) {/* B44 only compress half float data */
972  for (iY = 0; iY < nb_b44_block_h; iY++) {
973  for (iX = 0; iX < nb_b44_block_w; iX++) {/* For each B44 block */
974  if (stay_to_uncompress < 3) {
975  av_log(s, AV_LOG_ERROR, "Not enough data for B44A block: %d", stay_to_uncompress);
976  return AVERROR_INVALIDDATA;
977  }
978 
979  if (src[compressed_size - stay_to_uncompress + 2] == 0xfc) { /* B44A block */
980  unpack_3(sr, tmp_buffer);
981  sr += 3;
982  stay_to_uncompress -= 3;
983  } else {/* B44 Block */
984  if (stay_to_uncompress < 14) {
985  av_log(s, AV_LOG_ERROR, "Not enough data for B44 block: %d", stay_to_uncompress);
986  return AVERROR_INVALIDDATA;
987  }
988  unpack_14(sr, tmp_buffer);
989  sr += 14;
990  stay_to_uncompress -= 14;
991  }
992 
993  /* copy data to uncompress buffer (B44 block can exceed target resolution)*/
994  index_tl_x = iX * 4;
995  index_tl_y = iY * 4;
996 
997  for (y = index_tl_y; y < FFMIN(index_tl_y + 4, td->ysize); y++) {
998  for (x = index_tl_x; x < FFMIN(index_tl_x + 4, td->xsize); x++) {
999  index_out = target_channel_offset * td->xsize + y * td->channel_line_size + 2 * x;
1000  index_tmp = (y-index_tl_y) * 4 + (x-index_tl_x);
1001  td->uncompressed_data[index_out] = tmp_buffer[index_tmp] & 0xff;
1002  td->uncompressed_data[index_out + 1] = tmp_buffer[index_tmp] >> 8;
1003  }
1004  }
1005  }
1006  }
1007  target_channel_offset += 2;
1008  } else {/* Float or UINT 32 channel */
1009  if (stay_to_uncompress < td->ysize * td->xsize * 4) {
1010  av_log(s, AV_LOG_ERROR, "Not enough data for uncompress channel: %d", stay_to_uncompress);
1011  return AVERROR_INVALIDDATA;
1012  }
1013 
1014  for (y = 0; y < td->ysize; y++) {
1015  index_out = target_channel_offset * td->xsize + y * td->channel_line_size;
1016  memcpy(&td->uncompressed_data[index_out], sr, td->xsize * 4);
1017  sr += td->xsize * 4;
1018  }
1019  target_channel_offset += 4;
1020 
1021  stay_to_uncompress -= td->ysize * td->xsize * 4;
1022  }
1023  }
1024 
1025  return 0;
1026 }
1027 
1028 static int decode_block(AVCodecContext *avctx, void *tdata,
1029  int jobnr, int threadnr)
1030 {
1031  EXRContext *s = avctx->priv_data;
1032  AVFrame *const p = s->picture;
1033  EXRThreadData *td = &s->thread_data[threadnr];
1034  const uint8_t *channel_buffer[4] = { 0 };
1035  const uint8_t *buf = s->buf;
1036  uint64_t line_offset, uncompressed_size;
1037  uint16_t *ptr_x;
1038  uint8_t *ptr;
1039  uint32_t data_size;
1040  uint64_t line, col = 0;
1041  uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
1042  const uint8_t *src;
1043  int axmax = (avctx->width - (s->xmax + 1)) * 2 * s->desc->nb_components; /* nb pixel to add at the right of the datawindow */
1044  int bxmin = s->xmin * 2 * s->desc->nb_components; /* nb pixel to add at the left of the datawindow */
1045  int i, x, buf_size = s->buf_size;
1046  int c, rgb_channel_count;
1047  float one_gamma = 1.0f / s->gamma;
1048  avpriv_trc_function trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
1049  int ret;
1050 
1051  line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
1052 
1053  if (s->is_tile) {
1054  if (buf_size < 20 || line_offset > buf_size - 20)
1055  return AVERROR_INVALIDDATA;
1056 
1057  src = buf + line_offset + 20;
1058 
1059  tile_x = AV_RL32(src - 20);
1060  tile_y = AV_RL32(src - 16);
1061  tile_level_x = AV_RL32(src - 12);
1062  tile_level_y = AV_RL32(src - 8);
1063 
1064  data_size = AV_RL32(src - 4);
1065  if (data_size <= 0 || data_size > buf_size - line_offset - 20)
1066  return AVERROR_INVALIDDATA;
1067 
1068  if (tile_level_x || tile_level_y) { /* tile level, is not the full res level */
1069  avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
1070  return AVERROR_PATCHWELCOME;
1071  }
1072 
1073  if (s->xmin || s->ymin) {
1074  avpriv_report_missing_feature(s->avctx, "Tiles with xmin/ymin");
1075  return AVERROR_PATCHWELCOME;
1076  }
1077 
1078  line = s->tile_attr.ySize * tile_y;
1079  col = s->tile_attr.xSize * tile_x;
1080 
1081  if (line < s->ymin || line > s->ymax ||
1082  col < s->xmin || col > s->xmax)
1083  return AVERROR_INVALIDDATA;
1084 
1085  td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tile_y * s->tile_attr.ySize);
1086  td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tile_x * s->tile_attr.xSize);
1087 
1088  if (col) { /* not the first tile of the line */
1089  bxmin = 0; /* doesn't add pixel at the left of the datawindow */
1090  }
1091 
1092  if ((col + td->xsize) != s->xdelta)/* not the last tile of the line */
1093  axmax = 0; /* doesn't add pixel at the right of the datawindow */
1094 
1095  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX)
1096  return AVERROR_INVALIDDATA;
1097 
1098  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1099  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1100  } else {
1101  if (buf_size < 8 || line_offset > buf_size - 8)
1102  return AVERROR_INVALIDDATA;
1103 
1104  src = buf + line_offset + 8;
1105  line = AV_RL32(src - 8);
1106 
1107  if (line < s->ymin || line > s->ymax)
1108  return AVERROR_INVALIDDATA;
1109 
1110  data_size = AV_RL32(src - 4);
1111  if (data_size <= 0 || data_size > buf_size - line_offset - 8)
1112  return AVERROR_INVALIDDATA;
1113 
1114  td->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1); /* s->ydelta - line ?? */
1115  td->xsize = s->xdelta;
1116 
1117  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX)
1118  return AVERROR_INVALIDDATA;
1119 
1120  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1121  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1122 
1123  if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
1124  line_offset > buf_size - uncompressed_size)) ||
1125  (s->compression != EXR_RAW && (data_size > uncompressed_size ||
1126  line_offset > buf_size - data_size))) {
1127  return AVERROR_INVALIDDATA;
1128  }
1129  }
1130 
1131  if (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
1132  av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
1133  if (!td->tmp)
1134  return AVERROR(ENOMEM);
1135  }
1136 
1137  if (data_size < uncompressed_size) {
1138  av_fast_padded_malloc(&td->uncompressed_data,
1139  &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
1140 
1141  if (!td->uncompressed_data)
1142  return AVERROR(ENOMEM);
1143 
1145  switch (s->compression) {
1146  case EXR_ZIP1:
1147  case EXR_ZIP16:
1148  ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
1149  break;
1150  case EXR_PIZ:
1151  ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
1152  break;
1153  case EXR_PXR24:
1154  ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
1155  break;
1156  case EXR_RLE:
1157  ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
1158  break;
1159  case EXR_B44:
1160  case EXR_B44A:
1161  ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
1162  break;
1163  }
1164  if (ret < 0) {
1165  av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
1166  return ret;
1167  }
1168  src = td->uncompressed_data;
1169  }
1170 
1171  if (!s->is_luma) {
1172  channel_buffer[0] = src + td->xsize * s->channel_offsets[0];
1173  channel_buffer[1] = src + td->xsize * s->channel_offsets[1];
1174  channel_buffer[2] = src + td->xsize * s->channel_offsets[2];
1175  rgb_channel_count = 3;
1176  } else { /* put y data in the first channel_buffer */
1177  channel_buffer[0] = src + td->xsize * s->channel_offsets[1];
1178  rgb_channel_count = 1;
1179  }
1180  if (s->channel_offsets[3] >= 0)
1181  channel_buffer[3] = src + td->xsize * s->channel_offsets[3];
1182 
1183  ptr = p->data[0] + line * p->linesize[0] + (col * s->desc->nb_components * 2);
1184 
1185  for (i = 0;
1186  i < td->ysize; i++, ptr += p->linesize[0]) {
1187 
1188  const uint8_t * a;
1189  const uint8_t *rgb[3];
1190 
1191  for (c = 0; c < rgb_channel_count; c++){
1192  rgb[c] = channel_buffer[c];
1193  }
1194 
1195  if (channel_buffer[3])
1196  a = channel_buffer[3];
1197 
1198  ptr_x = (uint16_t *) ptr;
1199 
1200  // Zero out the start if xmin is not 0
1201  memset(ptr_x, 0, bxmin);
1202  ptr_x += s->xmin * s->desc->nb_components;
1203 
1204  if (s->pixel_type == EXR_FLOAT) {
1205  // 32-bit
1206  if (trc_func) {
1207  for (x = 0; x < td->xsize; x++) {
1208  union av_intfloat32 t;
1209 
1210  for (c = 0; c < rgb_channel_count; c++) {
1211  t.i = bytestream_get_le32(&rgb[c]);
1212  t.f = trc_func(t.f);
1213  *ptr_x++ = exr_flt2uint(t.i);
1214  }
1215  if (channel_buffer[3])
1216  *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
1217  }
1218  } else {
1219  for (x = 0; x < td->xsize; x++) {
1220  union av_intfloat32 t;
1221  int c;
1222 
1223  for (c = 0; c < rgb_channel_count; c++) {
1224  t.i = bytestream_get_le32(&rgb[c]);
1225  if (t.f > 0.0f) /* avoid negative values */
1226  t.f = powf(t.f, one_gamma);
1227  *ptr_x++ = exr_flt2uint(t.i);
1228  }
1229 
1230  if (channel_buffer[3])
1231  *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
1232  }
1233  }
1234  } else if (s->pixel_type == EXR_HALF) {
1235  // 16-bit
1236  for (x = 0; x < td->xsize; x++) {
1237  int c;
1238  for (c = 0; c < rgb_channel_count; c++) {
1239  *ptr_x++ = s->gamma_table[bytestream_get_le16(&rgb[c])];
1240  }
1241 
1242  if (channel_buffer[3])
1243  *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&a));
1244  }
1245  } else if (s->pixel_type == EXR_UINT) {
1246  for (x = 0; x < td->xsize; x++) {
1247  for (c = 0; c < rgb_channel_count; c++) {
1248  *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
1249  }
1250 
1251  if (channel_buffer[3])
1252  *ptr_x++ = bytestream_get_le32(&a) >> 16;
1253  }
1254  }
1255 
1256  // Zero out the end if xmax+1 is not w
1257  memset(ptr_x, 0, axmax);
1258 
1259  channel_buffer[0] += td->channel_line_size;
1260  channel_buffer[1] += td->channel_line_size;
1261  channel_buffer[2] += td->channel_line_size;
1262  if (channel_buffer[3])
1263  channel_buffer[3] += td->channel_line_size;
1264  }
1265 
1266  return 0;
1267 }
1268 
1269 /**
1270  * Check if the variable name corresponds to its data type.
1271  *
1272  * @param s the EXRContext
1273  * @param value_name name of the variable to check
1274  * @param value_type type of the variable to check
1275  * @param minimum_length minimum length of the variable data
1276  *
1277  * @return bytes to read containing variable data
1278  * -1 if variable is not found
1279  * 0 if buffer ended prematurely
1280  */
1282  const char *value_name,
1283  const char *value_type,
1284  unsigned int minimum_length)
1285 {
1286  int var_size = -1;
1287 
1288  if (bytestream2_get_bytes_left(&s->gb) >= minimum_length &&
1289  !strcmp(s->gb.buffer, value_name)) {
1290  // found value_name, jump to value_type (null terminated strings)
1291  s->gb.buffer += strlen(value_name) + 1;
1292  if (!strcmp(s->gb.buffer, value_type)) {
1293  s->gb.buffer += strlen(value_type) + 1;
1294  var_size = bytestream2_get_le32(&s->gb);
1295  // don't go read past boundaries
1296  if (var_size > bytestream2_get_bytes_left(&s->gb))
1297  var_size = 0;
1298  } else {
1299  // value_type not found, reset the buffer
1300  s->gb.buffer -= strlen(value_name) + 1;
1301  av_log(s->avctx, AV_LOG_WARNING,
1302  "Unknown data type %s for header variable %s.\n",
1303  value_type, value_name);
1304  }
1305  }
1306 
1307  return var_size;
1308 }
1309 
1311 {
1312  AVDictionary *metadata = NULL;
1313  int magic_number, version, i, flags, sar = 0;
1314  int layer_match = 0;
1315  int ret;
1316  int dup_channels = 0;
1317 
1318  s->current_channel_offset = 0;
1319  s->xmin = ~0;
1320  s->xmax = ~0;
1321  s->ymin = ~0;
1322  s->ymax = ~0;
1323  s->xdelta = ~0;
1324  s->ydelta = ~0;
1325  s->channel_offsets[0] = -1;
1326  s->channel_offsets[1] = -1;
1327  s->channel_offsets[2] = -1;
1328  s->channel_offsets[3] = -1;
1329  s->pixel_type = EXR_UNKNOWN;
1330  s->compression = EXR_UNKN;
1331  s->nb_channels = 0;
1332  s->w = 0;
1333  s->h = 0;
1334  s->tile_attr.xSize = -1;
1335  s->tile_attr.ySize = -1;
1336  s->is_tile = 0;
1337  s->is_luma = 0;
1338 
1339  if (bytestream2_get_bytes_left(&s->gb) < 10) {
1340  av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
1341  return AVERROR_INVALIDDATA;
1342  }
1343 
1344  magic_number = bytestream2_get_le32(&s->gb);
1345  if (magic_number != 20000630) {
1346  /* As per documentation of OpenEXR, it is supposed to be
1347  * int 20000630 little-endian */
1348  av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
1349  return AVERROR_INVALIDDATA;
1350  }
1351 
1352  version = bytestream2_get_byte(&s->gb);
1353  if (version != 2) {
1354  avpriv_report_missing_feature(s->avctx, "Version %d", version);
1355  return AVERROR_PATCHWELCOME;
1356  }
1357 
1358  flags = bytestream2_get_le24(&s->gb);
1359 
1360  if (flags & 0x02)
1361  s->is_tile = 1;
1362  if (flags & 0x08) {
1363  avpriv_report_missing_feature(s->avctx, "deep data");
1364  return AVERROR_PATCHWELCOME;
1365  }
1366  if (flags & 0x10) {
1367  avpriv_report_missing_feature(s->avctx, "multipart");
1368  return AVERROR_PATCHWELCOME;
1369  }
1370 
1371  // Parse the header
1372  while (bytestream2_get_bytes_left(&s->gb) > 0 && *s->gb.buffer) {
1373  int var_size;
1374  if ((var_size = check_header_variable(s, "channels",
1375  "chlist", 38)) >= 0) {
1376  GetByteContext ch_gb;
1377  if (!var_size) {
1379  goto fail;
1380  }
1381 
1382  bytestream2_init(&ch_gb, s->gb.buffer, var_size);
1383 
1384  while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
1386  enum ExrPixelType current_pixel_type;
1387  int channel_index = -1;
1388  int xsub, ysub;
1389 
1390  if (strcmp(s->layer, "") != 0) {
1391  if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
1392  layer_match = 1;
1393  av_log(s->avctx, AV_LOG_INFO,
1394  "Channel match layer : %s.\n", ch_gb.buffer);
1395  ch_gb.buffer += strlen(s->layer);
1396  if (*ch_gb.buffer == '.')
1397  ch_gb.buffer++; /* skip dot if not given */
1398  } else {
1399  layer_match = 0;
1400  av_log(s->avctx, AV_LOG_INFO,
1401  "Channel doesn't match layer : %s.\n", ch_gb.buffer);
1402  }
1403  } else {
1404  layer_match = 1;
1405  }
1406 
1407  if (layer_match) { /* only search channel if the layer match is valid */
1408  if (!strcmp(ch_gb.buffer, "R") ||
1409  !strcmp(ch_gb.buffer, "X") ||
1410  !strcmp(ch_gb.buffer, "U")) {
1411  channel_index = 0;
1412  s->is_luma = 0;
1413  } else if (!strcmp(ch_gb.buffer, "G") ||
1414  !strcmp(ch_gb.buffer, "V")) {
1415  channel_index = 1;
1416  s->is_luma = 0;
1417  } else if (!strcmp(ch_gb.buffer, "Y")) {
1418  channel_index = 1;
1419  s->is_luma = 1;
1420  } else if (!strcmp(ch_gb.buffer, "B") ||
1421  !strcmp(ch_gb.buffer, "Z") ||
1422  !strcmp(ch_gb.buffer, "W")){
1423  channel_index = 2;
1424  s->is_luma = 0;
1425  } else if (!strcmp(ch_gb.buffer, "A")) {
1426  channel_index = 3;
1427  } else {
1428  av_log(s->avctx, AV_LOG_WARNING,
1429  "Unsupported channel %.256s.\n", ch_gb.buffer);
1430  }
1431  }
1432 
1433  /* skip until you get a 0 */
1434  while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1435  bytestream2_get_byte(&ch_gb))
1436  continue;
1437 
1438  if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1439  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1441  goto fail;
1442  }
1443 
1444  current_pixel_type = bytestream2_get_le32(&ch_gb);
1445  if (current_pixel_type >= EXR_UNKNOWN) {
1446  avpriv_report_missing_feature(s->avctx, "Pixel type %d",
1447  current_pixel_type);
1449  goto fail;
1450  }
1451 
1452  bytestream2_skip(&ch_gb, 4);
1453  xsub = bytestream2_get_le32(&ch_gb);
1454  ysub = bytestream2_get_le32(&ch_gb);
1455 
1456  if (xsub != 1 || ysub != 1) {
1458  "Subsampling %dx%d",
1459  xsub, ysub);
1461  goto fail;
1462  }
1463 
1464  if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
1465  if (s->pixel_type != EXR_UNKNOWN &&
1466  s->pixel_type != current_pixel_type) {
1467  av_log(s->avctx, AV_LOG_ERROR,
1468  "RGB channels not of the same depth.\n");
1470  goto fail;
1471  }
1472  s->pixel_type = current_pixel_type;
1473  s->channel_offsets[channel_index] = s->current_channel_offset;
1474  } else if (channel_index >= 0) {
1475  av_log(s->avctx, AV_LOG_WARNING,
1476  "Multiple channels with index %d.\n", channel_index);
1477  if (++dup_channels > 10) {
1479  goto fail;
1480  }
1481  }
1482 
1483  s->channels = av_realloc(s->channels,
1484  ++s->nb_channels * sizeof(EXRChannel));
1485  if (!s->channels) {
1486  ret = AVERROR(ENOMEM);
1487  goto fail;
1488  }
1489  channel = &s->channels[s->nb_channels - 1];
1490  channel->pixel_type = current_pixel_type;
1491  channel->xsub = xsub;
1492  channel->ysub = ysub;
1493 
1494  if (current_pixel_type == EXR_HALF) {
1495  s->current_channel_offset += 2;
1496  } else {/* Float or UINT32 */
1497  s->current_channel_offset += 4;
1498  }
1499  }
1500 
1501  /* Check if all channels are set with an offset or if the channels
1502  * are causing an overflow */
1503  if (!s->is_luma){/* if we expected to have at least 3 channels */
1504  if (FFMIN3(s->channel_offsets[0],
1505  s->channel_offsets[1],
1506  s->channel_offsets[2]) < 0) {
1507  if (s->channel_offsets[0] < 0)
1508  av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1509  if (s->channel_offsets[1] < 0)
1510  av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1511  if (s->channel_offsets[2] < 0)
1512  av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1514  goto fail;
1515  }
1516  }
1517 
1518  // skip one last byte and update main gb
1519  s->gb.buffer = ch_gb.buffer + 1;
1520  continue;
1521  } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1522  31)) >= 0) {
1523  int xmin, ymin, xmax, ymax;
1524  if (!var_size) {
1526  goto fail;
1527  }
1528 
1529  xmin = bytestream2_get_le32(&s->gb);
1530  ymin = bytestream2_get_le32(&s->gb);
1531  xmax = bytestream2_get_le32(&s->gb);
1532  ymax = bytestream2_get_le32(&s->gb);
1533 
1534  if (xmin > xmax || ymin > ymax ||
1535  ymax == INT_MAX || xmax == INT_MAX ||
1536  (unsigned)xmax - xmin >= INT_MAX ||
1537  (unsigned)ymax - ymin >= INT_MAX) {
1539  goto fail;
1540  }
1541  s->xmin = xmin;
1542  s->xmax = xmax;
1543  s->ymin = ymin;
1544  s->ymax = ymax;
1545  s->xdelta = (s->xmax - s->xmin) + 1;
1546  s->ydelta = (s->ymax - s->ymin) + 1;
1547 
1548  continue;
1549  } else if ((var_size = check_header_variable(s, "displayWindow",
1550  "box2i", 34)) >= 0) {
1551  if (!var_size) {
1553  goto fail;
1554  }
1555 
1556  bytestream2_skip(&s->gb, 8);
1557  s->w = bytestream2_get_le32(&s->gb) + 1;
1558  s->h = bytestream2_get_le32(&s->gb) + 1;
1559 
1560  continue;
1561  } else if ((var_size = check_header_variable(s, "lineOrder",
1562  "lineOrder", 25)) >= 0) {
1563  int line_order;
1564  if (!var_size) {
1566  goto fail;
1567  }
1568 
1569  line_order = bytestream2_get_byte(&s->gb);
1570  av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1571  if (line_order > 2) {
1572  av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1574  goto fail;
1575  }
1576 
1577  continue;
1578  } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1579  "float", 31)) >= 0) {
1580  if (!var_size) {
1582  goto fail;
1583  }
1584 
1585  sar = bytestream2_get_le32(&s->gb);
1586 
1587  continue;
1588  } else if ((var_size = check_header_variable(s, "compression",
1589  "compression", 29)) >= 0) {
1590  if (!var_size) {
1592  goto fail;
1593  }
1594 
1595  if (s->compression == EXR_UNKN)
1596  s->compression = bytestream2_get_byte(&s->gb);
1597  else
1598  av_log(s->avctx, AV_LOG_WARNING,
1599  "Found more than one compression attribute.\n");
1600 
1601  continue;
1602  } else if ((var_size = check_header_variable(s, "tiles",
1603  "tiledesc", 22)) >= 0) {
1604  char tileLevel;
1605 
1606  if (!s->is_tile)
1607  av_log(s->avctx, AV_LOG_WARNING,
1608  "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1609 
1610  s->tile_attr.xSize = bytestream2_get_le32(&s->gb);
1611  s->tile_attr.ySize = bytestream2_get_le32(&s->gb);
1612 
1613  tileLevel = bytestream2_get_byte(&s->gb);
1614  s->tile_attr.level_mode = tileLevel & 0x0f;
1615  s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1616 
1617  if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN){
1618  avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
1619  s->tile_attr.level_mode);
1621  goto fail;
1622  }
1623 
1624  if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
1625  avpriv_report_missing_feature(s->avctx, "Tile level round %d",
1626  s->tile_attr.level_round);
1628  goto fail;
1629  }
1630 
1631  continue;
1632  } else if ((var_size = check_header_variable(s, "writer",
1633  "string", 1)) >= 0) {
1634  uint8_t key[256] = { 0 };
1635 
1636  bytestream2_get_buffer(&s->gb, key, FFMIN(sizeof(key) - 1, var_size));
1637  av_dict_set(&metadata, "writer", key, 0);
1638 
1639  continue;
1640  }
1641 
1642  // Check if there are enough bytes for a header
1643  if (bytestream2_get_bytes_left(&s->gb) <= 9) {
1644  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1646  goto fail;
1647  }
1648 
1649  // Process unknown variables
1650  for (i = 0; i < 2; i++) // value_name and value_type
1651  while (bytestream2_get_byte(&s->gb) != 0);
1652 
1653  // Skip variable length
1654  bytestream2_skip(&s->gb, bytestream2_get_le32(&s->gb));
1655  }
1656 
1657  ff_set_sar(s->avctx, av_d2q(av_int2float(sar), 255));
1658 
1659  if (s->compression == EXR_UNKN) {
1660  av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
1662  goto fail;
1663  }
1664 
1665  if (s->is_tile) {
1666  if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
1667  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
1669  goto fail;
1670  }
1671  }
1672 
1673  if (bytestream2_get_bytes_left(&s->gb) <= 0) {
1674  av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
1676  goto fail;
1677  }
1678 
1679  frame->metadata = metadata;
1680 
1681  // aaand we are done
1682  bytestream2_skip(&s->gb, 1);
1683  return 0;
1684 fail:
1685  av_dict_free(&metadata);
1686  return ret;
1687 }
1688 
1689 static int decode_frame(AVCodecContext *avctx, void *data,
1690  int *got_frame, AVPacket *avpkt)
1691 {
1692  EXRContext *s = avctx->priv_data;
1693  ThreadFrame frame = { .f = data };
1694  AVFrame *picture = data;
1695  uint8_t *ptr;
1696 
1697  int y, ret;
1698  int out_line_size;
1699  int nb_blocks; /* nb scanline or nb tile */
1700  uint64_t start_offset_table;
1701  uint64_t start_next_scanline;
1702  PutByteContext offset_table_writer;
1703 
1704  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
1705 
1706  if ((ret = decode_header(s, picture)) < 0)
1707  return ret;
1708 
1709  switch (s->pixel_type) {
1710  case EXR_FLOAT:
1711  case EXR_HALF:
1712  case EXR_UINT:
1713  if (s->channel_offsets[3] >= 0) {
1714  if (!s->is_luma) {
1715  avctx->pix_fmt = AV_PIX_FMT_RGBA64;
1716  } else {
1717  avctx->pix_fmt = AV_PIX_FMT_YA16;
1718  }
1719  } else {
1720  if (!s->is_luma) {
1721  avctx->pix_fmt = AV_PIX_FMT_RGB48;
1722  } else {
1723  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
1724  }
1725  }
1726  break;
1727  default:
1728  av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
1729  return AVERROR_INVALIDDATA;
1730  }
1731 
1732  if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
1733  avctx->color_trc = s->apply_trc_type;
1734 
1735  switch (s->compression) {
1736  case EXR_RAW:
1737  case EXR_RLE:
1738  case EXR_ZIP1:
1739  s->scan_lines_per_block = 1;
1740  break;
1741  case EXR_PXR24:
1742  case EXR_ZIP16:
1743  s->scan_lines_per_block = 16;
1744  break;
1745  case EXR_PIZ:
1746  case EXR_B44:
1747  case EXR_B44A:
1748  s->scan_lines_per_block = 32;
1749  break;
1750  default:
1751  avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
1752  return AVERROR_PATCHWELCOME;
1753  }
1754 
1755  /* Verify the xmin, xmax, ymin, ymax and xdelta before setting
1756  * the actual image size. */
1757  if (s->xmin > s->xmax ||
1758  s->ymin > s->ymax ||
1759  s->xdelta != s->xmax - s->xmin + 1 ||
1760  s->xmax >= s->w ||
1761  s->ymax >= s->h ||
1762  s->ydelta == 0xFFFFFFFF || s->xdelta == 0xFFFFFFFF
1763  ) {
1764  av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
1765  return AVERROR_INVALIDDATA;
1766  }
1767 
1768  if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
1769  return ret;
1770 
1771  s->desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1772  if (!s->desc)
1773  return AVERROR_INVALIDDATA;
1774  out_line_size = avctx->width * 2 * s->desc->nb_components;
1775 
1776  if (s->is_tile) {
1777  nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
1778  ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
1779  } else { /* scanline */
1780  nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
1781  s->scan_lines_per_block;
1782  }
1783 
1784  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1785  return ret;
1786 
1787  if (bytestream2_get_bytes_left(&s->gb)/8 < nb_blocks)
1788  return AVERROR_INVALIDDATA;
1789 
1790  // check offset table and recreate it if need
1791  if (!s->is_tile && bytestream2_peek_le64(&s->gb) == 0) {
1792  av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
1793 
1794  start_offset_table = bytestream2_tell(&s->gb);
1795  start_next_scanline = start_offset_table + nb_blocks * 8;
1796  bytestream2_init_writer(&offset_table_writer, &avpkt->data[start_offset_table], nb_blocks * 8);
1797 
1798  for (y = 0; y < nb_blocks; y++) {
1799  /* write offset of prev scanline in offset table */
1800  bytestream2_put_le64(&offset_table_writer, start_next_scanline);
1801 
1802  /* get len of next scanline */
1803  bytestream2_seek(&s->gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
1804  start_next_scanline += (bytestream2_get_le32(&s->gb) + 8);
1805  }
1806  bytestream2_seek(&s->gb, start_offset_table, SEEK_SET);
1807  }
1808 
1809  // save pointer we are going to use in decode_block
1810  s->buf = avpkt->data;
1811  s->buf_size = avpkt->size;
1812  ptr = picture->data[0];
1813 
1814  // Zero out the start if ymin is not 0
1815  for (y = 0; y < FFMIN(s->ymin, s->h); y++) {
1816  memset(ptr, 0, out_line_size);
1817  ptr += picture->linesize[0];
1818  }
1819 
1820  s->picture = picture;
1821 
1822  avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
1823 
1824  // Zero out the end if ymax+1 is not h
1825  if ((s->ymax+1) < avctx->height) {
1826  ptr = picture->data[0] + ((s->ymax+1) * picture->linesize[0]);
1827  for (y = s->ymax + 1; y < avctx->height; y++) {
1828  memset(ptr, 0, out_line_size);
1829  ptr += picture->linesize[0];
1830  }
1831  }
1832 
1833  picture->pict_type = AV_PICTURE_TYPE_I;
1834  *got_frame = 1;
1835 
1836  return avpkt->size;
1837 }
1838 
1840 {
1841  EXRContext *s = avctx->priv_data;
1842  uint32_t i;
1843  union av_intfloat32 t;
1844  float one_gamma = 1.0f / s->gamma;
1845  avpriv_trc_function trc_func = NULL;
1846 
1847  s->avctx = avctx;
1848 
1849  ff_exrdsp_init(&s->dsp);
1850 
1851 #if HAVE_BIGENDIAN
1852  ff_bswapdsp_init(&s->bbdsp);
1853 #endif
1854 
1855  trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
1856  if (trc_func) {
1857  for (i = 0; i < 65536; ++i) {
1858  t = exr_half2float(i);
1859  t.f = trc_func(t.f);
1860  s->gamma_table[i] = exr_flt2uint(t.i);
1861  }
1862  } else {
1863  if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
1864  for (i = 0; i < 65536; ++i)
1865  s->gamma_table[i] = exr_halflt2uint(i);
1866  } else {
1867  for (i = 0; i < 65536; ++i) {
1868  t = exr_half2float(i);
1869  /* If negative value we reuse half value */
1870  if (t.f <= 0.0f) {
1871  s->gamma_table[i] = exr_halflt2uint(i);
1872  } else {
1873  t.f = powf(t.f, one_gamma);
1874  s->gamma_table[i] = exr_flt2uint(t.i);
1875  }
1876  }
1877  }
1878  }
1879 
1880  // allocate thread data, used for non EXR_RAW compression types
1881  s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
1882  if (!s->thread_data)
1883  return AVERROR_INVALIDDATA;
1884 
1885  return 0;
1886 }
1887 
1888 #if HAVE_THREADS
1889 static int decode_init_thread_copy(AVCodecContext *avctx)
1890 { EXRContext *s = avctx->priv_data;
1891 
1892  // allocate thread data, used for non EXR_RAW compression types
1893  s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
1894  if (!s->thread_data)
1895  return AVERROR_INVALIDDATA;
1896 
1897  return 0;
1898 }
1899 #endif
1900 
1902 {
1903  EXRContext *s = avctx->priv_data;
1904  int i;
1905  for (i = 0; i < avctx->thread_count; i++) {
1906  EXRThreadData *td = &s->thread_data[i];
1907  av_freep(&td->uncompressed_data);
1908  av_freep(&td->tmp);
1909  av_freep(&td->bitmap);
1910  av_freep(&td->lut);
1911  }
1912 
1913  av_freep(&s->thread_data);
1914  av_freep(&s->channels);
1915 
1916  return 0;
1917 }
1918 
1919 #define OFFSET(x) offsetof(EXRContext, x)
1920 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1921 static const AVOption options[] = {
1922  { "layer", "Set the decoding layer", OFFSET(layer),
1923  AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
1924  { "gamma", "Set the float gamma value when decoding", OFFSET(gamma),
1925  AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD },
1926 
1927  // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
1928  { "apply_trc", "color transfer characteristics to apply to EXR linear input", OFFSET(apply_trc_type),
1929  AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD, "apply_trc_type"},
1930  { "bt709", "BT.709", 0,
1931  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1932  { "gamma", "gamma", 0,
1933  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1934  { "gamma22", "BT.470 M", 0,
1935  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1936  { "gamma28", "BT.470 BG", 0,
1937  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1938  { "smpte170m", "SMPTE 170 M", 0,
1939  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1940  { "smpte240m", "SMPTE 240 M", 0,
1941  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1942  { "linear", "Linear", 0,
1943  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1944  { "log", "Log", 0,
1945  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1946  { "log_sqrt", "Log square root", 0,
1947  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1948  { "iec61966_2_4", "IEC 61966-2-4", 0,
1949  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1950  { "bt1361", "BT.1361", 0,
1951  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1952  { "iec61966_2_1", "IEC 61966-2-1", 0,
1953  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1954  { "bt2020_10bit", "BT.2020 - 10 bit", 0,
1955  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1956  { "bt2020_12bit", "BT.2020 - 12 bit", 0,
1957  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1958  { "smpte2084", "SMPTE ST 2084", 0,
1959  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1960  { "smpte428_1", "SMPTE ST 428-1", 0,
1961  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
1962 
1963  { NULL },
1964 };
1965 
1966 static const AVClass exr_class = {
1967  .class_name = "EXR",
1968  .item_name = av_default_item_name,
1969  .option = options,
1970  .version = LIBAVUTIL_VERSION_INT,
1971 };
1972 
1974  .name = "exr",
1975  .long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
1976  .type = AVMEDIA_TYPE_VIDEO,
1977  .id = AV_CODEC_ID_EXR,
1978  .priv_data_size = sizeof(EXRContext),
1979  .init = decode_init,
1980  .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1981  .close = decode_end,
1982  .decode = decode_frame,
1983  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
1985  .priv_class = &exr_class,
1986 };
HufDec::len
int len
Definition: exr.c:366
EXRContext::ymin
uint32_t ymin
Definition: exr.c:138
AVCodec
AVCodec.
Definition: avcodec.h:3481
bswapdsp.h
EXRTileAttribute::level_round
enum ExrTileLevelRound level_round
Definition: exr.c:103
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
EXRThreadData
Definition: exr.c:106
td
#define td
Definition: regdef.h:70
EXR_TILE_ROUND_DOWN
@ EXR_TILE_ROUND_DOWN
Definition: exr.c:90
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
EXRContext::ymax
uint32_t ymax
Definition: exr.c:138
rle_uncompress
static int rle_uncompress(EXRContext *ctx, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:285
EXRThreadData::uncompressed_size
int uncompressed_size
Definition: exr.c:108
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
EXR_DWB
@ EXR_DWB
Definition: exr.c:70
EXRTileAttribute
Definition: exr.c:99
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:467
out
FILE * out
Definition: movenc.c:54
EXRThreadData::lut
uint16_t * lut
Definition: exr.c:114
GetByteContext
Definition: bytestream.h:33
EXR_TILE_LEVEL_ONE
@ EXR_TILE_LEVEL_ONE
Definition: exr.c:82
n
int n
Definition: avisynth_c.h:760
EXRThreadData::uncompressed_data
uint8_t * uncompressed_data
Definition: exr.c:107
VD
#define VD
Definition: exr.c:1920
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:87
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
exr_flt2uint
static uint16_t exr_flt2uint(int32_t v)
Convert from 32-bit float as uint32_t to uint16_t.
Definition: exr.c:235
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:476
FLOAT_MAX_BIASED_EXP
#define FLOAT_MAX_BIASED_EXP
Definition: exr.c:173
decode_header
static int decode_header(EXRContext *s, AVFrame *frame)
Definition: exr.c:1310
EXRContext::layer
const char * layer
Definition: exr.c:158
pxr24_uncompress
static int pxr24_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:816
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
EXRContext::xmax
uint32_t xmax
Definition: exr.c:137
count
void INT64 INT64 count
Definition: avisynth_c.h:767
ff_exr_decoder
AVCodec ff_exr_decoder
Definition: exr.c:1973
im
float im
Definition: fft.c:82
bytestream2_seek
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
EXRContext::picture
AVFrame * picture
Definition: exr.c:123
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:489
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2186
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
av_intfloat32::i
uint32_t i
Definition: intfloat.h:28
ExrPixelType
ExrPixelType
Definition: exr.c:74
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:470
data
const char data[16]
Definition: mxf.c:91
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: exr.c:1839
HUF_DECMASK
#define HUF_DECMASK
Definition: exr.c:363
reverse_lut
static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
Definition: exr.c:335
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: exr.c:1689
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
HUF_DECBITS
#define HUF_DECBITS
Definition: exr.c:359
float.h
AVCOL_TRC_BT2020_12
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:483
EXRThreadData::ysize
int ysize
Definition: exr.c:116
AVDictionary
Definition: dict.c:30
options
static const AVOption options[]
Definition: exr.c:1921
EXRThreadData::tmp_size
int tmp_size
Definition: exr.c:111
intfloat.h
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
EXRContext::channel_offsets
int channel_offsets[4]
Definition: exr.c:133
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
EXR_B44A
@ EXR_B44A
Definition: exr.c:68
EXR_HALF
@ EXR_HALF
Definition: exr.c:76
huf_uncompress
static int huf_uncompress(GetByteContext *gb, uint16_t *dst, int dst_size)
Definition: exr.c:574
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
EXRContext::tile_attr
EXRTileAttribute tile_attr
Definition: exr.c:143
apply_lut
static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
Definition: exr.c:350
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:481
fail
#define fail()
Definition: checkasm.h:120
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:2824
EXR_TILE_LEVEL_RIPMAP
@ EXR_TILE_LEVEL_RIPMAP
Definition: exr.c:84
EXR_TILE_ROUND_UNKNOWN
@ EXR_TILE_ROUND_UNKNOWN
Definition: exr.c:91
GetBitContext
Definition: get_bits.h:61
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:473
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
AVCOL_TRC_LOG_SQRT
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
Definition: pixfmt.h:478
FFMIN3
#define FFMIN3(a, b, c)
Definition: common.h:97
EXRContext::avctx
AVCodecContext * avctx
Definition: exr.c:124
src
#define src
Definition: vp8dsp.c:254
AVCOL_TRC_SMPTEST428_1
@ AVCOL_TRC_SMPTEST428_1
Definition: pixfmt.h:487
EXR_DWA
@ EXR_DWA
Definition: exr.c:69
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:472
HufDec
Definition: exr.c:365
HALF_FLOAT_MAX_BIASED_EXP
#define HALF_FLOAT_MAX_BIASED_EXP
Definition: exr.c:175
EXRContext::scan_lines_per_block
int scan_lines_per_block
Definition: exr.c:141
EXRContext::h
int h
Definition: exr.c:136
color_utils.h
ExrDSPContext
Definition: exrdsp.h:25
EXRThreadData::channel_line_size
int channel_line_size
Definition: exr.c:118
USHORT_RANGE
#define USHORT_RANGE
Definition: exr.c:332
avassert.h
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: exr.c:1901
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
HufDec::lit
int lit
Definition: exr.c:367
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
zip_uncompress
static int zip_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:268
EXR_FLOAT
@ EXR_FLOAT
Definition: exr.c:77
BITMAP_SIZE
#define BITMAP_SIZE
Definition: exr.c:333
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:143
EXRContext::compression
enum ExrCompr compression
Definition: exr.c:131
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:1281
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:480
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
EXRContext::current_channel_offset
int current_channel_offset
Definition: exr.c:154
decode_block
static int decode_block(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
Definition: exr.c:1028
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
EXRChannel::pixel_type
enum ExrPixelType pixel_type
Definition: exr.c:96
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
EXRContext::gamma_table
uint16_t gamma_table[65536]
Definition: exr.c:162
SHORTEST_LONG_RUN
#define SHORTEST_LONG_RUN
Definition: exr.c:396
key
const char * key
Definition: hwcontext_opencl.c:168
f
#define f(width, name)
Definition: cbs_vp9.c:255
version
int version
Definition: avisynth_c.h:858
int32_t
int32_t
Definition: audio_convert.c:194
EXR_ZIP1
@ EXR_ZIP1
Definition: exr.c:63
if
if(ret)
Definition: filter_design.txt:179
EXRContext::desc
const AVPixFmtDescriptor * desc
Definition: exr.c:134
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
EXRContext::is_luma
int is_luma
Definition: exr.c:146
AV_CODEC_ID_EXR
@ AV_CODEC_ID_EXR
Definition: avcodec.h:398
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:377
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:62
LONG_ZEROCODE_RUN
#define LONG_ZEROCODE_RUN
Definition: exr.c:395
pixel
uint8_t pixel
Definition: tiny_ssim.c:42
SHORT_ZEROCODE_RUN
#define SHORT_ZEROCODE_RUN
Definition: exr.c:394
AVCOL_TRC_IEC61966_2_4
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:479
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:95
avpriv_get_trc_function_from_trc
avpriv_trc_function avpriv_get_trc_function_from_trc(enum AVColorTransferCharacteristic trc)
Determine the function needed to apply the given AVColorTransferCharacteristic to linear input.
Definition: color_utils.c:170
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
huf_decode
static int huf_decode(const uint64_t *hcode, const HufDec *hdecod, GetByteContext *gb, int nbits, int rlc, int no, uint16_t *out)
Definition: exr.c:505
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:263
ff_exrdsp_init
av_cold void ff_exrdsp_init(ExrDSPContext *c)
Definition: exrdsp.c:49
get_char
#define get_char(c, lc, gb)
Definition: exr.c:476
EXRContext::w
int w
Definition: exr.c:136
AVCOL_TRC_BT2020_10
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
Definition: pixfmt.h:482
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:227
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:964
av_intfloat32
Definition: intfloat.h:27
unpack_14
static void unpack_14(const uint8_t b[14], uint16_t s[16])
Definition: exr.c:900
EXR_PIZ
@ EXR_PIZ
Definition: exr.c:65
A_OFFSET
#define A_OFFSET
Definition: exr.c:639
exp
int8_t exp
Definition: eval.c:72
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_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
exr_half2float
static union av_intfloat32 exr_half2float(uint16_t hf)
Convert a half float as a uint16_t into a full float.
Definition: exr.c:184
HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP
#define HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP
Definition: exr.c:166
EXRThreadData::bitmap
uint8_t * bitmap
Definition: exr.c:113
PutByteContext
Definition: bytestream.h:37
EXRContext::pixel_type
enum ExrPixelType pixel_type
Definition: exr.c:132
EXRTileAttribute::level_mode
enum ExrTileLevelMode level_mode
Definition: exr.c:102
EXRChannel::xsub
int xsub
Definition: exr.c:95
EXRContext::thread_data
EXRThreadData * thread_data
Definition: exr.c:156
EXR_RAW
@ EXR_RAW
Definition: exr.c:61
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
wdec14
static void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:625
AVPacket::size
int size
Definition: avcodec.h:1478
wav_decode
static void wav_decode(uint16_t *in, int nx, int ox, int ny, int oy, uint16_t mx)
Definition: exr.c:652
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
powf
#define powf(x, y)
Definition: libm.h:50
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:475
MOD_MASK
#define MOD_MASK
Definition: exr.c:640
AVCOL_TRC_SMPTEST2084
@ AVCOL_TRC_SMPTEST2084
Definition: pixfmt.h:485
AVCOL_TRC_LOG
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
Definition: pixfmt.h:477
EXRTileAttribute::xSize
int32_t xSize
Definition: exr.c:100
init_thread_copy
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 add an init_thread_copy() which re-allocates them for other threads. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:373
EXRThreadData::tmp
uint8_t * tmp
Definition: exr.c:110
EXRContext::is_tile
int is_tile
Definition: exr.c:144
EXR_TILE_LEVEL_MIPMAP
@ EXR_TILE_LEVEL_MIPMAP
Definition: exr.c:83
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.
huf_build_dec_table
static int huf_build_dec_table(const uint64_t *hcode, int im, int iM, HufDec *hdecod)
Definition: exr.c:439
HufDec::p
int * p
Definition: exr.c:368
EXRContext::gamma
float gamma
Definition: exr.c:161
EXRContext::gb
GetByteContext gb
Definition: exr.c:148
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
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
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1041
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:203
EXR_ZIP16
@ EXR_ZIP16
Definition: exr.c:64
EXRContext::apply_trc_type
enum AVColorTransferCharacteristic apply_trc_type
Definition: exr.c:160
unpack_3
static void unpack_3(const uint8_t b[3], uint16_t s[16])
Definition: exr.c:935
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:469
HUF_DECSIZE
#define HUF_DECSIZE
Definition: exr.c:362
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:226
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
ExrTileLevelRound
ExrTileLevelRound
Definition: exr.c:88
OFFSET
#define OFFSET(x)
Definition: exr.c:1919
get_code
#define get_code(po, rlc, c, lc, gb, out, oe, outb)
Definition: exr.c:482
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:372
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
HUF_ENCSIZE
#define HUF_ENCSIZE
Definition: exr.c:361
common.h
EXRContext::buf
const uint8_t * buf
Definition: exr.c:149
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
EXRThreadData::xsize
int xsize
Definition: exr.c:116
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:70
EXR_PXR24
@ EXR_PXR24
Definition: exr.c:66
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
EXR_UINT
@ EXR_UINT
Definition: exr.c:75
exr_halflt2uint
static uint16_t exr_halflt2uint(uint16_t v)
Convert from 16-bit float as uint16_t to uint16_t.
Definition: exr.c:255
AVCodecContext::height
int height
Definition: avcodec.h:1738
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
EXR_B44
@ EXR_B44
Definition: exr.c:67
avcodec.h
EXRContext::nb_channels
int nb_channels
Definition: exr.c:153
ret
ret
Definition: filter_design.txt:187
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:72
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
huf_unpack_enc_table
static int huf_unpack_enc_table(GetByteContext *gb, int32_t im, int32_t iM, uint64_t *hcode)
Definition: exr.c:399
avpriv_trc_function
double(* avpriv_trc_function)(double)
Definition: color_utils.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
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:119
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
ThreadFrame
Definition: thread.h:34
EXRContext::channels
EXRChannel * channels
Definition: exr.c:152
EXR_UNKNOWN
@ EXR_UNKNOWN
Definition: exr.c:78
EXRContext::ydelta
uint32_t ydelta
Definition: exr.c:139
wdec16
static void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:642
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
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:474
huf_canonical_code_table
static void huf_canonical_code_table(uint64_t *hcode)
Definition: exr.c:371
EXR_TILE_LEVEL_UNKNOWN
@ EXR_TILE_LEVEL_UNKNOWN
Definition: exr.c:85
av_intfloat32::f
float f
Definition: intfloat.h:29
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:104
EXRContext::xmin
uint32_t xmin
Definition: exr.c:137
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
ExrCompr
ExrCompr
Definition: exr.c:60
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:70
EXRContext::buf_size
int buf_size
Definition: exr.c:150
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1738
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:133
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
ExrTileLevelMode
ExrTileLevelMode
Definition: exr.c:81
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
EXRTileAttribute::ySize
int32_t ySize
Definition: exr.c:101
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
exr_class
static const AVClass exr_class
Definition: exr.c:1966
BswapDSPContext
Definition: bswapdsp.h:24
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:227
EXRContext::xdelta
uint32_t xdelta
Definition: exr.c:139
int
int
Definition: ffmpeg_filter.c:191
b44_uncompress
static int b44_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:951
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
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:2884
piz_uncompress
static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize, int dsize, EXRThreadData *td)
Definition: exr.c:731
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
EXRContext::dsp
ExrDSPContext dsp
Definition: exr.c:125
EXR_UNKN
@ EXR_UNKN
Definition: exr.c:71
EXRContext
Definition: exr.c:121
EXRChannel
Definition: exr.c:94