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