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