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