FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 
1000  if (compressed_size <= 88)
1001  return AVERROR_INVALIDDATA;
1002 
1003  version = AV_RL64(src + 0);
1004  if (version != 2)
1005  return AVERROR_INVALIDDATA;
1006 
1007  lo_usize = AV_RL64(src + 8);
1008  lo_size = AV_RL64(src + 16);
1009  ac_size = AV_RL64(src + 24);
1010  dc_size = AV_RL64(src + 32);
1011  rle_csize = AV_RL64(src + 40);
1012  rle_usize = AV_RL64(src + 48);
1013  rle_raw_size = AV_RL64(src + 56);
1014  ac_count = AV_RL64(src + 64);
1015  dc_count = AV_RL64(src + 72);
1016  ac_compression = AV_RL64(src + 80);
1017 
1018  if ( compressed_size < (uint64_t)(lo_size | ac_size | dc_size | rle_csize) || compressed_size < 88LL + lo_size + ac_size + dc_size + rle_csize
1019  || ac_count > (uint64_t)INT_MAX/2
1020  )
1021  return AVERROR_INVALIDDATA;
1022 
1023  bytestream2_init(&gb, src + 88, compressed_size - 88);
1024  skip = bytestream2_get_le16(&gb);
1025  if (skip < 2)
1026  return AVERROR_INVALIDDATA;
1027 
1028  bytestream2_skip(&gb, skip - 2);
1029 
1030  if (lo_size > 0) {
1031  if (lo_usize > uncompressed_size)
1032  return AVERROR_INVALIDDATA;
1033  bytestream2_skip(&gb, lo_size);
1034  }
1035 
1036  if (ac_size > 0) {
1037  unsigned long dest_len;
1038  GetByteContext agb = gb;
1039 
1040  if (ac_count > 3LL * td->xsize * s->scan_lines_per_block)
1041  return AVERROR_INVALIDDATA;
1042 
1043  dest_len = ac_count * 2LL;
1044 
1045  av_fast_padded_malloc(&td->ac_data, &td->ac_size, dest_len);
1046  if (!td->ac_data)
1047  return AVERROR(ENOMEM);
1048 
1049  switch (ac_compression) {
1050  case 0:
1051  ret = huf_uncompress(s, td, &agb, (int16_t *)td->ac_data, ac_count);
1052  if (ret < 0)
1053  return ret;
1054  break;
1055  case 1:
1056  if (uncompress(td->ac_data, &dest_len, agb.buffer, ac_size) != Z_OK ||
1057  dest_len != ac_count * 2LL)
1058  return AVERROR_INVALIDDATA;
1059  break;
1060  default:
1061  return AVERROR_INVALIDDATA;
1062  }
1063 
1064  bytestream2_skip(&gb, ac_size);
1065  }
1066 
1067  {
1068  unsigned long dest_len;
1069  GetByteContext agb = gb;
1070 
1071  if (dc_count != dc_w * dc_h * 3)
1072  return AVERROR_INVALIDDATA;
1073 
1074  dest_len = dc_count * 2LL;
1075 
1076  av_fast_padded_malloc(&td->dc_data, &td->dc_size, FFALIGN(dest_len, 64) * 2);
1077  if (!td->dc_data)
1078  return AVERROR(ENOMEM);
1079 
1080  if (uncompress(td->dc_data + FFALIGN(dest_len, 64), &dest_len, agb.buffer, dc_size) != Z_OK ||
1081  (dest_len != dc_count * 2LL))
1082  return AVERROR_INVALIDDATA;
1083 
1084  s->dsp.predictor(td->dc_data + FFALIGN(dest_len, 64), dest_len);
1085  s->dsp.reorder_pixels(td->dc_data, td->dc_data + FFALIGN(dest_len, 64), dest_len);
1086 
1087  bytestream2_skip(&gb, dc_size);
1088  }
1089 
1090  if (rle_raw_size > 0 && rle_csize > 0 && rle_usize > 0) {
1091  unsigned long dest_len = rle_usize;
1092 
1093  av_fast_padded_malloc(&td->rle_data, &td->rle_size, rle_usize);
1094  if (!td->rle_data)
1095  return AVERROR(ENOMEM);
1096 
1097  av_fast_padded_malloc(&td->rle_raw_data, &td->rle_raw_size, rle_raw_size);
1098  if (!td->rle_raw_data)
1099  return AVERROR(ENOMEM);
1100 
1101  if (uncompress(td->rle_data, &dest_len, gb.buffer, rle_csize) != Z_OK ||
1102  (dest_len != rle_usize))
1103  return AVERROR_INVALIDDATA;
1104 
1105  ret = rle(td->rle_raw_data, td->rle_data, rle_usize, rle_raw_size);
1106  if (ret < 0)
1107  return ret;
1108  bytestream2_skip(&gb, rle_csize);
1109  }
1110 
1111  bytestream2_init(&agb, td->ac_data, ac_count * 2);
1112 
1113  for (int y = 0; y < td->ysize; y += 8) {
1114  for (int x = 0; x < td->xsize; x += 8) {
1115  memset(td->block, 0, sizeof(td->block));
1116 
1117  for (int j = 0; j < 3; j++) {
1118  float *block = td->block[j];
1119  const int idx = (x >> 3) + (y >> 3) * dc_w + dc_w * dc_h * j;
1120  uint16_t *dc = (uint16_t *)td->dc_data;
1121  union av_intfloat32 dc_val;
1122 
1123  dc_val.i = half2float(dc[idx], &s->h2f_tables);
1124 
1125  block[0] = dc_val.f;
1126  ac_uncompress(s, &agb, block);
1127  dct_inverse(block);
1128  }
1129 
1130  {
1131  const int o = s->nb_channels == 4;
1132  float *bo = ((float *)td->uncompressed_data) +
1133  y * td->xsize * s->nb_channels + td->xsize * (o + 0) + x;
1134  float *go = ((float *)td->uncompressed_data) +
1135  y * td->xsize * s->nb_channels + td->xsize * (o + 1) + x;
1136  float *ro = ((float *)td->uncompressed_data) +
1137  y * td->xsize * s->nb_channels + td->xsize * (o + 2) + x;
1138  float *yb = td->block[0];
1139  float *ub = td->block[1];
1140  float *vb = td->block[2];
1141 
1142  for (int yy = 0; yy < 8; yy++) {
1143  for (int xx = 0; xx < 8; xx++) {
1144  const int idx = xx + yy * 8;
1145 
1146  convert(yb[idx], ub[idx], vb[idx], &bo[xx], &go[xx], &ro[xx]);
1147 
1148  bo[xx] = to_linear(bo[xx], 1.f);
1149  go[xx] = to_linear(go[xx], 1.f);
1150  ro[xx] = to_linear(ro[xx], 1.f);
1151  }
1152 
1153  bo += td->xsize * s->nb_channels;
1154  go += td->xsize * s->nb_channels;
1155  ro += td->xsize * s->nb_channels;
1156  }
1157  }
1158  }
1159  }
1160 
1161  if (s->nb_channels < 4)
1162  return 0;
1163 
1164  for (int y = 0; y < td->ysize && td->rle_raw_data; y++) {
1165  uint32_t *ao = ((uint32_t *)td->uncompressed_data) + y * td->xsize * s->nb_channels;
1166  uint8_t *ai0 = td->rle_raw_data + y * td->xsize;
1167  uint8_t *ai1 = td->rle_raw_data + y * td->xsize + rle_raw_size / 2;
1168 
1169  for (int x = 0; x < td->xsize; x++) {
1170  uint16_t ha = ai0[x] | (ai1[x] << 8);
1171 
1172  ao[x] = half2float(ha, &s->h2f_tables);
1173  }
1174  }
1175 
1176  return 0;
1177 }
1178 
1179 static int decode_block(AVCodecContext *avctx, void *tdata,
1180  int jobnr, int threadnr)
1181 {
1182  const EXRContext *s = avctx->priv_data;
1183  AVFrame *const p = s->picture;
1184  EXRThreadData *td = &s->thread_data[threadnr];
1185  const uint8_t *channel_buffer[4] = { 0 };
1186  const uint8_t *buf = s->buf;
1187  uint64_t line_offset, uncompressed_size;
1188  uint8_t *ptr;
1189  uint32_t data_size;
1190  int line, col = 0;
1191  uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
1192  const uint8_t *src;
1193  int step = s->desc->comp[0].step;
1194  int bxmin = 0, axmax = 0, window_xoffset = 0;
1195  int window_xmin, window_xmax, window_ymin, window_ymax;
1196  int data_xoffset, data_yoffset, data_window_offset, xsize, ysize;
1197  int i, x, buf_size = s->buf_size;
1198  int c, rgb_channel_count;
1199 #if FF_API_EXR_GAMMA
1200  float one_gamma = 1.0f / s->gamma;
1201  av_csp_trc_function trc_func = av_csp_trc_func_from_id(s->apply_trc_type);
1202 #endif
1203  int ret;
1204 
1205  line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
1206 
1207  if (s->is_tile) {
1208  if (buf_size < 20 || line_offset > buf_size - 20)
1209  return AVERROR_INVALIDDATA;
1210 
1211  src = buf + line_offset + 20;
1212  if (s->is_multipart)
1213  src += 4;
1214 
1215  tile_x = AV_RL32(src - 20);
1216  tile_y = AV_RL32(src - 16);
1217  tile_level_x = AV_RL32(src - 12);
1218  tile_level_y = AV_RL32(src - 8);
1219 
1220  data_size = AV_RL32(src - 4);
1221  if (data_size <= 0 || data_size > buf_size - line_offset - 20)
1222  return AVERROR_INVALIDDATA;
1223 
1224  if (tile_level_x || tile_level_y) { /* tile level, is not the full res level */
1225  avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
1226  return AVERROR_PATCHWELCOME;
1227  }
1228 
1229  if (tile_x && s->tile_attr.xSize + (int64_t)FFMAX(s->xmin, 0) >= INT_MAX / tile_x )
1230  return AVERROR_INVALIDDATA;
1231  if (tile_y && s->tile_attr.ySize + (int64_t)FFMAX(s->ymin, 0) >= INT_MAX / tile_y )
1232  return AVERROR_INVALIDDATA;
1233 
1234  line = s->ymin + s->tile_attr.ySize * tile_y;
1235  col = s->tile_attr.xSize * tile_x;
1236 
1237  if (line < s->ymin || line > s->ymax ||
1238  s->xmin + col < s->xmin || s->xmin + col > s->xmax)
1239  return AVERROR_INVALIDDATA;
1240 
1241  td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tile_y * s->tile_attr.ySize);
1242  td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tile_x * s->tile_attr.xSize);
1243 
1244  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1245  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1246  return AVERROR_INVALIDDATA;
1247 
1248  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1249  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1250  } else {
1251  if (buf_size < 8 || line_offset > buf_size - 8)
1252  return AVERROR_INVALIDDATA;
1253 
1254  src = buf + line_offset + 8;
1255  if (s->is_multipart)
1256  src += 4;
1257  line = AV_RL32(src - 8);
1258 
1259  if (line < s->ymin || line > s->ymax)
1260  return AVERROR_INVALIDDATA;
1261 
1262  data_size = AV_RL32(src - 4);
1263  if (data_size <= 0 || data_size > buf_size - line_offset - 8)
1264  return AVERROR_INVALIDDATA;
1265 
1266  td->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1); /* s->ydelta - line ?? */
1267  td->xsize = s->xdelta;
1268 
1269  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1270  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1271  return AVERROR_INVALIDDATA;
1272 
1273  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1274  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1275 
1276  if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
1277  line_offset > buf_size - uncompressed_size)) ||
1278  (s->compression != EXR_RAW && (data_size > uncompressed_size ||
1279  line_offset > buf_size - data_size))) {
1280  return AVERROR_INVALIDDATA;
1281  }
1282  }
1283 
1284  window_xmin = FFMIN(avctx->width, FFMAX(0, s->xmin + col));
1285  window_xmax = FFMIN(avctx->width, FFMAX(0, s->xmin + col + td->xsize));
1286  window_ymin = FFMIN(avctx->height, FFMAX(0, line ));
1287  window_ymax = FFMIN(avctx->height, FFMAX(0, line + td->ysize));
1288  xsize = window_xmax - window_xmin;
1289  ysize = window_ymax - window_ymin;
1290 
1291  /* tile or scanline not visible skip decoding */
1292  if (xsize <= 0 || ysize <= 0)
1293  return 0;
1294 
1295  /* is the first tile or is a scanline */
1296  if(col == 0) {
1297  window_xmin = 0;
1298  /* pixels to add at the left of the display window */
1299  window_xoffset = FFMAX(0, s->xmin);
1300  /* bytes to add at the left of the display window */
1301  bxmin = window_xoffset * step;
1302  }
1303 
1304  /* is the last tile or is a scanline */
1305  if(col + td->xsize == s->xdelta) {
1306  window_xmax = avctx->width;
1307  /* bytes to add at the right of the display window */
1308  axmax = FFMAX(0, (avctx->width - (s->xmax + 1))) * step;
1309  }
1310 
1311  if (avctx->max_pixels && uncompressed_size > avctx->max_pixels * 16LL)
1312  return AVERROR_INVALIDDATA;
1313 
1314  if (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
1315  av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
1316  if (!td->tmp)
1317  return AVERROR(ENOMEM);
1318  }
1319 
1320  if (data_size < uncompressed_size) {
1322  &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
1323 
1324  if (!td->uncompressed_data)
1325  return AVERROR(ENOMEM);
1326 
1328  switch (s->compression) {
1329  case EXR_ZIP1:
1330  case EXR_ZIP16:
1331  ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
1332  break;
1333  case EXR_PIZ:
1334  ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
1335  break;
1336  case EXR_PXR24:
1337  ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
1338  break;
1339  case EXR_RLE:
1340  ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
1341  break;
1342  case EXR_B44:
1343  case EXR_B44A:
1344  ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
1345  break;
1346  case EXR_DWAA:
1347  case EXR_DWAB:
1348  ret = dwa_uncompress(s, src, data_size, uncompressed_size, td);
1349  break;
1350  }
1351  if (ret < 0) {
1352  av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
1353  return ret;
1354  }
1355  src = td->uncompressed_data;
1356  }
1357 
1358  /* offsets to crop data outside display window */
1359  data_xoffset = FFABS(FFMIN(0, s->xmin + col)) * (s->pixel_type == EXR_HALF ? 2 : 4);
1360  data_yoffset = FFABS(FFMIN(0, line));
1361  data_window_offset = (data_yoffset * td->channel_line_size) + data_xoffset;
1362 
1363  if (s->channel_offsets[3] >= 0)
1364  channel_buffer[3] = src + (td->xsize * s->channel_offsets[3]) + data_window_offset;
1365  if (!s->is_luma) {
1366  channel_buffer[0] = src + (td->xsize * s->channel_offsets[0]) + data_window_offset;
1367  channel_buffer[1] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1368  channel_buffer[2] = src + (td->xsize * s->channel_offsets[2]) + data_window_offset;
1369  rgb_channel_count = 3;
1370  } else { /* put y data in the first channel_buffer and if needed, alpha in the second */
1371  channel_buffer[0] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1372  if (!(s->desc->flags & AV_PIX_FMT_FLAG_PLANAR))
1373  channel_buffer[1] = channel_buffer[3];
1374  rgb_channel_count = 1;
1375  }
1376 
1377  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
1378  for (c = 0; c < s->desc->nb_components; c++) {
1379  int plane = s->desc->comp[c].plane;
1380  ptr = p->data[plane] + window_ymin * p->linesize[plane] + (window_xmin * step) + s->desc->comp[c].offset;
1381 
1382  for (i = 0; i < ysize; i++, ptr += p->linesize[plane]) {
1383  const uint8_t *src = channel_buffer[c];
1384  uint8_t *ptr_x = ptr + window_xoffset * step;
1385 
1386  // Zero out the start if xmin is not 0
1387  if (s->desc->flags & AV_PIX_FMT_FLAG_PLANAR || !c)
1388  memset(ptr, 0, bxmin);
1389 
1390  if (s->pixel_type == EXR_FLOAT ||
1391  s->compression == EXR_DWAA ||
1392  s->compression == EXR_DWAB) {
1393  // 32-bit
1394 #if FF_API_EXR_GAMMA
1395  if (trc_func && (!c || (c < 3 && s->desc->flags & AV_PIX_FMT_FLAG_PLANAR))) {
1396  for (int x = 0; x < xsize; x++, ptr_x += step) {
1397  float f = av_int2float(bytestream_get_le32(&src));
1398  AV_WN32A(ptr_x, av_float2int(trc_func(f)));
1399  }
1400  } else if (one_gamma != 1.f) {
1401  for (int x = 0; x < xsize; x++, ptr_x += step) {
1402  float f = av_int2float(bytestream_get_le32(&src));
1403  if (f > 0.0f && c < 3) /* avoid negative values */
1404  f = powf(f, one_gamma);
1405  AV_WN32A(ptr_x, av_float2int(f));
1406  }
1407  } else
1408 #endif
1409  for (int x = 0; x < xsize; x++, ptr_x += step)
1410  AV_WN32A(ptr_x, bytestream_get_le32(&src));
1411  } else if (s->pixel_type == EXR_HALF) {
1412  // 16-bit
1413 #if FF_API_EXR_GAMMA
1414  if (one_gamma != 1.f || (trc_func && (!c || (c < 3 && s->desc->flags & AV_PIX_FMT_FLAG_PLANAR)))) {
1415  for (int x = 0; x < xsize; x++, ptr_x += step)
1416  AV_WN16A(ptr_x, s->gamma_table[bytestream_get_le16(&src)]);
1417  } else
1418 #endif
1419  for (int x = 0; x < xsize; x++, ptr_x += step)
1420  AV_WN16A(ptr_x, bytestream_get_le16(&src));
1421  }
1422 
1423  // Zero out the end if xmax+1 is not w
1424  memset(ptr_x, 0, axmax);
1425  channel_buffer[c] += td->channel_line_size;
1426  }
1427  }
1428  } else {
1429 
1430  av_assert1(s->pixel_type == EXR_UINT);
1431  ptr = p->data[0] + window_ymin * p->linesize[0] + (window_xmin * s->desc->nb_components * 2);
1432 
1433  for (i = 0; i < ysize; i++, ptr += p->linesize[0]) {
1434 
1435  const uint8_t * a;
1436  const uint8_t *rgb[3];
1437  uint16_t *ptr_x;
1438 
1439  for (c = 0; c < rgb_channel_count; c++) {
1440  rgb[c] = channel_buffer[c];
1441  }
1442 
1443  if (channel_buffer[3])
1444  a = channel_buffer[3];
1445 
1446  ptr_x = (uint16_t *) ptr;
1447 
1448  // Zero out the start if xmin is not 0
1449  memset(ptr_x, 0, bxmin);
1450  ptr_x += window_xoffset * s->desc->nb_components;
1451 
1452  for (x = 0; x < xsize; x++) {
1453  for (c = 0; c < rgb_channel_count; c++) {
1454  *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
1455  }
1456 
1457  if (channel_buffer[3])
1458  *ptr_x++ = bytestream_get_le32(&a) >> 16;
1459  }
1460 
1461  // Zero out the end if xmax+1 is not w
1462  memset(ptr_x, 0, axmax);
1463 
1464  channel_buffer[0] += td->channel_line_size;
1465  channel_buffer[1] += td->channel_line_size;
1466  channel_buffer[2] += td->channel_line_size;
1467  if (channel_buffer[3])
1468  channel_buffer[3] += td->channel_line_size;
1469  }
1470  }
1471 
1472  return 0;
1473 }
1474 
1476 {
1477  GetByteContext *gb = &s->gb;
1478 
1479  while (bytestream2_get_bytes_left(gb) > 0) {
1480  if (!bytestream2_peek_byte(gb))
1481  break;
1482 
1483  // Process unknown variables
1484  for (int i = 0; i < 2; i++) // value_name and value_type
1485  while (bytestream2_get_byte(gb) != 0);
1486 
1487  // Skip variable length
1488  bytestream2_skip(gb, bytestream2_get_le32(gb));
1489  }
1490 }
1491 
1492 /**
1493  * Check if the variable name corresponds to its data type.
1494  *
1495  * @param s the EXRContext
1496  * @param value_name name of the variable to check
1497  * @param value_type type of the variable to check
1498  * @param minimum_length minimum length of the variable data
1499  *
1500  * @return bytes to read containing variable data
1501  * -1 if variable is not found
1502  * 0 if buffer ended prematurely
1503  */
1505  const char *value_name,
1506  const char *value_type,
1507  unsigned int minimum_length)
1508 {
1509  GetByteContext *gb = &s->gb;
1510  int var_size = -1;
1511 
1512  if (bytestream2_get_bytes_left(gb) >= minimum_length &&
1513  !strcmp(gb->buffer, value_name)) {
1514  // found value_name, jump to value_type (null terminated strings)
1515  gb->buffer += strlen(value_name) + 1;
1516  if (!strcmp(gb->buffer, value_type)) {
1517  gb->buffer += strlen(value_type) + 1;
1518  var_size = bytestream2_get_le32(gb);
1519  // don't go read past boundaries
1520  if (var_size > bytestream2_get_bytes_left(gb))
1521  var_size = 0;
1522  } else {
1523  // value_type not found, reset the buffer
1524  gb->buffer -= strlen(value_name) + 1;
1525  av_log(s->avctx, AV_LOG_WARNING,
1526  "Unknown data type %s for header variable %s.\n",
1527  value_type, value_name);
1528  }
1529  }
1530 
1531  return var_size;
1532 }
1533 
1535 {
1536  AVDictionary *metadata = NULL;
1537  GetByteContext *gb = &s->gb;
1538  int magic_number, version, flags;
1539  int layer_match = 0;
1540  int ret;
1541  int dup_channels = 0;
1542 
1543  s->current_channel_offset = 0;
1544  s->xmin = ~0;
1545  s->xmax = ~0;
1546  s->ymin = ~0;
1547  s->ymax = ~0;
1548  s->xdelta = ~0;
1549  s->ydelta = ~0;
1550  s->channel_offsets[0] = -1;
1551  s->channel_offsets[1] = -1;
1552  s->channel_offsets[2] = -1;
1553  s->channel_offsets[3] = -1;
1554  s->pixel_type = EXR_UNKNOWN;
1555  s->compression = EXR_UNKN;
1556  s->nb_channels = 0;
1557  s->w = 0;
1558  s->h = 0;
1559  s->tile_attr.xSize = -1;
1560  s->tile_attr.ySize = -1;
1561  s->is_tile = 0;
1562  s->is_multipart = 0;
1563  s->is_luma = 0;
1564  s->current_part = 0;
1565 
1566  if (bytestream2_get_bytes_left(gb) < 10) {
1567  av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
1568  return AVERROR_INVALIDDATA;
1569  }
1570 
1571  magic_number = bytestream2_get_le32(gb);
1572  if (magic_number != 20000630) {
1573  /* As per documentation of OpenEXR, it is supposed to be
1574  * int 20000630 little-endian */
1575  av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
1576  return AVERROR_INVALIDDATA;
1577  }
1578 
1579  version = bytestream2_get_byte(gb);
1580  if (version != 2) {
1581  avpriv_report_missing_feature(s->avctx, "Version %d", version);
1582  return AVERROR_PATCHWELCOME;
1583  }
1584 
1585  flags = bytestream2_get_le24(gb);
1586 
1587  if (flags & 0x02)
1588  s->is_tile = 1;
1589  if (flags & 0x10)
1590  s->is_multipart = 1;
1591  if (flags & 0x08) {
1592  avpriv_report_missing_feature(s->avctx, "deep data");
1593  return AVERROR_PATCHWELCOME;
1594  }
1595 
1596  // Parse the header
1597  while (bytestream2_get_bytes_left(gb) > 0) {
1598  int var_size;
1599 
1600  while (s->is_multipart && s->current_part < s->selected_part &&
1601  bytestream2_get_bytes_left(gb) > 0) {
1602  if (bytestream2_peek_byte(gb)) {
1604  } else {
1605  bytestream2_skip(gb, 1);
1606  if (!bytestream2_peek_byte(gb))
1607  break;
1608  }
1609  bytestream2_skip(gb, 1);
1610  s->current_part++;
1611  }
1612 
1613  if (!bytestream2_peek_byte(gb)) {
1614  if (!s->is_multipart)
1615  break;
1616  bytestream2_skip(gb, 1);
1617  if (s->current_part == s->selected_part) {
1618  while (bytestream2_get_bytes_left(gb) > 0) {
1619  if (bytestream2_peek_byte(gb)) {
1621  } else {
1622  bytestream2_skip(gb, 1);
1623  if (!bytestream2_peek_byte(gb))
1624  break;
1625  }
1626  }
1627  }
1628  if (!bytestream2_peek_byte(gb))
1629  break;
1630  s->current_part++;
1631  }
1632 
1633  if ((var_size = check_header_variable(s, "channels",
1634  "chlist", 38)) >= 0) {
1635  GetByteContext ch_gb;
1636  if (!var_size) {
1638  goto fail;
1639  }
1640 
1641  bytestream2_init(&ch_gb, gb->buffer, var_size);
1642 
1643  while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
1645  enum ExrPixelType current_pixel_type;
1646  int channel_index = -1;
1647  int xsub, ysub;
1648 
1649  if (strcmp(s->layer, "") != 0) {
1650  if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
1651  layer_match = 1;
1652  av_log(s->avctx, AV_LOG_INFO,
1653  "Channel match layer : %s.\n", ch_gb.buffer);
1654  ch_gb.buffer += strlen(s->layer);
1655  if (*ch_gb.buffer == '.')
1656  ch_gb.buffer++; /* skip dot if not given */
1657  } else {
1658  layer_match = 0;
1659  av_log(s->avctx, AV_LOG_INFO,
1660  "Channel doesn't match layer : %s.\n", ch_gb.buffer);
1661  }
1662  } else {
1663  layer_match = 1;
1664  }
1665 
1666  if (layer_match) { /* only search channel if the layer match is valid */
1667  if (!av_strcasecmp(ch_gb.buffer, "R") ||
1668  !av_strcasecmp(ch_gb.buffer, "X") ||
1669  !av_strcasecmp(ch_gb.buffer, "U")) {
1670  channel_index = 0;
1671  s->is_luma = 0;
1672  } else if (!av_strcasecmp(ch_gb.buffer, "G") ||
1673  !av_strcasecmp(ch_gb.buffer, "V")) {
1674  channel_index = 1;
1675  s->is_luma = 0;
1676  } else if (!av_strcasecmp(ch_gb.buffer, "Y")) {
1677  channel_index = 1;
1678  s->is_luma = 1;
1679  } else if (!av_strcasecmp(ch_gb.buffer, "B") ||
1680  !av_strcasecmp(ch_gb.buffer, "Z") ||
1681  !av_strcasecmp(ch_gb.buffer, "W")) {
1682  channel_index = 2;
1683  s->is_luma = 0;
1684  } else if (!av_strcasecmp(ch_gb.buffer, "A")) {
1685  channel_index = 3;
1686  } else {
1687  av_log(s->avctx, AV_LOG_WARNING,
1688  "Unsupported channel %.256s.\n", ch_gb.buffer);
1689  }
1690  }
1691 
1692  /* skip until you get a 0 */
1693  while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1694  bytestream2_get_byte(&ch_gb))
1695  continue;
1696 
1697  if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1698  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1700  goto fail;
1701  }
1702 
1703  current_pixel_type = bytestream2_get_le32(&ch_gb);
1704  if (current_pixel_type >= EXR_UNKNOWN) {
1705  avpriv_report_missing_feature(s->avctx, "Pixel type %d",
1706  current_pixel_type);
1708  goto fail;
1709  }
1710 
1711  bytestream2_skip(&ch_gb, 4);
1712  xsub = bytestream2_get_le32(&ch_gb);
1713  ysub = bytestream2_get_le32(&ch_gb);
1714 
1715  if (xsub != 1 || ysub != 1) {
1717  "Subsampling %dx%d",
1718  xsub, ysub);
1720  goto fail;
1721  }
1722 
1723  if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
1724  if (s->pixel_type != EXR_UNKNOWN &&
1725  s->pixel_type != current_pixel_type) {
1726  av_log(s->avctx, AV_LOG_ERROR,
1727  "RGB channels not of the same depth.\n");
1729  goto fail;
1730  }
1731  s->pixel_type = current_pixel_type;
1732  s->channel_offsets[channel_index] = s->current_channel_offset;
1733  } else if (channel_index >= 0) {
1734  av_log(s->avctx, AV_LOG_WARNING,
1735  "Multiple channels with index %d.\n", channel_index);
1736  if (++dup_channels > 10) {
1738  goto fail;
1739  }
1740  }
1741 
1742  s->channels = av_realloc(s->channels,
1743  ++s->nb_channels * sizeof(EXRChannel));
1744  if (!s->channels) {
1745  ret = AVERROR(ENOMEM);
1746  goto fail;
1747  }
1748  channel = &s->channels[s->nb_channels - 1];
1749  channel->pixel_type = current_pixel_type;
1750  channel->xsub = xsub;
1751  channel->ysub = ysub;
1752 
1753  if (current_pixel_type == EXR_HALF) {
1754  s->current_channel_offset += 2;
1755  } else {/* Float or UINT32 */
1756  s->current_channel_offset += 4;
1757  }
1758  }
1759 
1760  /* Check if all channels are set with an offset or if the channels
1761  * are causing an overflow */
1762  if (!s->is_luma) {/* if we expected to have at least 3 channels */
1763  if (FFMIN3(s->channel_offsets[0],
1764  s->channel_offsets[1],
1765  s->channel_offsets[2]) < 0) {
1766  if (s->channel_offsets[0] < 0)
1767  av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1768  if (s->channel_offsets[1] < 0)
1769  av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1770  if (s->channel_offsets[2] < 0)
1771  av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1773  goto fail;
1774  }
1775  }
1776 
1777  // skip one last byte and update main gb
1778  gb->buffer = ch_gb.buffer + 1;
1779  continue;
1780  } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1781  31)) >= 0) {
1782  int xmin, ymin, xmax, ymax;
1783  if (!var_size) {
1785  goto fail;
1786  }
1787 
1788  xmin = bytestream2_get_le32(gb);
1789  ymin = bytestream2_get_le32(gb);
1790  xmax = bytestream2_get_le32(gb);
1791  ymax = bytestream2_get_le32(gb);
1792 
1793  if (xmin > xmax || ymin > ymax ||
1794  ymax == INT_MAX || xmax == INT_MAX ||
1795  (unsigned)xmax - xmin >= INT_MAX ||
1796  (unsigned)ymax - ymin >= INT_MAX) {
1798  goto fail;
1799  }
1800  s->xmin = xmin;
1801  s->xmax = xmax;
1802  s->ymin = ymin;
1803  s->ymax = ymax;
1804  s->xdelta = (s->xmax - s->xmin) + 1;
1805  s->ydelta = (s->ymax - s->ymin) + 1;
1806 
1807  continue;
1808  } else if ((var_size = check_header_variable(s, "displayWindow",
1809  "box2i", 34)) >= 0) {
1810  int32_t sx, sy, dx, dy;
1811 
1812  if (!var_size) {
1814  goto fail;
1815  }
1816 
1817  sx = bytestream2_get_le32(gb);
1818  sy = bytestream2_get_le32(gb);
1819  dx = bytestream2_get_le32(gb);
1820  dy = bytestream2_get_le32(gb);
1821 
1822  s->w = (unsigned)dx - sx + 1;
1823  s->h = (unsigned)dy - sy + 1;
1824 
1825  continue;
1826  } else if ((var_size = check_header_variable(s, "lineOrder",
1827  "lineOrder", 25)) >= 0) {
1828  int line_order;
1829  if (!var_size) {
1831  goto fail;
1832  }
1833 
1834  line_order = bytestream2_get_byte(gb);
1835  av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1836  if (line_order > 2) {
1837  av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1839  goto fail;
1840  }
1841 
1842  continue;
1843  } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1844  "float", 31)) >= 0) {
1845  if (!var_size) {
1847  goto fail;
1848  }
1849 
1850  s->sar = bytestream2_get_le32(gb);
1851 
1852  continue;
1853  } else if ((var_size = check_header_variable(s, "compression",
1854  "compression", 29)) >= 0) {
1855  if (!var_size) {
1857  goto fail;
1858  }
1859 
1860  if (s->compression == EXR_UNKN)
1861  s->compression = bytestream2_get_byte(gb);
1862  else {
1863  bytestream2_skip(gb, 1);
1864  av_log(s->avctx, AV_LOG_WARNING,
1865  "Found more than one compression attribute.\n");
1866  }
1867 
1868  continue;
1869  } else if ((var_size = check_header_variable(s, "tiles",
1870  "tiledesc", 22)) >= 0) {
1871  uint8_t tileLevel;
1872 
1873  if (!s->is_tile)
1874  av_log(s->avctx, AV_LOG_WARNING,
1875  "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1876 
1877  s->tile_attr.xSize = bytestream2_get_le32(gb);
1878  s->tile_attr.ySize = bytestream2_get_le32(gb);
1879 
1880  tileLevel = bytestream2_get_byte(gb);
1881  s->tile_attr.level_mode = tileLevel & 0x0f;
1882  s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1883 
1884  if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN) {
1885  avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
1886  s->tile_attr.level_mode);
1888  goto fail;
1889  }
1890 
1891  if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
1892  avpriv_report_missing_feature(s->avctx, "Tile level round %d",
1893  s->tile_attr.level_round);
1895  goto fail;
1896  }
1897 
1898  continue;
1899  } else if ((var_size = check_header_variable(s, "writer",
1900  "string", 1)) >= 0) {
1901  uint8_t key[256] = { 0 };
1902 
1903  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1904  av_dict_set(&metadata, "writer", key, 0);
1905 
1906  continue;
1907  } else if ((var_size = check_header_variable(s, "framesPerSecond",
1908  "rational", 33)) >= 0) {
1909  if (!var_size) {
1911  goto fail;
1912  }
1913 
1914  s->avctx->framerate.num = bytestream2_get_le32(gb);
1915  s->avctx->framerate.den = bytestream2_get_le32(gb);
1916 
1917  continue;
1918  } else if ((var_size = check_header_variable(s, "chunkCount",
1919  "int", 23)) >= 0) {
1920 
1921  s->chunk_count = bytestream2_get_le32(gb);
1922 
1923  continue;
1924  } else if ((var_size = check_header_variable(s, "type",
1925  "string", 16)) >= 0) {
1926  uint8_t key[256] = { 0 };
1927 
1928  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1929  if (strncmp("scanlineimage", key, var_size) &&
1930  strncmp("tiledimage", key, var_size)) {
1932  goto fail;
1933  }
1934 
1935  continue;
1936  } else if ((var_size = check_header_variable(s, "preview",
1937  "preview", 16)) >= 0) {
1938  uint32_t pw = bytestream2_get_le32(gb);
1939  uint32_t ph = bytestream2_get_le32(gb);
1940  uint64_t psize = pw * (uint64_t)ph;
1941  if (psize > INT64_MAX / 4) {
1943  goto fail;
1944  }
1945  psize *= 4;
1946 
1947  if ((int64_t)psize >= bytestream2_get_bytes_left(gb)) {
1949  goto fail;
1950  }
1951 
1952  bytestream2_skip(gb, psize);
1953 
1954  continue;
1955  }
1956 
1957  // Check if there are enough bytes for a header
1958  if (bytestream2_get_bytes_left(gb) <= 9) {
1959  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1961  goto fail;
1962  }
1963 
1964  // Process unknown variables
1965  {
1966  uint8_t name[256] = { 0 };
1967  uint8_t type[256] = { 0 };
1968  uint8_t value[8192] = { 0 };
1969  int i = 0, size;
1970 
1971  while (bytestream2_get_bytes_left(gb) > 0 &&
1972  bytestream2_peek_byte(gb) && i < 255) {
1973  name[i++] = bytestream2_get_byte(gb);
1974  }
1975 
1976  bytestream2_skip(gb, 1);
1977  i = 0;
1978  while (bytestream2_get_bytes_left(gb) > 0 &&
1979  bytestream2_peek_byte(gb) && i < 255) {
1980  type[i++] = bytestream2_get_byte(gb);
1981  }
1982  bytestream2_skip(gb, 1);
1983  size = bytestream2_get_le32(gb);
1984 
1985  bytestream2_get_buffer(gb, value, FFMIN(sizeof(value) - 1, size));
1986  if (size > sizeof(value) - 1)
1987  bytestream2_skip(gb, size - (sizeof(value) - 1));
1988  if (!strcmp(type, "string"))
1989  av_dict_set(&metadata, name, value, 0);
1990  }
1991  }
1992 
1993  if (s->compression == EXR_UNKN) {
1994  av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
1996  goto fail;
1997  }
1998 
1999  if (s->is_tile) {
2000  if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
2001  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
2003  goto fail;
2004  }
2005  }
2006 
2007  if (bytestream2_get_bytes_left(gb) <= 0) {
2008  av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
2010  goto fail;
2011  }
2012 
2013  frame->metadata = metadata;
2014 
2015  // aaand we are done
2016  bytestream2_skip(gb, 1);
2017  return 0;
2018 fail:
2019  av_dict_free(&metadata);
2020  return ret;
2021 }
2022 
2023 static int decode_frame(AVCodecContext *avctx, AVFrame *picture,
2024  int *got_frame, AVPacket *avpkt)
2025 {
2026  EXRContext *s = avctx->priv_data;
2027  GetByteContext *gb = &s->gb;
2028  uint8_t *ptr;
2029 
2030  int i, y, ret, ymax;
2031  int planes;
2032  int out_line_size;
2033  int nb_blocks; /* nb scanline or nb tile */
2034  uint64_t start_offset_table;
2035  uint64_t start_next_scanline;
2036 
2037  bytestream2_init(gb, avpkt->data, avpkt->size);
2038 
2039  if ((ret = decode_header(s, picture)) < 0)
2040  return ret;
2041 
2042  if ((s->compression == EXR_DWAA || s->compression == EXR_DWAB) &&
2043  s->pixel_type == EXR_HALF) {
2044  s->current_channel_offset *= 2;
2045  for (int i = 0; i < 4; i++)
2046  s->channel_offsets[i] *= 2;
2047  }
2048 
2049  switch (s->pixel_type) {
2050  case EXR_HALF:
2051  if (!(s->compression == EXR_DWAA || s->compression == EXR_DWAB)) {
2052  if (s->channel_offsets[3] >= 0) {
2053  if (!s->is_luma) {
2054  avctx->pix_fmt = AV_PIX_FMT_GBRAPF16;
2055  } else {
2056  avctx->pix_fmt = AV_PIX_FMT_YAF16;
2057  }
2058  } else {
2059  if (!s->is_luma) {
2060  avctx->pix_fmt = AV_PIX_FMT_GBRPF16;
2061  } else {
2062  avctx->pix_fmt = AV_PIX_FMT_GRAYF16;
2063  }
2064  }
2065  break;
2066  }
2067  case EXR_FLOAT:
2068  if (s->channel_offsets[3] >= 0) {
2069  if (!s->is_luma) {
2070  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2071  } else {
2072  avctx->pix_fmt = AV_PIX_FMT_YAF32;
2073  }
2074  } else {
2075  if (!s->is_luma) {
2076  avctx->pix_fmt = AV_PIX_FMT_GBRPF32;
2077  } else {
2078  avctx->pix_fmt = AV_PIX_FMT_GRAYF32;
2079  }
2080  }
2081  break;
2082  case EXR_UINT:
2083  if (s->channel_offsets[3] >= 0) {
2084  if (!s->is_luma) {
2085  avctx->pix_fmt = AV_PIX_FMT_RGBA64;
2086  } else {
2087  avctx->pix_fmt = AV_PIX_FMT_YA16;
2088  }
2089  } else {
2090  if (!s->is_luma) {
2091  avctx->pix_fmt = AV_PIX_FMT_RGB48;
2092  } else {
2093  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
2094  }
2095  }
2096  break;
2097  default:
2098  av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
2099  return AVERROR_INVALIDDATA;
2100  }
2101 
2102 #if FF_API_EXR_GAMMA
2103  if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
2104  avctx->color_trc = s->apply_trc_type;
2105  else if (s->gamma > 0.9999f && s->gamma < 1.0001f)
2106 #endif
2107  avctx->color_trc = AVCOL_TRC_LINEAR;
2108 
2109  switch (s->compression) {
2110  case EXR_RAW:
2111  case EXR_RLE:
2112  case EXR_ZIP1:
2113  s->scan_lines_per_block = 1;
2114  break;
2115  case EXR_PXR24:
2116  case EXR_ZIP16:
2117  s->scan_lines_per_block = 16;
2118  break;
2119  case EXR_PIZ:
2120  case EXR_B44:
2121  case EXR_B44A:
2122  case EXR_DWAA:
2123  s->scan_lines_per_block = 32;
2124  break;
2125  case EXR_DWAB:
2126  s->scan_lines_per_block = 256;
2127  break;
2128  default:
2129  avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
2130  return AVERROR_PATCHWELCOME;
2131  }
2132 
2133  /* Verify the xmin, xmax, ymin and ymax before setting the actual image size.
2134  * It's possible for the data window can larger or outside the display window */
2135  if (s->xmin > s->xmax || s->ymin > s->ymax ||
2136  s->ydelta == 0xFFFFFFFF || s->xdelta == 0xFFFFFFFF) {
2137  av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
2138  return AVERROR_INVALIDDATA;
2139  }
2140 
2141  if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
2142  return ret;
2143 
2144  ff_set_sar(s->avctx, av_d2q(av_int2float(s->sar), 255));
2145 
2146  if (avctx->skip_frame >= AVDISCARD_ALL)
2147  return avpkt->size;
2148 
2149  s->desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2150  if (!s->desc)
2151  return AVERROR_INVALIDDATA;
2152 
2154  out_line_size = avctx->width * s->desc->comp[0].step;
2155 
2156  if (s->is_tile) {
2157  nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
2158  ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
2159  } else { /* scanline */
2160  nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
2161  s->scan_lines_per_block;
2162  }
2163 
2164  if ((ret = ff_thread_get_buffer(avctx, picture, 0)) < 0)
2165  return ret;
2166 
2167  if (bytestream2_get_bytes_left(gb)/8 < nb_blocks)
2168  return AVERROR_INVALIDDATA;
2169 
2170  // check offset table and recreate it if need
2171  if (!s->is_tile && bytestream2_peek_le64(gb) == 0) {
2172  PutByteContext offset_table_writer;
2173 
2174  av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
2175 
2176  s->offset_table = av_realloc_f(s->offset_table, nb_blocks, 8);
2177  if (!s->offset_table)
2178  return AVERROR(ENOMEM);
2179 
2180  start_offset_table = bytestream2_tell(gb);
2181  start_next_scanline = start_offset_table + nb_blocks * 8;
2182  bytestream2_init_writer(&offset_table_writer, s->offset_table, nb_blocks * 8);
2183 
2184  for (y = 0; y < nb_blocks; y++) {
2185  /* write offset of prev scanline in offset table */
2186  bytestream2_put_le64(&offset_table_writer, start_next_scanline);
2187 
2188  /* get len of next scanline */
2189  bytestream2_seek(gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
2190  start_next_scanline += (bytestream2_get_le32(gb) + 8);
2191  }
2192  bytestream2_init(gb, s->offset_table, nb_blocks * 8);
2193  }
2194 
2195  // save pointer we are going to use in decode_block
2196  s->buf = avpkt->data;
2197  s->buf_size = avpkt->size;
2198 
2199  // Zero out the start if ymin is not 0
2200  for (i = 0; i < planes; i++) {
2201  ptr = picture->data[i];
2202  for (y = 0; y < FFMIN(s->ymin, s->h); y++) {
2203  memset(ptr, 0, out_line_size);
2204  ptr += picture->linesize[i];
2205  }
2206  }
2207 
2208  s->picture = picture;
2209 
2210  avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
2211 
2212  ymax = FFMAX(0, s->ymax + 1);
2213  // Zero out the end if ymax+1 is not h
2214  if (ymax < avctx->height)
2215  for (i = 0; i < planes; i++) {
2216  ptr = picture->data[i] + (ymax * picture->linesize[i]);
2217  for (y = ymax; y < avctx->height; y++) {
2218  memset(ptr, 0, out_line_size);
2219  ptr += picture->linesize[i];
2220  }
2221  }
2222 
2223  picture->pict_type = AV_PICTURE_TYPE_I;
2224  *got_frame = 1;
2225 
2226  return avpkt->size;
2227 }
2228 
2230 {
2231  EXRContext *s = avctx->priv_data;
2232 #if FF_API_EXR_GAMMA
2233  uint32_t i;
2234  union av_intfloat32 t;
2235  float one_gamma = 1.0f / s->gamma;
2236  av_csp_trc_function trc_func = NULL;
2237  ff_init_float2half_tables(&s->f2h_tables);
2238 #endif
2239 
2240  ff_init_half2float_tables(&s->h2f_tables);
2241 
2242  s->avctx = avctx;
2243 
2244  ff_exrdsp_init(&s->dsp);
2245 
2246 #if HAVE_BIGENDIAN
2247  ff_bswapdsp_init(&s->bbdsp);
2248 #endif
2249 
2250 #if FF_API_EXR_GAMMA
2251  trc_func = av_csp_trc_func_from_id(s->apply_trc_type);
2252  if (trc_func) {
2253  for (i = 0; i < 65536; ++i) {
2254  t.i = half2float(i, &s->h2f_tables);
2255  t.f = trc_func(t.f);
2256  s->gamma_table[i] = float2half(av_float2int(t.f), &s->f2h_tables);
2257  }
2258  } else if (one_gamma != 1.0f) {
2259  for (i = 0; i < 65536; ++i) {
2260  t.i = half2float(i, &s->h2f_tables);
2261  /* If negative value we reuse half value */
2262  if (t.f <= 0.0f) {
2263  s->gamma_table[i] = i;
2264  } else {
2265  t.f = powf(t.f, one_gamma);
2266  s->gamma_table[i] = float2half(t.i, &s->f2h_tables);
2267  }
2268  }
2269  }
2270 #endif
2271 
2272  // allocate thread data, used for non EXR_RAW compression types
2273  s->thread_data = av_calloc(avctx->thread_count, sizeof(*s->thread_data));
2274  if (!s->thread_data)
2275  return AVERROR(ENOMEM);
2276 
2277  return 0;
2278 }
2279 
2281 {
2282  EXRContext *s = avctx->priv_data;
2283  int i;
2284  for (i = 0; i < avctx->thread_count; i++) {
2285  EXRThreadData *td = &s->thread_data[i];
2287  av_freep(&td->tmp);
2288  av_freep(&td->bitmap);
2289  av_freep(&td->lut);
2290  av_freep(&td->he);
2291  av_freep(&td->freq);
2292  av_freep(&td->ac_data);
2293  av_freep(&td->dc_data);
2294  av_freep(&td->rle_data);
2295  av_freep(&td->rle_raw_data);
2296  ff_vlc_free(&td->vlc);
2297  }
2298 
2299  av_freep(&s->thread_data);
2300  av_freep(&s->channels);
2301  av_freep(&s->offset_table);
2302 
2303  return 0;
2304 }
2305 
2306 #define OFFSET(x) offsetof(EXRContext, x)
2307 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2308 static const AVOption options[] = {
2309  { "layer", "Set the decoding layer", OFFSET(layer),
2310  AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
2311  { "part", "Set the decoding part", OFFSET(selected_part),
2312  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
2313 #if FF_API_EXR_GAMMA
2314  { "gamma", "Set the float gamma value when decoding (deprecated, use a scaler)", OFFSET(gamma),
2315  AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD | AV_OPT_FLAG_DEPRECATED },
2316 
2317  // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
2318  { "apply_trc", "color transfer characteristics to apply to EXR linear input (deprecated, use a scaler)", OFFSET(apply_trc_type),
2319  AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD | AV_OPT_FLAG_DEPRECATED, .unit = "apply_trc_type"},
2320  { "bt709", "BT.709", 0,
2321  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2322  { "gamma", "gamma", 0,
2323  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2324  { "gamma22", "BT.470 M", 0,
2325  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2326  { "gamma28", "BT.470 BG", 0,
2327  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2328  { "smpte170m", "SMPTE 170 M", 0,
2329  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2330  { "smpte240m", "SMPTE 240 M", 0,
2331  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2332  { "linear", "Linear", 0,
2333  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2334  { "log", "Log", 0,
2335  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2336  { "log_sqrt", "Log square root", 0,
2337  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2338  { "iec61966_2_4", "IEC 61966-2-4", 0,
2339  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2340  { "bt1361", "BT.1361", 0,
2341  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2342  { "iec61966_2_1", "IEC 61966-2-1", 0,
2343  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2344  { "bt2020_10bit", "BT.2020 - 10 bit", 0,
2345  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2346  { "bt2020_12bit", "BT.2020 - 12 bit", 0,
2347  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2348  { "smpte2084", "SMPTE ST 2084", 0,
2349  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2350  { "smpte428_1", "SMPTE ST 428-1", 0,
2351  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, .unit = "apply_trc_type"},
2352 #endif
2353 
2354  { NULL },
2355 };
2356 
2357 static const AVClass exr_class = {
2358  .class_name = "EXR",
2359  .item_name = av_default_item_name,
2360  .option = options,
2361  .version = LIBAVUTIL_VERSION_INT,
2362 };
2363 
2365  .p.name = "exr",
2366  CODEC_LONG_NAME("OpenEXR image"),
2367  .p.type = AVMEDIA_TYPE_VIDEO,
2368  .p.id = AV_CODEC_ID_EXR,
2369  .priv_data_size = sizeof(EXRContext),
2370  .init = decode_init,
2371  .close = decode_end,
2373  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2375  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2376  .p.priv_class = &exr_class,
2377 };
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:215
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:678
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
EXRTileAttribute
Definition: exr.c:107
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:644
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
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
EXRThreadData::uncompressed_data
uint8_t * uncompressed_data
Definition: exr.c:115
VD
#define VD
Definition: exr.c:2307
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:3341
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:653
decode_header
static int decode_header(EXRContext *s, AVFrame *frame)
Definition: exr.c:1534
EXRContext::layer
const char * layer
Definition: exr.c:189
int64_t
long long int64_t
Definition: coverity.c:34
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:249
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:2023
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:3043
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:410
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:666
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
AVPacket::data
uint8_t * data
Definition: packet.h:535
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:647
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: exr.c:2229
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:660
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:2308
EXRThreadData::tmp_size
int tmp_size
Definition: exr.c:119
planes
static const struct @487 planes[]
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:497
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:431
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
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:3381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
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:53
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:658
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:194
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:108
ub
#define ub(width, name)
Definition: cbs_h2645.c:401
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:650
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:564
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:511
AV_PIX_FMT_YAF32
#define AV_PIX_FMT_YAF32
Definition: pixfmt.h:568
AVCOL_TRC_LOG_SQRT
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
Definition: pixfmt.h:655
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:2364
AVCOL_TRC_SMPTEST428_1
@ AVCOL_TRC_SMPTEST428_1
Definition: pixfmt.h:664
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:649
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:2280
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
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:528
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:1504
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:657
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:1179
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
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:1475
key
const char * key
Definition: hwcontext_opencl.c:189
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:565
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:221
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:518
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
exrdsp.h
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:204
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:656
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:239
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
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:659
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:635
close
av_cold void CBS_FUNC() close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:140
AV_PIX_FMT_GBRPF16
#define AV_PIX_FMT_GBRPF16
Definition: pixfmt.h:559
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
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
bytestream2_tell
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
EXRThreadData::bitmap
uint8_t * bitmap
Definition: exr.c: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:502
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:536
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:652
height
#define height
Definition: dsp.h:85
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:83
AVCOL_TRC_SMPTEST2084
@ AVCOL_TRC_SMPTEST2084
Definition: pixfmt.h:662
AVCOL_TRC_LOG
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
Definition: pixfmt.h:654
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:561
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:514
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:220
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:646
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
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:2306
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:513
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:56
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:98
AV_PIX_FMT_YAF16
#define AV_PIX_FMT_YAF16
Definition: pixfmt.h:567
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:80
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_init_half2float_tables
void ff_init_half2float_tables(Half2FloatTables *t)
Definition: half2float.c:39
rle_uncompress
static int rle_uncompress(const EXRContext *ctx, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c: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:562
EXRThreadData::run_sym
int run_sym
Definition: exr.c:142
AV_PIX_FMT_GBRAPF16
#define AV_PIX_FMT_GBRAPF16
Definition: pixfmt.h:560
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:651
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:201
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:291
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:512
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:455
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:2357
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:375
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