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