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