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 < 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  if (dc_size > 0) {
1063  unsigned long dest_len = dc_count * 2LL;
1064  GetByteContext agb = gb;
1065 
1066  if (dc_count > (6LL * td->xsize * td->ysize + 63) / 64)
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 (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
1303  av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
1304  if (!td->tmp)
1305  return AVERROR(ENOMEM);
1306  }
1307 
1308  if (data_size < uncompressed_size) {
1309  av_fast_padded_malloc(&td->uncompressed_data,
1310  &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
1311 
1312  if (!td->uncompressed_data)
1313  return AVERROR(ENOMEM);
1314 
1316  switch (s->compression) {
1317  case EXR_ZIP1:
1318  case EXR_ZIP16:
1319  ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
1320  break;
1321  case EXR_PIZ:
1322  ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
1323  break;
1324  case EXR_PXR24:
1325  ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
1326  break;
1327  case EXR_RLE:
1328  ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
1329  break;
1330  case EXR_B44:
1331  case EXR_B44A:
1332  ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
1333  break;
1334  case EXR_DWAA:
1335  case EXR_DWAB:
1336  ret = dwa_uncompress(s, src, data_size, uncompressed_size, td);
1337  break;
1338  }
1339  if (ret < 0) {
1340  av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
1341  return ret;
1342  }
1343  src = td->uncompressed_data;
1344  }
1345 
1346  /* offsets to crop data outside display window */
1347  data_xoffset = FFABS(FFMIN(0, s->xmin + col)) * (s->pixel_type == EXR_HALF ? 2 : 4);
1348  data_yoffset = FFABS(FFMIN(0, line));
1349  data_window_offset = (data_yoffset * td->channel_line_size) + data_xoffset;
1350 
1351  if (!s->is_luma) {
1352  channel_buffer[0] = src + (td->xsize * s->channel_offsets[0]) + data_window_offset;
1353  channel_buffer[1] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1354  channel_buffer[2] = src + (td->xsize * s->channel_offsets[2]) + data_window_offset;
1355  rgb_channel_count = 3;
1356  } else { /* put y data in the first channel_buffer */
1357  channel_buffer[0] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1358  rgb_channel_count = 1;
1359  }
1360  if (s->channel_offsets[3] >= 0)
1361  channel_buffer[3] = src + (td->xsize * s->channel_offsets[3]) + data_window_offset;
1362 
1363  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
1364  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
1365  int channel_count = s->channel_offsets[3] >= 0 ? 4 : rgb_channel_count;
1366  if (s->is_luma) {
1367  channel_buffer[1] = channel_buffer[0];
1368  channel_buffer[2] = channel_buffer[0];
1369  }
1370 
1371  for (c = 0; c < channel_count; c++) {
1372  int plane = s->desc->comp[c].plane;
1373  ptr = p->data[plane] + window_ymin * p->linesize[plane] + (window_xmin * 4);
1374 
1375  for (i = 0; i < ysize; i++, ptr += p->linesize[plane]) {
1376  const uint8_t *src;
1377  union av_intfloat32 *ptr_x;
1378 
1379  src = channel_buffer[c];
1380  ptr_x = (union av_intfloat32 *)ptr;
1381 
1382  // Zero out the start if xmin is not 0
1383  memset(ptr_x, 0, bxmin);
1384  ptr_x += window_xoffset;
1385 
1386  if (s->pixel_type == EXR_FLOAT ||
1387  s->compression == EXR_DWAA ||
1388  s->compression == EXR_DWAB) {
1389  // 32-bit
1390  union av_intfloat32 t;
1391  if (trc_func && c < 3) {
1392  for (x = 0; x < xsize; x++) {
1393  t.i = bytestream_get_le32(&src);
1394  t.f = trc_func(t.f);
1395  *ptr_x++ = t;
1396  }
1397  } else if (one_gamma != 1.f) {
1398  for (x = 0; x < xsize; x++) {
1399  t.i = bytestream_get_le32(&src);
1400  if (t.f > 0.0f && c < 3) /* avoid negative values */
1401  t.f = powf(t.f, one_gamma);
1402  *ptr_x++ = t;
1403  }
1404  } else {
1405  for (x = 0; x < xsize; x++) {
1406  t.i = bytestream_get_le32(&src);
1407  *ptr_x++ = t;
1408  }
1409  }
1410  } else if (s->pixel_type == EXR_HALF) {
1411  // 16-bit
1412  if (c < 3 || !trc_func) {
1413  for (x = 0; x < xsize; x++) {
1414  *ptr_x++ = s->gamma_table[bytestream_get_le16(&src)];
1415  }
1416  } else {
1417  for (x = 0; x < xsize; x++) {
1418  ptr_x[0].i = half2float(bytestream_get_le16(&src),
1419  s->mantissatable,
1420  s->exponenttable,
1421  s->offsettable);
1422  ptr_x++;
1423  }
1424  }
1425  }
1426 
1427  // Zero out the end if xmax+1 is not w
1428  memset(ptr_x, 0, axmax);
1429  channel_buffer[c] += td->channel_line_size;
1430  }
1431  }
1432  } else {
1433 
1434  av_assert1(s->pixel_type == EXR_UINT);
1435  ptr = p->data[0] + window_ymin * p->linesize[0] + (window_xmin * s->desc->nb_components * 2);
1436 
1437  for (i = 0; i < ysize; i++, ptr += p->linesize[0]) {
1438 
1439  const uint8_t * a;
1440  const uint8_t *rgb[3];
1441  uint16_t *ptr_x;
1442 
1443  for (c = 0; c < rgb_channel_count; c++) {
1444  rgb[c] = channel_buffer[c];
1445  }
1446 
1447  if (channel_buffer[3])
1448  a = channel_buffer[3];
1449 
1450  ptr_x = (uint16_t *) ptr;
1451 
1452  // Zero out the start if xmin is not 0
1453  memset(ptr_x, 0, bxmin);
1454  ptr_x += window_xoffset * s->desc->nb_components;
1455 
1456  for (x = 0; x < xsize; x++) {
1457  for (c = 0; c < rgb_channel_count; c++) {
1458  *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
1459  }
1460 
1461  if (channel_buffer[3])
1462  *ptr_x++ = bytestream_get_le32(&a) >> 16;
1463  }
1464 
1465  // Zero out the end if xmax+1 is not w
1466  memset(ptr_x, 0, axmax);
1467 
1468  channel_buffer[0] += td->channel_line_size;
1469  channel_buffer[1] += td->channel_line_size;
1470  channel_buffer[2] += td->channel_line_size;
1471  if (channel_buffer[3])
1472  channel_buffer[3] += td->channel_line_size;
1473  }
1474  }
1475 
1476  return 0;
1477 }
1478 
1480 {
1481  GetByteContext *gb = &s->gb;
1482 
1483  while (bytestream2_get_bytes_left(gb) > 0) {
1484  if (!bytestream2_peek_byte(gb))
1485  break;
1486 
1487  // Process unknown variables
1488  for (int i = 0; i < 2; i++) // value_name and value_type
1489  while (bytestream2_get_byte(gb) != 0);
1490 
1491  // Skip variable length
1492  bytestream2_skip(gb, bytestream2_get_le32(gb));
1493  }
1494 }
1495 
1496 /**
1497  * Check if the variable name corresponds to its data type.
1498  *
1499  * @param s the EXRContext
1500  * @param value_name name of the variable to check
1501  * @param value_type type of the variable to check
1502  * @param minimum_length minimum length of the variable data
1503  *
1504  * @return bytes to read containing variable data
1505  * -1 if variable is not found
1506  * 0 if buffer ended prematurely
1507  */
1509  const char *value_name,
1510  const char *value_type,
1511  unsigned int minimum_length)
1512 {
1513  GetByteContext *gb = &s->gb;
1514  int var_size = -1;
1515 
1516  if (bytestream2_get_bytes_left(gb) >= minimum_length &&
1517  !strcmp(gb->buffer, value_name)) {
1518  // found value_name, jump to value_type (null terminated strings)
1519  gb->buffer += strlen(value_name) + 1;
1520  if (!strcmp(gb->buffer, value_type)) {
1521  gb->buffer += strlen(value_type) + 1;
1522  var_size = bytestream2_get_le32(gb);
1523  // don't go read past boundaries
1524  if (var_size > bytestream2_get_bytes_left(gb))
1525  var_size = 0;
1526  } else {
1527  // value_type not found, reset the buffer
1528  gb->buffer -= strlen(value_name) + 1;
1529  av_log(s->avctx, AV_LOG_WARNING,
1530  "Unknown data type %s for header variable %s.\n",
1531  value_type, value_name);
1532  }
1533  }
1534 
1535  return var_size;
1536 }
1537 
1539 {
1540  AVDictionary *metadata = NULL;
1541  GetByteContext *gb = &s->gb;
1542  int magic_number, version, flags;
1543  int layer_match = 0;
1544  int ret;
1545  int dup_channels = 0;
1546 
1547  s->current_channel_offset = 0;
1548  s->xmin = ~0;
1549  s->xmax = ~0;
1550  s->ymin = ~0;
1551  s->ymax = ~0;
1552  s->xdelta = ~0;
1553  s->ydelta = ~0;
1554  s->channel_offsets[0] = -1;
1555  s->channel_offsets[1] = -1;
1556  s->channel_offsets[2] = -1;
1557  s->channel_offsets[3] = -1;
1558  s->pixel_type = EXR_UNKNOWN;
1559  s->compression = EXR_UNKN;
1560  s->nb_channels = 0;
1561  s->w = 0;
1562  s->h = 0;
1563  s->tile_attr.xSize = -1;
1564  s->tile_attr.ySize = -1;
1565  s->is_tile = 0;
1566  s->is_multipart = 0;
1567  s->is_luma = 0;
1568  s->current_part = 0;
1569 
1570  if (bytestream2_get_bytes_left(gb) < 10) {
1571  av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
1572  return AVERROR_INVALIDDATA;
1573  }
1574 
1575  magic_number = bytestream2_get_le32(gb);
1576  if (magic_number != 20000630) {
1577  /* As per documentation of OpenEXR, it is supposed to be
1578  * int 20000630 little-endian */
1579  av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
1580  return AVERROR_INVALIDDATA;
1581  }
1582 
1583  version = bytestream2_get_byte(gb);
1584  if (version != 2) {
1585  avpriv_report_missing_feature(s->avctx, "Version %d", version);
1586  return AVERROR_PATCHWELCOME;
1587  }
1588 
1589  flags = bytestream2_get_le24(gb);
1590 
1591  if (flags & 0x02)
1592  s->is_tile = 1;
1593  if (flags & 0x10)
1594  s->is_multipart = 1;
1595  if (flags & 0x08) {
1596  avpriv_report_missing_feature(s->avctx, "deep data");
1597  return AVERROR_PATCHWELCOME;
1598  }
1599 
1600  // Parse the header
1601  while (bytestream2_get_bytes_left(gb) > 0) {
1602  int var_size;
1603 
1604  while (s->is_multipart && s->current_part < s->selected_part &&
1605  bytestream2_get_bytes_left(gb) > 0) {
1606  if (bytestream2_peek_byte(gb)) {
1608  } else {
1609  bytestream2_skip(gb, 1);
1610  if (!bytestream2_peek_byte(gb))
1611  break;
1612  }
1613  bytestream2_skip(gb, 1);
1614  s->current_part++;
1615  }
1616 
1617  if (!bytestream2_peek_byte(gb)) {
1618  if (!s->is_multipart)
1619  break;
1620  bytestream2_skip(gb, 1);
1621  if (s->current_part == s->selected_part) {
1622  while (bytestream2_get_bytes_left(gb) > 0) {
1623  if (bytestream2_peek_byte(gb)) {
1625  } else {
1626  bytestream2_skip(gb, 1);
1627  if (!bytestream2_peek_byte(gb))
1628  break;
1629  }
1630  }
1631  }
1632  if (!bytestream2_peek_byte(gb))
1633  break;
1634  s->current_part++;
1635  }
1636 
1637  if ((var_size = check_header_variable(s, "channels",
1638  "chlist", 38)) >= 0) {
1639  GetByteContext ch_gb;
1640  if (!var_size) {
1642  goto fail;
1643  }
1644 
1645  bytestream2_init(&ch_gb, gb->buffer, var_size);
1646 
1647  while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
1649  enum ExrPixelType current_pixel_type;
1650  int channel_index = -1;
1651  int xsub, ysub;
1652 
1653  if (strcmp(s->layer, "") != 0) {
1654  if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
1655  layer_match = 1;
1656  av_log(s->avctx, AV_LOG_INFO,
1657  "Channel match layer : %s.\n", ch_gb.buffer);
1658  ch_gb.buffer += strlen(s->layer);
1659  if (*ch_gb.buffer == '.')
1660  ch_gb.buffer++; /* skip dot if not given */
1661  } else {
1662  layer_match = 0;
1663  av_log(s->avctx, AV_LOG_INFO,
1664  "Channel doesn't match layer : %s.\n", ch_gb.buffer);
1665  }
1666  } else {
1667  layer_match = 1;
1668  }
1669 
1670  if (layer_match) { /* only search channel if the layer match is valid */
1671  if (!av_strcasecmp(ch_gb.buffer, "R") ||
1672  !av_strcasecmp(ch_gb.buffer, "X") ||
1673  !av_strcasecmp(ch_gb.buffer, "U")) {
1674  channel_index = 0;
1675  s->is_luma = 0;
1676  } else if (!av_strcasecmp(ch_gb.buffer, "G") ||
1677  !av_strcasecmp(ch_gb.buffer, "V")) {
1678  channel_index = 1;
1679  s->is_luma = 0;
1680  } else if (!av_strcasecmp(ch_gb.buffer, "Y")) {
1681  channel_index = 1;
1682  s->is_luma = 1;
1683  } else if (!av_strcasecmp(ch_gb.buffer, "B") ||
1684  !av_strcasecmp(ch_gb.buffer, "Z") ||
1685  !av_strcasecmp(ch_gb.buffer, "W")) {
1686  channel_index = 2;
1687  s->is_luma = 0;
1688  } else if (!av_strcasecmp(ch_gb.buffer, "A")) {
1689  channel_index = 3;
1690  } else {
1691  av_log(s->avctx, AV_LOG_WARNING,
1692  "Unsupported channel %.256s.\n", ch_gb.buffer);
1693  }
1694  }
1695 
1696  /* skip until you get a 0 */
1697  while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1698  bytestream2_get_byte(&ch_gb))
1699  continue;
1700 
1701  if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1702  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1704  goto fail;
1705  }
1706 
1707  current_pixel_type = bytestream2_get_le32(&ch_gb);
1708  if (current_pixel_type >= EXR_UNKNOWN) {
1709  avpriv_report_missing_feature(s->avctx, "Pixel type %d",
1710  current_pixel_type);
1712  goto fail;
1713  }
1714 
1715  bytestream2_skip(&ch_gb, 4);
1716  xsub = bytestream2_get_le32(&ch_gb);
1717  ysub = bytestream2_get_le32(&ch_gb);
1718 
1719  if (xsub != 1 || ysub != 1) {
1721  "Subsampling %dx%d",
1722  xsub, ysub);
1724  goto fail;
1725  }
1726 
1727  if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
1728  if (s->pixel_type != EXR_UNKNOWN &&
1729  s->pixel_type != current_pixel_type) {
1730  av_log(s->avctx, AV_LOG_ERROR,
1731  "RGB channels not of the same depth.\n");
1733  goto fail;
1734  }
1735  s->pixel_type = current_pixel_type;
1736  s->channel_offsets[channel_index] = s->current_channel_offset;
1737  } else if (channel_index >= 0) {
1738  av_log(s->avctx, AV_LOG_WARNING,
1739  "Multiple channels with index %d.\n", channel_index);
1740  if (++dup_channels > 10) {
1742  goto fail;
1743  }
1744  }
1745 
1746  s->channels = av_realloc(s->channels,
1747  ++s->nb_channels * sizeof(EXRChannel));
1748  if (!s->channels) {
1749  ret = AVERROR(ENOMEM);
1750  goto fail;
1751  }
1752  channel = &s->channels[s->nb_channels - 1];
1753  channel->pixel_type = current_pixel_type;
1754  channel->xsub = xsub;
1755  channel->ysub = ysub;
1756 
1757  if (current_pixel_type == EXR_HALF) {
1758  s->current_channel_offset += 2;
1759  } else {/* Float or UINT32 */
1760  s->current_channel_offset += 4;
1761  }
1762  }
1763 
1764  /* Check if all channels are set with an offset or if the channels
1765  * are causing an overflow */
1766  if (!s->is_luma) {/* if we expected to have at least 3 channels */
1767  if (FFMIN3(s->channel_offsets[0],
1768  s->channel_offsets[1],
1769  s->channel_offsets[2]) < 0) {
1770  if (s->channel_offsets[0] < 0)
1771  av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1772  if (s->channel_offsets[1] < 0)
1773  av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1774  if (s->channel_offsets[2] < 0)
1775  av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1777  goto fail;
1778  }
1779  }
1780 
1781  // skip one last byte and update main gb
1782  gb->buffer = ch_gb.buffer + 1;
1783  continue;
1784  } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1785  31)) >= 0) {
1786  int xmin, ymin, xmax, ymax;
1787  if (!var_size) {
1789  goto fail;
1790  }
1791 
1792  xmin = bytestream2_get_le32(gb);
1793  ymin = bytestream2_get_le32(gb);
1794  xmax = bytestream2_get_le32(gb);
1795  ymax = bytestream2_get_le32(gb);
1796 
1797  if (xmin > xmax || ymin > ymax ||
1798  (unsigned)xmax - xmin >= INT_MAX ||
1799  (unsigned)ymax - ymin >= INT_MAX) {
1801  goto fail;
1802  }
1803  s->xmin = xmin;
1804  s->xmax = xmax;
1805  s->ymin = ymin;
1806  s->ymax = ymax;
1807  s->xdelta = (s->xmax - s->xmin) + 1;
1808  s->ydelta = (s->ymax - s->ymin) + 1;
1809 
1810  continue;
1811  } else if ((var_size = check_header_variable(s, "displayWindow",
1812  "box2i", 34)) >= 0) {
1813  int32_t sx, sy, dx, dy;
1814 
1815  if (!var_size) {
1817  goto fail;
1818  }
1819 
1820  sx = bytestream2_get_le32(gb);
1821  sy = bytestream2_get_le32(gb);
1822  dx = bytestream2_get_le32(gb);
1823  dy = bytestream2_get_le32(gb);
1824 
1825  s->w = dx - sx + 1;
1826  s->h = dy - sy + 1;
1827 
1828  continue;
1829  } else if ((var_size = check_header_variable(s, "lineOrder",
1830  "lineOrder", 25)) >= 0) {
1831  int line_order;
1832  if (!var_size) {
1834  goto fail;
1835  }
1836 
1837  line_order = bytestream2_get_byte(gb);
1838  av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1839  if (line_order > 2) {
1840  av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1842  goto fail;
1843  }
1844 
1845  continue;
1846  } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1847  "float", 31)) >= 0) {
1848  if (!var_size) {
1850  goto fail;
1851  }
1852 
1853  s->sar = bytestream2_get_le32(gb);
1854 
1855  continue;
1856  } else if ((var_size = check_header_variable(s, "compression",
1857  "compression", 29)) >= 0) {
1858  if (!var_size) {
1860  goto fail;
1861  }
1862 
1863  if (s->compression == EXR_UNKN)
1864  s->compression = bytestream2_get_byte(gb);
1865  else {
1866  bytestream2_skip(gb, 1);
1867  av_log(s->avctx, AV_LOG_WARNING,
1868  "Found more than one compression attribute.\n");
1869  }
1870 
1871  continue;
1872  } else if ((var_size = check_header_variable(s, "tiles",
1873  "tiledesc", 22)) >= 0) {
1874  char tileLevel;
1875 
1876  if (!s->is_tile)
1877  av_log(s->avctx, AV_LOG_WARNING,
1878  "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1879 
1880  s->tile_attr.xSize = bytestream2_get_le32(gb);
1881  s->tile_attr.ySize = bytestream2_get_le32(gb);
1882 
1883  tileLevel = bytestream2_get_byte(gb);
1884  s->tile_attr.level_mode = tileLevel & 0x0f;
1885  s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1886 
1887  if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN) {
1888  avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
1889  s->tile_attr.level_mode);
1891  goto fail;
1892  }
1893 
1894  if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
1895  avpriv_report_missing_feature(s->avctx, "Tile level round %d",
1896  s->tile_attr.level_round);
1898  goto fail;
1899  }
1900 
1901  continue;
1902  } else if ((var_size = check_header_variable(s, "writer",
1903  "string", 1)) >= 0) {
1904  uint8_t key[256] = { 0 };
1905 
1906  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1907  av_dict_set(&metadata, "writer", key, 0);
1908 
1909  continue;
1910  } else if ((var_size = check_header_variable(s, "framesPerSecond",
1911  "rational", 33)) >= 0) {
1912  if (!var_size) {
1914  goto fail;
1915  }
1916 
1917  s->avctx->framerate.num = bytestream2_get_le32(gb);
1918  s->avctx->framerate.den = bytestream2_get_le32(gb);
1919 
1920  continue;
1921  } else if ((var_size = check_header_variable(s, "chunkCount",
1922  "int", 23)) >= 0) {
1923 
1924  s->chunk_count = bytestream2_get_le32(gb);
1925 
1926  continue;
1927  } else if ((var_size = check_header_variable(s, "type",
1928  "string", 16)) >= 0) {
1929  uint8_t key[256] = { 0 };
1930 
1931  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1932  if (strncmp("scanlineimage", key, var_size) &&
1933  strncmp("tiledimage", key, var_size))
1934  return AVERROR_PATCHWELCOME;
1935 
1936  continue;
1937  } else if ((var_size = check_header_variable(s, "preview",
1938  "preview", 16)) >= 0) {
1939  uint32_t pw = bytestream2_get_le32(gb);
1940  uint32_t ph = bytestream2_get_le32(gb);
1941  int64_t psize = 4LL * pw * ph;
1942 
1943  if (psize >= bytestream2_get_bytes_left(gb))
1944  return AVERROR_INVALIDDATA;
1945 
1946  bytestream2_skip(gb, psize);
1947 
1948  continue;
1949  }
1950 
1951  // Check if there are enough bytes for a header
1952  if (bytestream2_get_bytes_left(gb) <= 9) {
1953  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1955  goto fail;
1956  }
1957 
1958  // Process unknown variables
1959  {
1960  uint8_t name[256] = { 0 };
1961  uint8_t type[256] = { 0 };
1962  uint8_t value[256] = { 0 };
1963  int i = 0, size;
1964 
1965  while (bytestream2_get_bytes_left(gb) > 0 &&
1966  bytestream2_peek_byte(gb) && i < 255) {
1967  name[i++] = bytestream2_get_byte(gb);
1968  }
1969 
1970  bytestream2_skip(gb, 1);
1971  i = 0;
1972  while (bytestream2_get_bytes_left(gb) > 0 &&
1973  bytestream2_peek_byte(gb) && i < 255) {
1974  type[i++] = bytestream2_get_byte(gb);
1975  }
1976  bytestream2_skip(gb, 1);
1977  size = bytestream2_get_le32(gb);
1978 
1979  bytestream2_get_buffer(gb, value, FFMIN(sizeof(value) - 1, size));
1980  if (!strcmp(type, "string"))
1981  av_dict_set(&metadata, name, value, 0);
1982  }
1983  }
1984 
1985  if (s->compression == EXR_UNKN) {
1986  av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
1988  goto fail;
1989  }
1990 
1991  if (s->is_tile) {
1992  if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
1993  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
1995  goto fail;
1996  }
1997  }
1998 
1999  if (bytestream2_get_bytes_left(gb) <= 0) {
2000  av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
2002  goto fail;
2003  }
2004 
2005  frame->metadata = metadata;
2006 
2007  // aaand we are done
2008  bytestream2_skip(gb, 1);
2009  return 0;
2010 fail:
2011  av_dict_free(&metadata);
2012  return ret;
2013 }
2014 
2015 static int decode_frame(AVCodecContext *avctx, void *data,
2016  int *got_frame, AVPacket *avpkt)
2017 {
2018  EXRContext *s = avctx->priv_data;
2019  GetByteContext *gb = &s->gb;
2020  ThreadFrame frame = { .f = data };
2021  AVFrame *picture = data;
2022  uint8_t *ptr;
2023 
2024  int i, y, ret, ymax;
2025  int planes;
2026  int out_line_size;
2027  int nb_blocks; /* nb scanline or nb tile */
2028  uint64_t start_offset_table;
2029  uint64_t start_next_scanline;
2030  PutByteContext offset_table_writer;
2031 
2032  bytestream2_init(gb, avpkt->data, avpkt->size);
2033 
2034  if ((ret = decode_header(s, picture)) < 0)
2035  return ret;
2036 
2037  if ((s->compression == EXR_DWAA || s->compression == EXR_DWAB) &&
2038  s->pixel_type == EXR_HALF) {
2039  s->current_channel_offset *= 2;
2040  for (int i = 0; i < 4; i++)
2041  s->channel_offsets[i] *= 2;
2042  }
2043 
2044  switch (s->pixel_type) {
2045  case EXR_FLOAT:
2046  case EXR_HALF:
2047  if (s->channel_offsets[3] >= 0) {
2048  if (!s->is_luma) {
2049  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2050  } else {
2051  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
2052  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2053  }
2054  } else {
2055  if (!s->is_luma) {
2056  avctx->pix_fmt = AV_PIX_FMT_GBRPF32;
2057  } else {
2058  avctx->pix_fmt = AV_PIX_FMT_GRAYF32;
2059  }
2060  }
2061  break;
2062  case EXR_UINT:
2063  if (s->channel_offsets[3] >= 0) {
2064  if (!s->is_luma) {
2065  avctx->pix_fmt = AV_PIX_FMT_RGBA64;
2066  } else {
2067  avctx->pix_fmt = AV_PIX_FMT_YA16;
2068  }
2069  } else {
2070  if (!s->is_luma) {
2071  avctx->pix_fmt = AV_PIX_FMT_RGB48;
2072  } else {
2073  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
2074  }
2075  }
2076  break;
2077  default:
2078  av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
2079  return AVERROR_INVALIDDATA;
2080  }
2081 
2082  if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
2083  avctx->color_trc = s->apply_trc_type;
2084 
2085  switch (s->compression) {
2086  case EXR_RAW:
2087  case EXR_RLE:
2088  case EXR_ZIP1:
2089  s->scan_lines_per_block = 1;
2090  break;
2091  case EXR_PXR24:
2092  case EXR_ZIP16:
2093  s->scan_lines_per_block = 16;
2094  break;
2095  case EXR_PIZ:
2096  case EXR_B44:
2097  case EXR_B44A:
2098  case EXR_DWAA:
2099  s->scan_lines_per_block = 32;
2100  break;
2101  case EXR_DWAB:
2102  s->scan_lines_per_block = 256;
2103  break;
2104  default:
2105  avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
2106  return AVERROR_PATCHWELCOME;
2107  }
2108 
2109  /* Verify the xmin, xmax, ymin and ymax before setting the actual image size.
2110  * It's possible for the data window can larger or outside the display window */
2111  if (s->xmin > s->xmax || s->ymin > s->ymax ||
2112  s->ydelta == 0xFFFFFFFF || s->xdelta == 0xFFFFFFFF) {
2113  av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
2114  return AVERROR_INVALIDDATA;
2115  }
2116 
2117  if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
2118  return ret;
2119 
2120  ff_set_sar(s->avctx, av_d2q(av_int2float(s->sar), 255));
2121 
2122  s->desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2123  if (!s->desc)
2124  return AVERROR_INVALIDDATA;
2125 
2126  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
2127  planes = s->desc->nb_components;
2128  out_line_size = avctx->width * 4;
2129  } else {
2130  planes = 1;
2131  out_line_size = avctx->width * 2 * s->desc->nb_components;
2132  }
2133 
2134  if (s->is_tile) {
2135  nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
2136  ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
2137  } else { /* scanline */
2138  nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
2139  s->scan_lines_per_block;
2140  }
2141 
2142  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2143  return ret;
2144 
2145  if (bytestream2_get_bytes_left(gb)/8 < nb_blocks)
2146  return AVERROR_INVALIDDATA;
2147 
2148  // check offset table and recreate it if need
2149  if (!s->is_tile && bytestream2_peek_le64(gb) == 0) {
2150  av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
2151 
2152  start_offset_table = bytestream2_tell(gb);
2153  start_next_scanline = start_offset_table + nb_blocks * 8;
2154  bytestream2_init_writer(&offset_table_writer, &avpkt->data[start_offset_table], nb_blocks * 8);
2155 
2156  for (y = 0; y < nb_blocks; y++) {
2157  /* write offset of prev scanline in offset table */
2158  bytestream2_put_le64(&offset_table_writer, start_next_scanline);
2159 
2160  /* get len of next scanline */
2161  bytestream2_seek(gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
2162  start_next_scanline += (bytestream2_get_le32(gb) + 8);
2163  }
2164  bytestream2_seek(gb, start_offset_table, SEEK_SET);
2165  }
2166 
2167  // save pointer we are going to use in decode_block
2168  s->buf = avpkt->data;
2169  s->buf_size = avpkt->size;
2170 
2171  // Zero out the start if ymin is not 0
2172  for (i = 0; i < planes; i++) {
2173  ptr = picture->data[i];
2174  for (y = 0; y < FFMIN(s->ymin, s->h); y++) {
2175  memset(ptr, 0, out_line_size);
2176  ptr += picture->linesize[i];
2177  }
2178  }
2179 
2180  s->picture = picture;
2181 
2182  avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
2183 
2184  ymax = FFMAX(0, s->ymax + 1);
2185  // Zero out the end if ymax+1 is not h
2186  if (ymax < avctx->height)
2187  for (i = 0; i < planes; i++) {
2188  ptr = picture->data[i] + (ymax * picture->linesize[i]);
2189  for (y = ymax; y < avctx->height; y++) {
2190  memset(ptr, 0, out_line_size);
2191  ptr += picture->linesize[i];
2192  }
2193  }
2194 
2195  picture->pict_type = AV_PICTURE_TYPE_I;
2196  *got_frame = 1;
2197 
2198  return avpkt->size;
2199 }
2200 
2202 {
2203  EXRContext *s = avctx->priv_data;
2204  uint32_t i;
2205  union av_intfloat32 t;
2206  float one_gamma = 1.0f / s->gamma;
2207  avpriv_trc_function trc_func = NULL;
2208 
2209  half2float_table(s->mantissatable, s->exponenttable, s->offsettable);
2210 
2211  s->avctx = avctx;
2212 
2213  ff_exrdsp_init(&s->dsp);
2214 
2215 #if HAVE_BIGENDIAN
2216  ff_bswapdsp_init(&s->bbdsp);
2217 #endif
2218 
2219  trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
2220  if (trc_func) {
2221  for (i = 0; i < 65536; ++i) {
2222  t.i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2223  t.f = trc_func(t.f);
2224  s->gamma_table[i] = t;
2225  }
2226  } else {
2227  if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
2228  for (i = 0; i < 65536; ++i) {
2229  s->gamma_table[i].i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2230  }
2231  } else {
2232  for (i = 0; i < 65536; ++i) {
2233  t.i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2234  /* If negative value we reuse half value */
2235  if (t.f <= 0.0f) {
2236  s->gamma_table[i] = t;
2237  } else {
2238  t.f = powf(t.f, one_gamma);
2239  s->gamma_table[i] = t;
2240  }
2241  }
2242  }
2243  }
2244 
2245  // allocate thread data, used for non EXR_RAW compression types
2246  s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
2247  if (!s->thread_data)
2248  return AVERROR(ENOMEM);
2249 
2250  return 0;
2251 }
2252 
2254 {
2255  EXRContext *s = avctx->priv_data;
2256  int i;
2257  for (i = 0; i < avctx->thread_count; i++) {
2258  EXRThreadData *td = &s->thread_data[i];
2259  av_freep(&td->uncompressed_data);
2260  av_freep(&td->tmp);
2261  av_freep(&td->bitmap);
2262  av_freep(&td->lut);
2263  av_freep(&td->he);
2264  av_freep(&td->freq);
2265  av_freep(&td->ac_data);
2266  av_freep(&td->dc_data);
2267  av_freep(&td->rle_data);
2268  av_freep(&td->rle_raw_data);
2269  ff_free_vlc(&td->vlc);
2270  }
2271 
2272  av_freep(&s->thread_data);
2273  av_freep(&s->channels);
2274 
2275  return 0;
2276 }
2277 
2278 #define OFFSET(x) offsetof(EXRContext, x)
2279 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2280 static const AVOption options[] = {
2281  { "layer", "Set the decoding layer", OFFSET(layer),
2282  AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
2283  { "part", "Set the decoding part", OFFSET(selected_part),
2284  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
2285  { "gamma", "Set the float gamma value when decoding", OFFSET(gamma),
2286  AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD },
2287 
2288  // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
2289  { "apply_trc", "color transfer characteristics to apply to EXR linear input", OFFSET(apply_trc_type),
2290  AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD, "apply_trc_type"},
2291  { "bt709", "BT.709", 0,
2292  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2293  { "gamma", "gamma", 0,
2294  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2295  { "gamma22", "BT.470 M", 0,
2296  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2297  { "gamma28", "BT.470 BG", 0,
2298  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2299  { "smpte170m", "SMPTE 170 M", 0,
2300  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2301  { "smpte240m", "SMPTE 240 M", 0,
2302  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2303  { "linear", "Linear", 0,
2304  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2305  { "log", "Log", 0,
2306  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2307  { "log_sqrt", "Log square root", 0,
2308  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2309  { "iec61966_2_4", "IEC 61966-2-4", 0,
2310  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2311  { "bt1361", "BT.1361", 0,
2312  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2313  { "iec61966_2_1", "IEC 61966-2-1", 0,
2314  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2315  { "bt2020_10bit", "BT.2020 - 10 bit", 0,
2316  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2317  { "bt2020_12bit", "BT.2020 - 12 bit", 0,
2318  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2319  { "smpte2084", "SMPTE ST 2084", 0,
2320  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2321  { "smpte428_1", "SMPTE ST 428-1", 0,
2322  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2323 
2324  { NULL },
2325 };
2326 
2327 static const AVClass exr_class = {
2328  .class_name = "EXR",
2329  .item_name = av_default_item_name,
2330  .option = options,
2331  .version = LIBAVUTIL_VERSION_INT,
2332 };
2333 
2335  .name = "exr",
2336  .long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
2337  .type = AVMEDIA_TYPE_VIDEO,
2338  .id = AV_CODEC_ID_EXR,
2339  .priv_data_size = sizeof(EXRContext),
2340  .init = decode_init,
2341  .close = decode_end,
2342  .decode = decode_frame,
2343  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2345  .priv_class = &exr_class,
2346 };
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:187
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:849
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:2279
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:2541
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:1538
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:219
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:159
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:27
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:1059
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
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:2334
AVOption
AVOption.
Definition: opt.h:248
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:476
data
const char data[16]
Definition: mxf.c:142
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: exr.c:2201
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:2015
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:797
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:2280
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:659
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:379
rgb
Definition: rpzaenc.c:58
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:134
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:1546
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:61
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:76
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
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
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:2253
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
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:677
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:1508
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:202
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:420
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:1479
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:229
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:67
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:312
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:366
wav_decode
static void wav_decode(uint16_t *in, int nx, int ox, int ny, int oy, uint16_t mx)
Definition: exr.c:511
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
powf
#define powf(x, y)
Definition: libm.h:50
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h: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:306
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:192
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:228
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:2278
i
int i
Definition: input.c:407
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:674
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
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:72
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:99
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:501
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:225
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:82
planes
static const struct @322 planes[]
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:84
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
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:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
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:674
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:2327
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:229
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:234
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1617
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