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