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