FFmpeg  4.4.4
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 {
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 
116  int tmp_size;
117 
119  uint16_t *lut;
120 
122  unsigned ac_size;
123 
125  unsigned dc_size;
126 
128  unsigned rle_size;
129 
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 
155  enum ExrCompr compression;
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;
191  union av_intfloat32 gamma_table[65536];
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)) {
475  ret = AVERROR_INVALIDDATA;
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 
677  int compressed_size, int uncompressed_size,
678  EXRThreadData *td)
679 {
680  unsigned long dest_len, expected_len = 0;
681  const uint8_t *in = td->tmp;
682  uint8_t *out;
683  int c, i, j;
684 
685  for (i = 0; i < s->nb_channels; i++) {
686  if (s->channels[i].pixel_type == EXR_FLOAT) {
687  expected_len += (td->xsize * td->ysize * 3);/* PRX 24 store float in 24 bit instead of 32 */
688  } else if (s->channels[i].pixel_type == EXR_HALF) {
689  expected_len += (td->xsize * td->ysize * 2);
690  } else {//UINT 32
691  expected_len += (td->xsize * td->ysize * 4);
692  }
693  }
694 
695  dest_len = expected_len;
696 
697  if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK) {
698  return AVERROR_INVALIDDATA;
699  } else if (dest_len != expected_len) {
700  return AVERROR_INVALIDDATA;
701  }
702 
703  out = td->uncompressed_data;
704  for (i = 0; i < td->ysize; i++)
705  for (c = 0; c < s->nb_channels; c++) {
706  EXRChannel *channel = &s->channels[c];
707  const uint8_t *ptr[4];
708  uint32_t pixel = 0;
709 
710  switch (channel->pixel_type) {
711  case EXR_FLOAT:
712  ptr[0] = in;
713  ptr[1] = ptr[0] + td->xsize;
714  ptr[2] = ptr[1] + td->xsize;
715  in = ptr[2] + td->xsize;
716 
717  for (j = 0; j < td->xsize; ++j) {
718  uint32_t diff = ((unsigned)*(ptr[0]++) << 24) |
719  (*(ptr[1]++) << 16) |
720  (*(ptr[2]++) << 8);
721  pixel += diff;
722  bytestream_put_le32(&out, pixel);
723  }
724  break;
725  case EXR_HALF:
726  ptr[0] = in;
727  ptr[1] = ptr[0] + td->xsize;
728  in = ptr[1] + td->xsize;
729  for (j = 0; j < td->xsize; j++) {
730  uint32_t diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
731 
732  pixel += diff;
733  bytestream_put_le16(&out, pixel);
734  }
735  break;
736  case EXR_UINT:
737  ptr[0] = in;
738  ptr[1] = ptr[0] + s->xdelta;
739  ptr[2] = ptr[1] + s->xdelta;
740  ptr[3] = ptr[2] + s->xdelta;
741  in = ptr[3] + s->xdelta;
742 
743  for (j = 0; j < s->xdelta; ++j) {
744  uint32_t diff = ((uint32_t)*(ptr[0]++) << 24) |
745  (*(ptr[1]++) << 16) |
746  (*(ptr[2]++) << 8 ) |
747  (*(ptr[3]++));
748  pixel += diff;
749  bytestream_put_le32(&out, pixel);
750  }
751  break;
752  default:
753  return AVERROR_INVALIDDATA;
754  }
755  }
756 
757  return 0;
758 }
759 
760 static void unpack_14(const uint8_t b[14], uint16_t s[16])
761 {
762  unsigned short shift = (b[ 2] >> 2) & 15;
763  unsigned short bias = (0x20 << shift);
764  int i;
765 
766  s[ 0] = (b[0] << 8) | b[1];
767 
768  s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
769  s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
770  s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
771 
772  s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
773  s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
774  s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
775  s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
776 
777  s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
778  s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
779  s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
780  s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
781 
782  s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
783  s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
784  s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
785  s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
786 
787  for (i = 0; i < 16; ++i) {
788  if (s[i] & 0x8000)
789  s[i] &= 0x7fff;
790  else
791  s[i] = ~s[i];
792  }
793 }
794 
795 static void unpack_3(const uint8_t b[3], uint16_t s[16])
796 {
797  int i;
798 
799  s[0] = (b[0] << 8) | b[1];
800 
801  if (s[0] & 0x8000)
802  s[0] &= 0x7fff;
803  else
804  s[0] = ~s[0];
805 
806  for (i = 1; i < 16; i++)
807  s[i] = s[0];
808 }
809 
810 
811 static int b44_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
812  int uncompressed_size, EXRThreadData *td) {
813  const int8_t *sr = src;
814  int stay_to_uncompress = compressed_size;
815  int nb_b44_block_w, nb_b44_block_h;
816  int index_tl_x, index_tl_y, index_out, index_tmp;
817  uint16_t tmp_buffer[16]; /* B44 use 4x4 half float pixel */
818  int c, iY, iX, y, x;
819  int target_channel_offset = 0;
820 
821  /* calc B44 block count */
822  nb_b44_block_w = td->xsize / 4;
823  if ((td->xsize % 4) != 0)
824  nb_b44_block_w++;
825 
826  nb_b44_block_h = td->ysize / 4;
827  if ((td->ysize % 4) != 0)
828  nb_b44_block_h++;
829 
830  for (c = 0; c < s->nb_channels; c++) {
831  if (s->channels[c].pixel_type == EXR_HALF) {/* B44 only compress half float data */
832  for (iY = 0; iY < nb_b44_block_h; iY++) {
833  for (iX = 0; iX < nb_b44_block_w; iX++) {/* For each B44 block */
834  if (stay_to_uncompress < 3) {
835  av_log(s, AV_LOG_ERROR, "Not enough data for B44A block: %d", stay_to_uncompress);
836  return AVERROR_INVALIDDATA;
837  }
838 
839  if (src[compressed_size - stay_to_uncompress + 2] == 0xfc) { /* B44A block */
840  unpack_3(sr, tmp_buffer);
841  sr += 3;
842  stay_to_uncompress -= 3;
843  } else {/* B44 Block */
844  if (stay_to_uncompress < 14) {
845  av_log(s, AV_LOG_ERROR, "Not enough data for B44 block: %d", stay_to_uncompress);
846  return AVERROR_INVALIDDATA;
847  }
848  unpack_14(sr, tmp_buffer);
849  sr += 14;
850  stay_to_uncompress -= 14;
851  }
852 
853  /* copy data to uncompress buffer (B44 block can exceed target resolution)*/
854  index_tl_x = iX * 4;
855  index_tl_y = iY * 4;
856 
857  for (y = index_tl_y; y < FFMIN(index_tl_y + 4, td->ysize); y++) {
858  for (x = index_tl_x; x < FFMIN(index_tl_x + 4, td->xsize); x++) {
859  index_out = target_channel_offset * td->xsize + y * td->channel_line_size + 2 * x;
860  index_tmp = (y-index_tl_y) * 4 + (x-index_tl_x);
861  td->uncompressed_data[index_out] = tmp_buffer[index_tmp] & 0xff;
862  td->uncompressed_data[index_out + 1] = tmp_buffer[index_tmp] >> 8;
863  }
864  }
865  }
866  }
867  target_channel_offset += 2;
868  } else {/* Float or UINT 32 channel */
869  if (stay_to_uncompress < td->ysize * td->xsize * 4) {
870  av_log(s, AV_LOG_ERROR, "Not enough data for uncompress channel: %d", stay_to_uncompress);
871  return AVERROR_INVALIDDATA;
872  }
873 
874  for (y = 0; y < td->ysize; y++) {
875  index_out = target_channel_offset * td->xsize + y * td->channel_line_size;
876  memcpy(&td->uncompressed_data[index_out], sr, td->xsize * 4);
877  sr += td->xsize * 4;
878  }
879  target_channel_offset += 4;
880 
881  stay_to_uncompress -= td->ysize * td->xsize * 4;
882  }
883  }
884 
885  return 0;
886 }
887 
888 static int ac_uncompress(EXRContext *s, GetByteContext *gb, float *block)
889 {
890  int ret = 0, n = 1;
891 
892  while (n < 64) {
893  uint16_t val = bytestream2_get_ne16(gb);
894 
895  if (val == 0xff00) {
896  n = 64;
897  } else if ((val >> 8) == 0xff) {
898  n += val & 0xff;
899  } else {
900  ret = n;
902  s->mantissatable,
903  s->exponenttable,
904  s->offsettable));
905  n++;
906  }
907  }
908 
909  return ret;
910 }
911 
912 static void idct_1d(float *blk, int step)
913 {
914  const float a = .5f * cosf( M_PI / 4.f);
915  const float b = .5f * cosf( M_PI / 16.f);
916  const float c = .5f * cosf( M_PI / 8.f);
917  const float d = .5f * cosf(3.f*M_PI / 16.f);
918  const float e = .5f * cosf(5.f*M_PI / 16.f);
919  const float f = .5f * cosf(3.f*M_PI / 8.f);
920  const float g = .5f * cosf(7.f*M_PI / 16.f);
921 
922  float alpha[4], beta[4], theta[4], gamma[4];
923 
924  alpha[0] = c * blk[2 * step];
925  alpha[1] = f * blk[2 * step];
926  alpha[2] = c * blk[6 * step];
927  alpha[3] = f * blk[6 * step];
928 
929  beta[0] = b * blk[1 * step] + d * blk[3 * step] + e * blk[5 * step] + g * blk[7 * step];
930  beta[1] = d * blk[1 * step] - g * blk[3 * step] - b * blk[5 * step] - e * blk[7 * step];
931  beta[2] = e * blk[1 * step] - b * blk[3 * step] + g * blk[5 * step] + d * blk[7 * step];
932  beta[3] = g * blk[1 * step] - e * blk[3 * step] + d * blk[5 * step] - b * blk[7 * step];
933 
934  theta[0] = a * (blk[0 * step] + blk[4 * step]);
935  theta[3] = a * (blk[0 * step] - blk[4 * step]);
936 
937  theta[1] = alpha[0] + alpha[3];
938  theta[2] = alpha[1] - alpha[2];
939 
940  gamma[0] = theta[0] + theta[1];
941  gamma[1] = theta[3] + theta[2];
942  gamma[2] = theta[3] - theta[2];
943  gamma[3] = theta[0] - theta[1];
944 
945  blk[0 * step] = gamma[0] + beta[0];
946  blk[1 * step] = gamma[1] + beta[1];
947  blk[2 * step] = gamma[2] + beta[2];
948  blk[3 * step] = gamma[3] + beta[3];
949 
950  blk[4 * step] = gamma[3] - beta[3];
951  blk[5 * step] = gamma[2] - beta[2];
952  blk[6 * step] = gamma[1] - beta[1];
953  blk[7 * step] = gamma[0] - beta[0];
954 }
955 
956 static void dct_inverse(float *block)
957 {
958  for (int i = 0; i < 8; i++)
959  idct_1d(block + i, 8);
960 
961  for (int i = 0; i < 8; i++) {
962  idct_1d(block, 1);
963  block += 8;
964  }
965 }
966 
967 static void convert(float y, float u, float v,
968  float *b, float *g, float *r)
969 {
970  *r = y + 1.5747f * v;
971  *g = y - 0.1873f * u - 0.4682f * v;
972  *b = y + 1.8556f * u;
973 }
974 
975 static float to_linear(float x, float scale)
976 {
977  float ax = fabsf(x);
978 
979  if (ax <= 1.f) {
980  return FFSIGN(x) * powf(ax, 2.2f * scale);
981  } else {
982  const float log_base = expf(2.2f * scale);
983 
984  return FFSIGN(x) * powf(log_base, ax - 1.f);
985  }
986 }
987 
988 static int dwa_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
989  int uncompressed_size, EXRThreadData *td)
990 {
991  int64_t version, lo_usize, lo_size;
992  int64_t ac_size, dc_size, rle_usize, rle_csize, rle_raw_size;
993  int64_t ac_count, dc_count, ac_compression;
994  const int dc_w = td->xsize >> 3;
995  const int dc_h = td->ysize >> 3;
996  GetByteContext gb, agb;
997  int skip, ret;
998 
999  if (compressed_size <= 88)
1000  return AVERROR_INVALIDDATA;
1001 
1002  version = AV_RL64(src + 0);
1003  if (version != 2)
1004  return AVERROR_INVALIDDATA;
1005 
1006  lo_usize = AV_RL64(src + 8);
1007  lo_size = AV_RL64(src + 16);
1008  ac_size = AV_RL64(src + 24);
1009  dc_size = AV_RL64(src + 32);
1010  rle_csize = AV_RL64(src + 40);
1011  rle_usize = AV_RL64(src + 48);
1012  rle_raw_size = AV_RL64(src + 56);
1013  ac_count = AV_RL64(src + 64);
1014  dc_count = AV_RL64(src + 72);
1015  ac_compression = AV_RL64(src + 80);
1016 
1017  if ( compressed_size < (uint64_t)(lo_size | ac_size | dc_size | rle_csize) || compressed_size < 88LL + lo_size + ac_size + dc_size + rle_csize
1018  || ac_count > (uint64_t)INT_MAX/2
1019  )
1020  return AVERROR_INVALIDDATA;
1021 
1022  bytestream2_init(&gb, src + 88, compressed_size - 88);
1023  skip = bytestream2_get_le16(&gb);
1024  if (skip < 2)
1025  return AVERROR_INVALIDDATA;
1026 
1027  bytestream2_skip(&gb, skip - 2);
1028 
1029  if (lo_size > 0) {
1030  if (lo_usize > uncompressed_size)
1031  return AVERROR_INVALIDDATA;
1032  bytestream2_skip(&gb, lo_size);
1033  }
1034 
1035  if (ac_size > 0) {
1036  unsigned long dest_len;
1037  GetByteContext agb = gb;
1038 
1039  if (ac_count > 3LL * td->xsize * s->scan_lines_per_block)
1040  return AVERROR_INVALIDDATA;
1041 
1042  dest_len = ac_count * 2LL;
1043 
1044  av_fast_padded_malloc(&td->ac_data, &td->ac_size, dest_len);
1045  if (!td->ac_data)
1046  return AVERROR(ENOMEM);
1047 
1048  switch (ac_compression) {
1049  case 0:
1050  ret = huf_uncompress(s, td, &agb, (int16_t *)td->ac_data, ac_count);
1051  if (ret < 0)
1052  return ret;
1053  break;
1054  case 1:
1055  if (uncompress(td->ac_data, &dest_len, agb.buffer, ac_size) != Z_OK ||
1056  dest_len != ac_count * 2LL)
1057  return AVERROR_INVALIDDATA;
1058  break;
1059  default:
1060  return AVERROR_INVALIDDATA;
1061  }
1062 
1063  bytestream2_skip(&gb, ac_size);
1064  }
1065 
1066  {
1067  unsigned long dest_len;
1068  GetByteContext agb = gb;
1069 
1070  if (dc_count != dc_w * dc_h * 3)
1071  return AVERROR_INVALIDDATA;
1072 
1073  dest_len = dc_count * 2LL;
1074 
1075  av_fast_padded_malloc(&td->dc_data, &td->dc_size, FFALIGN(dest_len, 64) * 2);
1076  if (!td->dc_data)
1077  return AVERROR(ENOMEM);
1078 
1079  if (uncompress(td->dc_data + FFALIGN(dest_len, 64), &dest_len, agb.buffer, dc_size) != Z_OK ||
1080  (dest_len != dc_count * 2LL))
1081  return AVERROR_INVALIDDATA;
1082 
1083  s->dsp.predictor(td->dc_data + FFALIGN(dest_len, 64), dest_len);
1084  s->dsp.reorder_pixels(td->dc_data, td->dc_data + FFALIGN(dest_len, 64), dest_len);
1085 
1086  bytestream2_skip(&gb, dc_size);
1087  }
1088 
1089  if (rle_raw_size > 0 && rle_csize > 0 && rle_usize > 0) {
1090  unsigned long dest_len = rle_usize;
1091 
1092  av_fast_padded_malloc(&td->rle_data, &td->rle_size, rle_usize);
1093  if (!td->rle_data)
1094  return AVERROR(ENOMEM);
1095 
1096  av_fast_padded_malloc(&td->rle_raw_data, &td->rle_raw_size, rle_raw_size);
1097  if (!td->rle_raw_data)
1098  return AVERROR(ENOMEM);
1099 
1100  if (uncompress(td->rle_data, &dest_len, gb.buffer, rle_csize) != Z_OK ||
1101  (dest_len != rle_usize))
1102  return AVERROR_INVALIDDATA;
1103 
1104  ret = rle(td->rle_raw_data, td->rle_data, rle_usize, rle_raw_size);
1105  if (ret < 0)
1106  return ret;
1107  bytestream2_skip(&gb, rle_csize);
1108  }
1109 
1110  bytestream2_init(&agb, td->ac_data, ac_count * 2);
1111 
1112  for (int y = 0; y < td->ysize; y += 8) {
1113  for (int x = 0; x < td->xsize; x += 8) {
1114  memset(td->block, 0, sizeof(td->block));
1115 
1116  for (int j = 0; j < 3; j++) {
1117  float *block = td->block[j];
1118  const int idx = (x >> 3) + (y >> 3) * dc_w + dc_w * dc_h * j;
1119  uint16_t *dc = (uint16_t *)td->dc_data;
1120  union av_intfloat32 dc_val;
1121 
1122  dc_val.i = half2float(dc[idx], s->mantissatable,
1123  s->exponenttable, s->offsettable);
1124 
1125  block[0] = dc_val.f;
1126  ac_uncompress(s, &agb, block);
1127  dct_inverse(block);
1128  }
1129 
1130  {
1131  const float scale = s->pixel_type == EXR_FLOAT ? 2.f : 1.f;
1132  const int o = s->nb_channels == 4;
1133  float *bo = ((float *)td->uncompressed_data) +
1134  y * td->xsize * s->nb_channels + td->xsize * (o + 0) + x;
1135  float *go = ((float *)td->uncompressed_data) +
1136  y * td->xsize * s->nb_channels + td->xsize * (o + 1) + x;
1137  float *ro = ((float *)td->uncompressed_data) +
1138  y * td->xsize * s->nb_channels + td->xsize * (o + 2) + x;
1139  float *yb = td->block[0];
1140  float *ub = td->block[1];
1141  float *vb = td->block[2];
1142 
1143  for (int yy = 0; yy < 8; yy++) {
1144  for (int xx = 0; xx < 8; xx++) {
1145  const int idx = xx + yy * 8;
1146 
1147  convert(yb[idx], ub[idx], vb[idx], &bo[xx], &go[xx], &ro[xx]);
1148 
1149  bo[xx] = to_linear(bo[xx], scale);
1150  go[xx] = to_linear(go[xx], scale);
1151  ro[xx] = to_linear(ro[xx], scale);
1152  }
1153 
1154  bo += td->xsize * s->nb_channels;
1155  go += td->xsize * s->nb_channels;
1156  ro += td->xsize * s->nb_channels;
1157  }
1158  }
1159  }
1160  }
1161 
1162  if (s->nb_channels < 4)
1163  return 0;
1164 
1165  for (int y = 0; y < td->ysize && td->rle_raw_data; y++) {
1166  uint32_t *ao = ((uint32_t *)td->uncompressed_data) + y * td->xsize * s->nb_channels;
1167  uint8_t *ai0 = td->rle_raw_data + y * td->xsize;
1168  uint8_t *ai1 = td->rle_raw_data + y * td->xsize + rle_raw_size / 2;
1169 
1170  for (int x = 0; x < td->xsize; x++) {
1171  uint16_t ha = ai0[x] | (ai1[x] << 8);
1172 
1173  ao[x] = half2float(ha, s->mantissatable, s->exponenttable, s->offsettable);
1174  }
1175  }
1176 
1177  return 0;
1178 }
1179 
1180 static int decode_block(AVCodecContext *avctx, void *tdata,
1181  int jobnr, int threadnr)
1182 {
1183  EXRContext *s = avctx->priv_data;
1184  AVFrame *const p = s->picture;
1185  EXRThreadData *td = &s->thread_data[threadnr];
1186  const uint8_t *channel_buffer[4] = { 0 };
1187  const uint8_t *buf = s->buf;
1188  uint64_t line_offset, uncompressed_size;
1189  uint8_t *ptr;
1190  uint32_t data_size;
1191  int line, col = 0;
1192  uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
1193  const uint8_t *src;
1194  int step = s->desc->flags & AV_PIX_FMT_FLAG_FLOAT ? 4 : 2 * s->desc->nb_components;
1195  int bxmin = 0, axmax = 0, window_xoffset = 0;
1196  int window_xmin, window_xmax, window_ymin, window_ymax;
1197  int data_xoffset, data_yoffset, data_window_offset, xsize, ysize;
1198  int i, x, buf_size = s->buf_size;
1199  int c, rgb_channel_count;
1200  float one_gamma = 1.0f / s->gamma;
1201  avpriv_trc_function trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
1202  int ret;
1203 
1204  line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
1205 
1206  if (s->is_tile) {
1207  if (buf_size < 20 || line_offset > buf_size - 20)
1208  return AVERROR_INVALIDDATA;
1209 
1210  src = buf + line_offset + 20;
1211  if (s->is_multipart)
1212  src += 4;
1213 
1214  tile_x = AV_RL32(src - 20);
1215  tile_y = AV_RL32(src - 16);
1216  tile_level_x = AV_RL32(src - 12);
1217  tile_level_y = AV_RL32(src - 8);
1218 
1219  data_size = AV_RL32(src - 4);
1220  if (data_size <= 0 || data_size > buf_size - line_offset - 20)
1221  return AVERROR_INVALIDDATA;
1222 
1223  if (tile_level_x || tile_level_y) { /* tile level, is not the full res level */
1224  avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
1225  return AVERROR_PATCHWELCOME;
1226  }
1227 
1228  if (tile_x && s->tile_attr.xSize + (int64_t)FFMAX(s->xmin, 0) >= INT_MAX / tile_x )
1229  return AVERROR_INVALIDDATA;
1230  if (tile_y && s->tile_attr.ySize + (int64_t)FFMAX(s->ymin, 0) >= INT_MAX / tile_y )
1231  return AVERROR_INVALIDDATA;
1232 
1233  line = s->ymin + s->tile_attr.ySize * tile_y;
1234  col = s->tile_attr.xSize * tile_x;
1235 
1236  if (line < s->ymin || line > s->ymax ||
1237  s->xmin + col < s->xmin || s->xmin + col > s->xmax)
1238  return AVERROR_INVALIDDATA;
1239 
1240  td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tile_y * s->tile_attr.ySize);
1241  td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tile_x * s->tile_attr.xSize);
1242 
1243  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1244  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1245  return AVERROR_INVALIDDATA;
1246 
1247  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1248  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1249  } else {
1250  if (buf_size < 8 || line_offset > buf_size - 8)
1251  return AVERROR_INVALIDDATA;
1252 
1253  src = buf + line_offset + 8;
1254  if (s->is_multipart)
1255  src += 4;
1256  line = AV_RL32(src - 8);
1257 
1258  if (line < s->ymin || line > s->ymax)
1259  return AVERROR_INVALIDDATA;
1260 
1261  data_size = AV_RL32(src - 4);
1262  if (data_size <= 0 || data_size > buf_size - line_offset - 8)
1263  return AVERROR_INVALIDDATA;
1264 
1265  td->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1); /* s->ydelta - line ?? */
1266  td->xsize = s->xdelta;
1267 
1268  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1269  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1270  return AVERROR_INVALIDDATA;
1271 
1272  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1273  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1274 
1275  if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
1276  line_offset > buf_size - uncompressed_size)) ||
1277  (s->compression != EXR_RAW && (data_size > uncompressed_size ||
1278  line_offset > buf_size - data_size))) {
1279  return AVERROR_INVALIDDATA;
1280  }
1281  }
1282 
1283  window_xmin = FFMIN(avctx->width, FFMAX(0, s->xmin + col));
1284  window_xmax = FFMIN(avctx->width, FFMAX(0, s->xmin + col + td->xsize));
1285  window_ymin = FFMIN(avctx->height, FFMAX(0, line ));
1286  window_ymax = FFMIN(avctx->height, FFMAX(0, line + td->ysize));
1287  xsize = window_xmax - window_xmin;
1288  ysize = window_ymax - window_ymin;
1289 
1290  /* tile or scanline not visible skip decoding */
1291  if (xsize <= 0 || ysize <= 0)
1292  return 0;
1293 
1294  /* is the first tile or is a scanline */
1295  if(col == 0) {
1296  window_xmin = 0;
1297  /* pixels to add at the left of the display window */
1298  window_xoffset = FFMAX(0, s->xmin);
1299  /* bytes to add at the left of the display window */
1300  bxmin = window_xoffset * step;
1301  }
1302 
1303  /* is the last tile or is a scanline */
1304  if(col + td->xsize == s->xdelta) {
1305  window_xmax = avctx->width;
1306  /* bytes to add at the right of the display window */
1307  axmax = FFMAX(0, (avctx->width - (s->xmax + 1))) * step;
1308  }
1309 
1310  if (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
1311  av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
1312  if (!td->tmp)
1313  return AVERROR(ENOMEM);
1314  }
1315 
1316  if (data_size < uncompressed_size) {
1317  av_fast_padded_malloc(&td->uncompressed_data,
1318  &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
1319 
1320  if (!td->uncompressed_data)
1321  return AVERROR(ENOMEM);
1322 
1323  ret = AVERROR_INVALIDDATA;
1324  switch (s->compression) {
1325  case EXR_ZIP1:
1326  case EXR_ZIP16:
1327  ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
1328  break;
1329  case EXR_PIZ:
1330  ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
1331  break;
1332  case EXR_PXR24:
1333  ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
1334  break;
1335  case EXR_RLE:
1336  ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
1337  break;
1338  case EXR_B44:
1339  case EXR_B44A:
1340  ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
1341  break;
1342  case EXR_DWAA:
1343  case EXR_DWAB:
1344  ret = dwa_uncompress(s, src, data_size, uncompressed_size, td);
1345  break;
1346  }
1347  if (ret < 0) {
1348  av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
1349  return ret;
1350  }
1351  src = td->uncompressed_data;
1352  }
1353 
1354  /* offsets to crop data outside display window */
1355  data_xoffset = FFABS(FFMIN(0, s->xmin + col)) * (s->pixel_type == EXR_HALF ? 2 : 4);
1356  data_yoffset = FFABS(FFMIN(0, line));
1357  data_window_offset = (data_yoffset * td->channel_line_size) + data_xoffset;
1358 
1359  if (!s->is_luma) {
1360  channel_buffer[0] = src + (td->xsize * s->channel_offsets[0]) + data_window_offset;
1361  channel_buffer[1] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1362  channel_buffer[2] = src + (td->xsize * s->channel_offsets[2]) + data_window_offset;
1363  rgb_channel_count = 3;
1364  } else { /* put y data in the first channel_buffer */
1365  channel_buffer[0] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1366  rgb_channel_count = 1;
1367  }
1368  if (s->channel_offsets[3] >= 0)
1369  channel_buffer[3] = src + (td->xsize * s->channel_offsets[3]) + data_window_offset;
1370 
1371  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
1372  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
1373  int channel_count = s->channel_offsets[3] >= 0 ? 4 : rgb_channel_count;
1374  if (s->is_luma) {
1375  channel_buffer[1] = channel_buffer[0];
1376  channel_buffer[2] = channel_buffer[0];
1377  }
1378 
1379  for (c = 0; c < channel_count; c++) {
1380  int plane = s->desc->comp[c].plane;
1381  ptr = p->data[plane] + window_ymin * p->linesize[plane] + (window_xmin * 4);
1382 
1383  for (i = 0; i < ysize; i++, ptr += p->linesize[plane]) {
1384  const uint8_t *src;
1385  union av_intfloat32 *ptr_x;
1386 
1387  src = channel_buffer[c];
1388  ptr_x = (union av_intfloat32 *)ptr;
1389 
1390  // Zero out the start if xmin is not 0
1391  memset(ptr_x, 0, bxmin);
1392  ptr_x += window_xoffset;
1393 
1394  if (s->pixel_type == EXR_FLOAT ||
1395  s->compression == EXR_DWAA ||
1396  s->compression == EXR_DWAB) {
1397  // 32-bit
1398  union av_intfloat32 t;
1399  if (trc_func && c < 3) {
1400  for (x = 0; x < xsize; x++) {
1401  t.i = bytestream_get_le32(&src);
1402  t.f = trc_func(t.f);
1403  *ptr_x++ = t;
1404  }
1405  } else if (one_gamma != 1.f) {
1406  for (x = 0; x < xsize; x++) {
1407  t.i = bytestream_get_le32(&src);
1408  if (t.f > 0.0f && c < 3) /* avoid negative values */
1409  t.f = powf(t.f, one_gamma);
1410  *ptr_x++ = t;
1411  }
1412  } else {
1413  for (x = 0; x < xsize; x++) {
1414  t.i = bytestream_get_le32(&src);
1415  *ptr_x++ = t;
1416  }
1417  }
1418  } else if (s->pixel_type == EXR_HALF) {
1419  // 16-bit
1420  if (c < 3 || !trc_func) {
1421  for (x = 0; x < xsize; x++) {
1422  *ptr_x++ = s->gamma_table[bytestream_get_le16(&src)];
1423  }
1424  } else {
1425  for (x = 0; x < xsize; x++) {
1426  ptr_x[0].i = half2float(bytestream_get_le16(&src),
1427  s->mantissatable,
1428  s->exponenttable,
1429  s->offsettable);
1430  ptr_x++;
1431  }
1432  }
1433  }
1434 
1435  // Zero out the end if xmax+1 is not w
1436  memset(ptr_x, 0, axmax);
1437  channel_buffer[c] += td->channel_line_size;
1438  }
1439  }
1440  } else {
1441 
1442  av_assert1(s->pixel_type == EXR_UINT);
1443  ptr = p->data[0] + window_ymin * p->linesize[0] + (window_xmin * s->desc->nb_components * 2);
1444 
1445  for (i = 0; i < ysize; i++, ptr += p->linesize[0]) {
1446 
1447  const uint8_t * a;
1448  const uint8_t *rgb[3];
1449  uint16_t *ptr_x;
1450 
1451  for (c = 0; c < rgb_channel_count; c++) {
1452  rgb[c] = channel_buffer[c];
1453  }
1454 
1455  if (channel_buffer[3])
1456  a = channel_buffer[3];
1457 
1458  ptr_x = (uint16_t *) ptr;
1459 
1460  // Zero out the start if xmin is not 0
1461  memset(ptr_x, 0, bxmin);
1462  ptr_x += window_xoffset * s->desc->nb_components;
1463 
1464  for (x = 0; x < xsize; x++) {
1465  for (c = 0; c < rgb_channel_count; c++) {
1466  *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
1467  }
1468 
1469  if (channel_buffer[3])
1470  *ptr_x++ = bytestream_get_le32(&a) >> 16;
1471  }
1472 
1473  // Zero out the end if xmax+1 is not w
1474  memset(ptr_x, 0, axmax);
1475 
1476  channel_buffer[0] += td->channel_line_size;
1477  channel_buffer[1] += td->channel_line_size;
1478  channel_buffer[2] += td->channel_line_size;
1479  if (channel_buffer[3])
1480  channel_buffer[3] += td->channel_line_size;
1481  }
1482  }
1483 
1484  return 0;
1485 }
1486 
1488 {
1489  GetByteContext *gb = &s->gb;
1490 
1491  while (bytestream2_get_bytes_left(gb) > 0) {
1492  if (!bytestream2_peek_byte(gb))
1493  break;
1494 
1495  // Process unknown variables
1496  for (int i = 0; i < 2; i++) // value_name and value_type
1497  while (bytestream2_get_byte(gb) != 0);
1498 
1499  // Skip variable length
1500  bytestream2_skip(gb, bytestream2_get_le32(gb));
1501  }
1502 }
1503 
1504 /**
1505  * Check if the variable name corresponds to its data type.
1506  *
1507  * @param s the EXRContext
1508  * @param value_name name of the variable to check
1509  * @param value_type type of the variable to check
1510  * @param minimum_length minimum length of the variable data
1511  *
1512  * @return bytes to read containing variable data
1513  * -1 if variable is not found
1514  * 0 if buffer ended prematurely
1515  */
1517  const char *value_name,
1518  const char *value_type,
1519  unsigned int minimum_length)
1520 {
1521  GetByteContext *gb = &s->gb;
1522  int var_size = -1;
1523 
1524  if (bytestream2_get_bytes_left(gb) >= minimum_length &&
1525  !strcmp(gb->buffer, value_name)) {
1526  // found value_name, jump to value_type (null terminated strings)
1527  gb->buffer += strlen(value_name) + 1;
1528  if (!strcmp(gb->buffer, value_type)) {
1529  gb->buffer += strlen(value_type) + 1;
1530  var_size = bytestream2_get_le32(gb);
1531  // don't go read past boundaries
1532  if (var_size > bytestream2_get_bytes_left(gb))
1533  var_size = 0;
1534  } else {
1535  // value_type not found, reset the buffer
1536  gb->buffer -= strlen(value_name) + 1;
1537  av_log(s->avctx, AV_LOG_WARNING,
1538  "Unknown data type %s for header variable %s.\n",
1539  value_type, value_name);
1540  }
1541  }
1542 
1543  return var_size;
1544 }
1545 
1547 {
1548  AVDictionary *metadata = NULL;
1549  GetByteContext *gb = &s->gb;
1550  int magic_number, version, flags;
1551  int layer_match = 0;
1552  int ret;
1553  int dup_channels = 0;
1554 
1555  s->current_channel_offset = 0;
1556  s->xmin = ~0;
1557  s->xmax = ~0;
1558  s->ymin = ~0;
1559  s->ymax = ~0;
1560  s->xdelta = ~0;
1561  s->ydelta = ~0;
1562  s->channel_offsets[0] = -1;
1563  s->channel_offsets[1] = -1;
1564  s->channel_offsets[2] = -1;
1565  s->channel_offsets[3] = -1;
1566  s->pixel_type = EXR_UNKNOWN;
1567  s->compression = EXR_UNKN;
1568  s->nb_channels = 0;
1569  s->w = 0;
1570  s->h = 0;
1571  s->tile_attr.xSize = -1;
1572  s->tile_attr.ySize = -1;
1573  s->is_tile = 0;
1574  s->is_multipart = 0;
1575  s->is_luma = 0;
1576  s->current_part = 0;
1577 
1578  if (bytestream2_get_bytes_left(gb) < 10) {
1579  av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
1580  return AVERROR_INVALIDDATA;
1581  }
1582 
1583  magic_number = bytestream2_get_le32(gb);
1584  if (magic_number != 20000630) {
1585  /* As per documentation of OpenEXR, it is supposed to be
1586  * int 20000630 little-endian */
1587  av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
1588  return AVERROR_INVALIDDATA;
1589  }
1590 
1591  version = bytestream2_get_byte(gb);
1592  if (version != 2) {
1593  avpriv_report_missing_feature(s->avctx, "Version %d", version);
1594  return AVERROR_PATCHWELCOME;
1595  }
1596 
1597  flags = bytestream2_get_le24(gb);
1598 
1599  if (flags & 0x02)
1600  s->is_tile = 1;
1601  if (flags & 0x10)
1602  s->is_multipart = 1;
1603  if (flags & 0x08) {
1604  avpriv_report_missing_feature(s->avctx, "deep data");
1605  return AVERROR_PATCHWELCOME;
1606  }
1607 
1608  // Parse the header
1609  while (bytestream2_get_bytes_left(gb) > 0) {
1610  int var_size;
1611 
1612  while (s->is_multipart && s->current_part < s->selected_part &&
1613  bytestream2_get_bytes_left(gb) > 0) {
1614  if (bytestream2_peek_byte(gb)) {
1616  } else {
1617  bytestream2_skip(gb, 1);
1618  if (!bytestream2_peek_byte(gb))
1619  break;
1620  }
1621  bytestream2_skip(gb, 1);
1622  s->current_part++;
1623  }
1624 
1625  if (!bytestream2_peek_byte(gb)) {
1626  if (!s->is_multipart)
1627  break;
1628  bytestream2_skip(gb, 1);
1629  if (s->current_part == s->selected_part) {
1630  while (bytestream2_get_bytes_left(gb) > 0) {
1631  if (bytestream2_peek_byte(gb)) {
1633  } else {
1634  bytestream2_skip(gb, 1);
1635  if (!bytestream2_peek_byte(gb))
1636  break;
1637  }
1638  }
1639  }
1640  if (!bytestream2_peek_byte(gb))
1641  break;
1642  s->current_part++;
1643  }
1644 
1645  if ((var_size = check_header_variable(s, "channels",
1646  "chlist", 38)) >= 0) {
1647  GetByteContext ch_gb;
1648  if (!var_size) {
1649  ret = AVERROR_INVALIDDATA;
1650  goto fail;
1651  }
1652 
1653  bytestream2_init(&ch_gb, gb->buffer, var_size);
1654 
1655  while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
1657  enum ExrPixelType current_pixel_type;
1658  int channel_index = -1;
1659  int xsub, ysub;
1660 
1661  if (strcmp(s->layer, "") != 0) {
1662  if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
1663  layer_match = 1;
1664  av_log(s->avctx, AV_LOG_INFO,
1665  "Channel match layer : %s.\n", ch_gb.buffer);
1666  ch_gb.buffer += strlen(s->layer);
1667  if (*ch_gb.buffer == '.')
1668  ch_gb.buffer++; /* skip dot if not given */
1669  } else {
1670  layer_match = 0;
1671  av_log(s->avctx, AV_LOG_INFO,
1672  "Channel doesn't match layer : %s.\n", ch_gb.buffer);
1673  }
1674  } else {
1675  layer_match = 1;
1676  }
1677 
1678  if (layer_match) { /* only search channel if the layer match is valid */
1679  if (!av_strcasecmp(ch_gb.buffer, "R") ||
1680  !av_strcasecmp(ch_gb.buffer, "X") ||
1681  !av_strcasecmp(ch_gb.buffer, "U")) {
1682  channel_index = 0;
1683  s->is_luma = 0;
1684  } else if (!av_strcasecmp(ch_gb.buffer, "G") ||
1685  !av_strcasecmp(ch_gb.buffer, "V")) {
1686  channel_index = 1;
1687  s->is_luma = 0;
1688  } else if (!av_strcasecmp(ch_gb.buffer, "Y")) {
1689  channel_index = 1;
1690  s->is_luma = 1;
1691  } else if (!av_strcasecmp(ch_gb.buffer, "B") ||
1692  !av_strcasecmp(ch_gb.buffer, "Z") ||
1693  !av_strcasecmp(ch_gb.buffer, "W")) {
1694  channel_index = 2;
1695  s->is_luma = 0;
1696  } else if (!av_strcasecmp(ch_gb.buffer, "A")) {
1697  channel_index = 3;
1698  } else {
1699  av_log(s->avctx, AV_LOG_WARNING,
1700  "Unsupported channel %.256s.\n", ch_gb.buffer);
1701  }
1702  }
1703 
1704  /* skip until you get a 0 */
1705  while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1706  bytestream2_get_byte(&ch_gb))
1707  continue;
1708 
1709  if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1710  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1711  ret = AVERROR_INVALIDDATA;
1712  goto fail;
1713  }
1714 
1715  current_pixel_type = bytestream2_get_le32(&ch_gb);
1716  if (current_pixel_type >= EXR_UNKNOWN) {
1717  avpriv_report_missing_feature(s->avctx, "Pixel type %d",
1718  current_pixel_type);
1719  ret = AVERROR_PATCHWELCOME;
1720  goto fail;
1721  }
1722 
1723  bytestream2_skip(&ch_gb, 4);
1724  xsub = bytestream2_get_le32(&ch_gb);
1725  ysub = bytestream2_get_le32(&ch_gb);
1726 
1727  if (xsub != 1 || ysub != 1) {
1729  "Subsampling %dx%d",
1730  xsub, ysub);
1731  ret = AVERROR_PATCHWELCOME;
1732  goto fail;
1733  }
1734 
1735  if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
1736  if (s->pixel_type != EXR_UNKNOWN &&
1737  s->pixel_type != current_pixel_type) {
1738  av_log(s->avctx, AV_LOG_ERROR,
1739  "RGB channels not of the same depth.\n");
1740  ret = AVERROR_INVALIDDATA;
1741  goto fail;
1742  }
1743  s->pixel_type = current_pixel_type;
1744  s->channel_offsets[channel_index] = s->current_channel_offset;
1745  } else if (channel_index >= 0) {
1746  av_log(s->avctx, AV_LOG_WARNING,
1747  "Multiple channels with index %d.\n", channel_index);
1748  if (++dup_channels > 10) {
1749  ret = AVERROR_INVALIDDATA;
1750  goto fail;
1751  }
1752  }
1753 
1754  s->channels = av_realloc(s->channels,
1755  ++s->nb_channels * sizeof(EXRChannel));
1756  if (!s->channels) {
1757  ret = AVERROR(ENOMEM);
1758  goto fail;
1759  }
1760  channel = &s->channels[s->nb_channels - 1];
1761  channel->pixel_type = current_pixel_type;
1762  channel->xsub = xsub;
1763  channel->ysub = ysub;
1764 
1765  if (current_pixel_type == EXR_HALF) {
1766  s->current_channel_offset += 2;
1767  } else {/* Float or UINT32 */
1768  s->current_channel_offset += 4;
1769  }
1770  }
1771 
1772  /* Check if all channels are set with an offset or if the channels
1773  * are causing an overflow */
1774  if (!s->is_luma) {/* if we expected to have at least 3 channels */
1775  if (FFMIN3(s->channel_offsets[0],
1776  s->channel_offsets[1],
1777  s->channel_offsets[2]) < 0) {
1778  if (s->channel_offsets[0] < 0)
1779  av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1780  if (s->channel_offsets[1] < 0)
1781  av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1782  if (s->channel_offsets[2] < 0)
1783  av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1784  ret = AVERROR_INVALIDDATA;
1785  goto fail;
1786  }
1787  }
1788 
1789  // skip one last byte and update main gb
1790  gb->buffer = ch_gb.buffer + 1;
1791  continue;
1792  } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1793  31)) >= 0) {
1794  int xmin, ymin, xmax, ymax;
1795  if (!var_size) {
1796  ret = AVERROR_INVALIDDATA;
1797  goto fail;
1798  }
1799 
1800  xmin = bytestream2_get_le32(gb);
1801  ymin = bytestream2_get_le32(gb);
1802  xmax = bytestream2_get_le32(gb);
1803  ymax = bytestream2_get_le32(gb);
1804 
1805  if (xmin > xmax || ymin > ymax ||
1806  ymax == INT_MAX || xmax == INT_MAX ||
1807  (unsigned)xmax - xmin >= INT_MAX ||
1808  (unsigned)ymax - ymin >= INT_MAX) {
1809  ret = AVERROR_INVALIDDATA;
1810  goto fail;
1811  }
1812  s->xmin = xmin;
1813  s->xmax = xmax;
1814  s->ymin = ymin;
1815  s->ymax = ymax;
1816  s->xdelta = (s->xmax - s->xmin) + 1;
1817  s->ydelta = (s->ymax - s->ymin) + 1;
1818 
1819  continue;
1820  } else if ((var_size = check_header_variable(s, "displayWindow",
1821  "box2i", 34)) >= 0) {
1822  int32_t sx, sy, dx, dy;
1823 
1824  if (!var_size) {
1825  ret = AVERROR_INVALIDDATA;
1826  goto fail;
1827  }
1828 
1829  sx = bytestream2_get_le32(gb);
1830  sy = bytestream2_get_le32(gb);
1831  dx = bytestream2_get_le32(gb);
1832  dy = bytestream2_get_le32(gb);
1833 
1834  s->w = (unsigned)dx - sx + 1;
1835  s->h = (unsigned)dy - sy + 1;
1836 
1837  continue;
1838  } else if ((var_size = check_header_variable(s, "lineOrder",
1839  "lineOrder", 25)) >= 0) {
1840  int line_order;
1841  if (!var_size) {
1842  ret = AVERROR_INVALIDDATA;
1843  goto fail;
1844  }
1845 
1846  line_order = bytestream2_get_byte(gb);
1847  av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1848  if (line_order > 2) {
1849  av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1850  ret = AVERROR_INVALIDDATA;
1851  goto fail;
1852  }
1853 
1854  continue;
1855  } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1856  "float", 31)) >= 0) {
1857  if (!var_size) {
1858  ret = AVERROR_INVALIDDATA;
1859  goto fail;
1860  }
1861 
1862  s->sar = bytestream2_get_le32(gb);
1863 
1864  continue;
1865  } else if ((var_size = check_header_variable(s, "compression",
1866  "compression", 29)) >= 0) {
1867  if (!var_size) {
1868  ret = AVERROR_INVALIDDATA;
1869  goto fail;
1870  }
1871 
1872  if (s->compression == EXR_UNKN)
1873  s->compression = bytestream2_get_byte(gb);
1874  else {
1875  bytestream2_skip(gb, 1);
1876  av_log(s->avctx, AV_LOG_WARNING,
1877  "Found more than one compression attribute.\n");
1878  }
1879 
1880  continue;
1881  } else if ((var_size = check_header_variable(s, "tiles",
1882  "tiledesc", 22)) >= 0) {
1883  char tileLevel;
1884 
1885  if (!s->is_tile)
1886  av_log(s->avctx, AV_LOG_WARNING,
1887  "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1888 
1889  s->tile_attr.xSize = bytestream2_get_le32(gb);
1890  s->tile_attr.ySize = bytestream2_get_le32(gb);
1891 
1892  tileLevel = bytestream2_get_byte(gb);
1893  s->tile_attr.level_mode = tileLevel & 0x0f;
1894  s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1895 
1896  if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN) {
1897  avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
1898  s->tile_attr.level_mode);
1899  ret = AVERROR_PATCHWELCOME;
1900  goto fail;
1901  }
1902 
1903  if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
1904  avpriv_report_missing_feature(s->avctx, "Tile level round %d",
1905  s->tile_attr.level_round);
1906  ret = AVERROR_PATCHWELCOME;
1907  goto fail;
1908  }
1909 
1910  continue;
1911  } else if ((var_size = check_header_variable(s, "writer",
1912  "string", 1)) >= 0) {
1913  uint8_t key[256] = { 0 };
1914 
1915  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1916  av_dict_set(&metadata, "writer", key, 0);
1917 
1918  continue;
1919  } else if ((var_size = check_header_variable(s, "framesPerSecond",
1920  "rational", 33)) >= 0) {
1921  if (!var_size) {
1922  ret = AVERROR_INVALIDDATA;
1923  goto fail;
1924  }
1925 
1926  s->avctx->framerate.num = bytestream2_get_le32(gb);
1927  s->avctx->framerate.den = bytestream2_get_le32(gb);
1928 
1929  continue;
1930  } else if ((var_size = check_header_variable(s, "chunkCount",
1931  "int", 23)) >= 0) {
1932 
1933  s->chunk_count = bytestream2_get_le32(gb);
1934 
1935  continue;
1936  } else if ((var_size = check_header_variable(s, "type",
1937  "string", 16)) >= 0) {
1938  uint8_t key[256] = { 0 };
1939 
1940  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1941  if (strncmp("scanlineimage", key, var_size) &&
1942  strncmp("tiledimage", key, var_size))
1943  return AVERROR_PATCHWELCOME;
1944 
1945  continue;
1946  } else if ((var_size = check_header_variable(s, "preview",
1947  "preview", 16)) >= 0) {
1948  uint32_t pw = bytestream2_get_le32(gb);
1949  uint32_t ph = bytestream2_get_le32(gb);
1950  uint64_t psize = pw * ph;
1951  if (psize > INT64_MAX / 4)
1952  return AVERROR_INVALIDDATA;
1953  psize *= 4;
1954 
1955  if ((int64_t)psize >= bytestream2_get_bytes_left(gb))
1956  return AVERROR_INVALIDDATA;
1957 
1958  bytestream2_skip(gb, psize);
1959 
1960  continue;
1961  }
1962 
1963  // Check if there are enough bytes for a header
1964  if (bytestream2_get_bytes_left(gb) <= 9) {
1965  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1966  ret = AVERROR_INVALIDDATA;
1967  goto fail;
1968  }
1969 
1970  // Process unknown variables
1971  {
1972  uint8_t name[256] = { 0 };
1973  uint8_t type[256] = { 0 };
1974  uint8_t value[256] = { 0 };
1975  int i = 0, size;
1976 
1977  while (bytestream2_get_bytes_left(gb) > 0 &&
1978  bytestream2_peek_byte(gb) && i < 255) {
1979  name[i++] = bytestream2_get_byte(gb);
1980  }
1981 
1982  bytestream2_skip(gb, 1);
1983  i = 0;
1984  while (bytestream2_get_bytes_left(gb) > 0 &&
1985  bytestream2_peek_byte(gb) && i < 255) {
1986  type[i++] = bytestream2_get_byte(gb);
1987  }
1988  bytestream2_skip(gb, 1);
1989  size = bytestream2_get_le32(gb);
1990 
1991  bytestream2_get_buffer(gb, value, FFMIN(sizeof(value) - 1, size));
1992  if (!strcmp(type, "string"))
1993  av_dict_set(&metadata, name, value, 0);
1994  }
1995  }
1996 
1997  if (s->compression == EXR_UNKN) {
1998  av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
1999  ret = AVERROR_INVALIDDATA;
2000  goto fail;
2001  }
2002 
2003  if (s->is_tile) {
2004  if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
2005  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
2006  ret = AVERROR_INVALIDDATA;
2007  goto fail;
2008  }
2009  }
2010 
2011  if (bytestream2_get_bytes_left(gb) <= 0) {
2012  av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
2013  ret = AVERROR_INVALIDDATA;
2014  goto fail;
2015  }
2016 
2017  frame->metadata = metadata;
2018 
2019  // aaand we are done
2020  bytestream2_skip(gb, 1);
2021  return 0;
2022 fail:
2023  av_dict_free(&metadata);
2024  return ret;
2025 }
2026 
2027 static int decode_frame(AVCodecContext *avctx, void *data,
2028  int *got_frame, AVPacket *avpkt)
2029 {
2030  EXRContext *s = avctx->priv_data;
2031  GetByteContext *gb = &s->gb;
2032  ThreadFrame frame = { .f = data };
2033  AVFrame *picture = data;
2034  uint8_t *ptr;
2035 
2036  int i, y, ret, ymax;
2037  int planes;
2038  int out_line_size;
2039  int nb_blocks; /* nb scanline or nb tile */
2040  uint64_t start_offset_table;
2041  uint64_t start_next_scanline;
2042  PutByteContext offset_table_writer;
2043 
2044  bytestream2_init(gb, avpkt->data, avpkt->size);
2045 
2046  if ((ret = decode_header(s, picture)) < 0)
2047  return ret;
2048 
2049  if ((s->compression == EXR_DWAA || s->compression == EXR_DWAB) &&
2050  s->pixel_type == EXR_HALF) {
2051  s->current_channel_offset *= 2;
2052  for (int i = 0; i < 4; i++)
2053  s->channel_offsets[i] *= 2;
2054  }
2055 
2056  switch (s->pixel_type) {
2057  case EXR_FLOAT:
2058  case EXR_HALF:
2059  if (s->channel_offsets[3] >= 0) {
2060  if (!s->is_luma) {
2061  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2062  } else {
2063  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
2064  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2065  }
2066  } else {
2067  if (!s->is_luma) {
2068  avctx->pix_fmt = AV_PIX_FMT_GBRPF32;
2069  } else {
2070  avctx->pix_fmt = AV_PIX_FMT_GRAYF32;
2071  }
2072  }
2073  break;
2074  case EXR_UINT:
2075  if (s->channel_offsets[3] >= 0) {
2076  if (!s->is_luma) {
2077  avctx->pix_fmt = AV_PIX_FMT_RGBA64;
2078  } else {
2079  avctx->pix_fmt = AV_PIX_FMT_YA16;
2080  }
2081  } else {
2082  if (!s->is_luma) {
2083  avctx->pix_fmt = AV_PIX_FMT_RGB48;
2084  } else {
2085  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
2086  }
2087  }
2088  break;
2089  default:
2090  av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
2091  return AVERROR_INVALIDDATA;
2092  }
2093 
2094  if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
2095  avctx->color_trc = s->apply_trc_type;
2096 
2097  switch (s->compression) {
2098  case EXR_RAW:
2099  case EXR_RLE:
2100  case EXR_ZIP1:
2101  s->scan_lines_per_block = 1;
2102  break;
2103  case EXR_PXR24:
2104  case EXR_ZIP16:
2105  s->scan_lines_per_block = 16;
2106  break;
2107  case EXR_PIZ:
2108  case EXR_B44:
2109  case EXR_B44A:
2110  case EXR_DWAA:
2111  s->scan_lines_per_block = 32;
2112  break;
2113  case EXR_DWAB:
2114  s->scan_lines_per_block = 256;
2115  break;
2116  default:
2117  avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
2118  return AVERROR_PATCHWELCOME;
2119  }
2120 
2121  /* Verify the xmin, xmax, ymin and ymax before setting the actual image size.
2122  * It's possible for the data window can larger or outside the display window */
2123  if (s->xmin > s->xmax || s->ymin > s->ymax ||
2124  s->ydelta == 0xFFFFFFFF || s->xdelta == 0xFFFFFFFF) {
2125  av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
2126  return AVERROR_INVALIDDATA;
2127  }
2128 
2129  if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
2130  return ret;
2131 
2132  ff_set_sar(s->avctx, av_d2q(av_int2float(s->sar), 255));
2133 
2134  s->desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2135  if (!s->desc)
2136  return AVERROR_INVALIDDATA;
2137 
2138  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
2139  planes = s->desc->nb_components;
2140  out_line_size = avctx->width * 4;
2141  } else {
2142  planes = 1;
2143  out_line_size = avctx->width * 2 * s->desc->nb_components;
2144  }
2145 
2146  if (s->is_tile) {
2147  nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
2148  ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
2149  } else { /* scanline */
2150  nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
2151  s->scan_lines_per_block;
2152  }
2153 
2154  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2155  return ret;
2156 
2157  if (bytestream2_get_bytes_left(gb)/8 < nb_blocks)
2158  return AVERROR_INVALIDDATA;
2159 
2160  // check offset table and recreate it if need
2161  if (!s->is_tile && bytestream2_peek_le64(gb) == 0) {
2162  av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
2163 
2164  start_offset_table = bytestream2_tell(gb);
2165  start_next_scanline = start_offset_table + nb_blocks * 8;
2166  bytestream2_init_writer(&offset_table_writer, &avpkt->data[start_offset_table], nb_blocks * 8);
2167 
2168  for (y = 0; y < nb_blocks; y++) {
2169  /* write offset of prev scanline in offset table */
2170  bytestream2_put_le64(&offset_table_writer, start_next_scanline);
2171 
2172  /* get len of next scanline */
2173  bytestream2_seek(gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
2174  start_next_scanline += (bytestream2_get_le32(gb) + 8);
2175  }
2176  bytestream2_seek(gb, start_offset_table, SEEK_SET);
2177  }
2178 
2179  // save pointer we are going to use in decode_block
2180  s->buf = avpkt->data;
2181  s->buf_size = avpkt->size;
2182 
2183  // Zero out the start if ymin is not 0
2184  for (i = 0; i < planes; i++) {
2185  ptr = picture->data[i];
2186  for (y = 0; y < FFMIN(s->ymin, s->h); y++) {
2187  memset(ptr, 0, out_line_size);
2188  ptr += picture->linesize[i];
2189  }
2190  }
2191 
2192  s->picture = picture;
2193 
2194  avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
2195 
2196  ymax = FFMAX(0, s->ymax + 1);
2197  // Zero out the end if ymax+1 is not h
2198  if (ymax < avctx->height)
2199  for (i = 0; i < planes; i++) {
2200  ptr = picture->data[i] + (ymax * picture->linesize[i]);
2201  for (y = ymax; y < avctx->height; y++) {
2202  memset(ptr, 0, out_line_size);
2203  ptr += picture->linesize[i];
2204  }
2205  }
2206 
2207  picture->pict_type = AV_PICTURE_TYPE_I;
2208  *got_frame = 1;
2209 
2210  return avpkt->size;
2211 }
2212 
2214 {
2215  EXRContext *s = avctx->priv_data;
2216  uint32_t i;
2217  union av_intfloat32 t;
2218  float one_gamma = 1.0f / s->gamma;
2219  avpriv_trc_function trc_func = NULL;
2220 
2221  half2float_table(s->mantissatable, s->exponenttable, s->offsettable);
2222 
2223  s->avctx = avctx;
2224 
2225  ff_exrdsp_init(&s->dsp);
2226 
2227 #if HAVE_BIGENDIAN
2228  ff_bswapdsp_init(&s->bbdsp);
2229 #endif
2230 
2231  trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
2232  if (trc_func) {
2233  for (i = 0; i < 65536; ++i) {
2234  t.i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2235  t.f = trc_func(t.f);
2236  s->gamma_table[i] = t;
2237  }
2238  } else {
2239  if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
2240  for (i = 0; i < 65536; ++i) {
2241  s->gamma_table[i].i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2242  }
2243  } else {
2244  for (i = 0; i < 65536; ++i) {
2245  t.i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2246  /* If negative value we reuse half value */
2247  if (t.f <= 0.0f) {
2248  s->gamma_table[i] = t;
2249  } else {
2250  t.f = powf(t.f, one_gamma);
2251  s->gamma_table[i] = t;
2252  }
2253  }
2254  }
2255  }
2256 
2257  // allocate thread data, used for non EXR_RAW compression types
2258  s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
2259  if (!s->thread_data)
2260  return AVERROR_INVALIDDATA;
2261 
2262  return 0;
2263 }
2264 
2266 {
2267  EXRContext *s = avctx->priv_data;
2268  int i;
2269  for (i = 0; i < avctx->thread_count; i++) {
2270  EXRThreadData *td = &s->thread_data[i];
2271  av_freep(&td->uncompressed_data);
2272  av_freep(&td->tmp);
2273  av_freep(&td->bitmap);
2274  av_freep(&td->lut);
2275  av_freep(&td->he);
2276  av_freep(&td->freq);
2277  av_freep(&td->ac_data);
2278  av_freep(&td->dc_data);
2279  av_freep(&td->rle_data);
2280  av_freep(&td->rle_raw_data);
2281  ff_free_vlc(&td->vlc);
2282  }
2283 
2284  av_freep(&s->thread_data);
2285  av_freep(&s->channels);
2286 
2287  return 0;
2288 }
2289 
2290 #define OFFSET(x) offsetof(EXRContext, x)
2291 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2292 static const AVOption options[] = {
2293  { "layer", "Set the decoding layer", OFFSET(layer),
2294  AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
2295  { "part", "Set the decoding part", OFFSET(selected_part),
2296  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
2297  { "gamma", "Set the float gamma value when decoding", OFFSET(gamma),
2298  AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD },
2299 
2300  // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
2301  { "apply_trc", "color transfer characteristics to apply to EXR linear input", OFFSET(apply_trc_type),
2302  AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD, "apply_trc_type"},
2303  { "bt709", "BT.709", 0,
2304  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2305  { "gamma", "gamma", 0,
2306  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2307  { "gamma22", "BT.470 M", 0,
2308  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2309  { "gamma28", "BT.470 BG", 0,
2310  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2311  { "smpte170m", "SMPTE 170 M", 0,
2312  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2313  { "smpte240m", "SMPTE 240 M", 0,
2314  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2315  { "linear", "Linear", 0,
2316  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2317  { "log", "Log", 0,
2318  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2319  { "log_sqrt", "Log square root", 0,
2320  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2321  { "iec61966_2_4", "IEC 61966-2-4", 0,
2322  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2323  { "bt1361", "BT.1361", 0,
2324  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2325  { "iec61966_2_1", "IEC 61966-2-1", 0,
2326  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2327  { "bt2020_10bit", "BT.2020 - 10 bit", 0,
2328  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2329  { "bt2020_12bit", "BT.2020 - 12 bit", 0,
2330  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2331  { "smpte2084", "SMPTE ST 2084", 0,
2332  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2333  { "smpte428_1", "SMPTE ST 428-1", 0,
2334  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2335 
2336  { NULL },
2337 };
2338 
2339 static const AVClass exr_class = {
2340  .class_name = "EXR",
2341  .item_name = av_default_item_name,
2342  .option = options,
2343  .version = LIBAVUTIL_VERSION_INT,
2344 };
2345 
2347  .name = "exr",
2348  .long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
2349  .type = AVMEDIA_TYPE_VIDEO,
2350  .id = AV_CODEC_ID_EXR,
2351  .priv_data_size = sizeof(EXRContext),
2352  .init = decode_init,
2353  .close = decode_end,
2354  .decode = decode_frame,
2355  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2357  .priv_class = &exr_class,
2358 };
static double val(void *priv, double ch)
Definition: aeval.c:76
#define av_cold
Definition: attributes.h:88
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
uint8_t
int32_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
Libavcodec external API header.
#define AV_RL64
Definition: intreadwrite.h:173
#define AV_RL32
Definition: intreadwrite.h:146
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:323
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
#define bytestream2_get_ne16
Definition: bytestream.h:119
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
#define ub(width, name)
Definition: cbs_h2645.c:266
#define s(width, name)
Definition: cbs_vp9.c:257
#define f(width, name)
Definition: cbs_vp9.c:255
#define fail()
Definition: checkasm.h:133
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
double(* avpriv_trc_function)(double)
Definition: color_utils.h:40
common internal and external API header
#define FFMIN(a, b)
Definition: common.h:105
#define FFMAX(a, b)
Definition: common.h:103
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define FFSIGN(a)
Definition: common.h:73
#define FFMIN3(a, b, c)
Definition: common.h:106
#define NULL
Definition: coverity.c:32
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
double value
Definition: eval.c:98
ExrCompr
Definition: exr.c:59
@ EXR_UNKN
Definition: exr.c:70
@ EXR_B44A
Definition: exr.c:67
@ EXR_DWAB
Definition: exr.c:69
@ EXR_ZIP16
Definition: exr.c:63
@ EXR_DWAA
Definition: exr.c:68
@ EXR_PIZ
Definition: exr.c:64
@ EXR_RLE
Definition: exr.c:61
@ EXR_B44
Definition: exr.c:66
@ EXR_PXR24
Definition: exr.c:65
@ EXR_ZIP1
Definition: exr.c:62
@ EXR_RAW
Definition: exr.c:60
static void idct_1d(float *blk, int step)
Definition: exr.c:912
static int huf_unpack_enc_table(GetByteContext *gb, int32_t im, int32_t iM, uint64_t *freq)
Definition: exr.c:327
ExrTileLevelMode
Definition: exr.c:80
@ EXR_TILE_LEVEL_UNKNOWN
Definition: exr.c:84
@ EXR_TILE_LEVEL_ONE
Definition: exr.c:81
@ EXR_TILE_LEVEL_MIPMAP
Definition: exr.c:82
@ EXR_TILE_LEVEL_RIPMAP
Definition: exr.c:83
static int huf_build_dec_table(EXRContext *s, EXRThreadData *td, int im, int iM)
Definition: exr.c:367
static void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:501
#define USHORT_RANGE
Definition: exr.c:270
static const AVOption options[]
Definition: exr.c:2292
#define MOD_MASK
Definition: exr.c:499
AVCodec ff_exr_decoder
Definition: exr.c:2346
static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
Definition: exr.c:273
#define LONG_ZEROCODE_RUN
Definition: exr.c:323
static float to_linear(float x, float scale)
Definition: exr.c:975
#define SHORT_ZEROCODE_RUN
Definition: exr.c:322
static av_cold int decode_init(AVCodecContext *avctx)
Definition: exr.c:2213
static const AVClass exr_class
Definition: exr.c:2339
static int decode_header(EXRContext *s, AVFrame *frame)
Definition: exr.c:1546
static int dwa_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:988
#define HUF_ENCSIZE
Definition: exr.c:297
static int b44_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:811
static void unpack_14(const uint8_t b[14], uint16_t s[16])
Definition: exr.c:760
static av_cold int decode_end(AVCodecContext *avctx)
Definition: exr.c:2265
static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize, int dsize, EXRThreadData *td)
Definition: exr.c:590
static int zip_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:198
ExrTileLevelRound
Definition: exr.c:87
@ EXR_TILE_ROUND_DOWN
Definition: exr.c:89
@ EXR_TILE_ROUND_UP
Definition: exr.c:88
@ EXR_TILE_ROUND_UNKNOWN
Definition: exr.c:90
static void skip_header_chunk(EXRContext *s)
Definition: exr.c:1487
static void dct_inverse(float *block)
Definition: exr.c:956
ExrPixelType
Definition: exr.c:73
@ EXR_UINT
Definition: exr.c:74
@ EXR_HALF
Definition: exr.c:75
@ EXR_UNKNOWN
Definition: exr.c:77
@ EXR_FLOAT
Definition: exr.c:76
static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
Definition: exr.c:288
static int huf_decode(VLC *vlc, GetByteContext *gb, int nbits, int run_sym, int no, uint16_t *out)
Definition: exr.c:413
static void convert(float y, float u, float v, float *b, float *g, float *r)
Definition: exr.c:967
#define BITMAP_SIZE
Definition: exr.c:271
static void unpack_3(const uint8_t b[3], uint16_t s[16])
Definition: exr.c:795
#define VD
Definition: exr.c:2291
static void huf_canonical_code_table(uint64_t *freq)
Definition: exr.c:299
#define SHORTEST_LONG_RUN
Definition: exr.c:324
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: exr.c:2027
static int huf_uncompress(EXRContext *s, EXRThreadData *td, GetByteContext *gb, uint16_t *dst, int dst_size)
Definition: exr.c:442
static int ac_uncompress(EXRContext *s, GetByteContext *gb, float *block)
Definition: exr.c:888
#define OFFSET(x)
Definition: exr.c:2290
static void wav_decode(uint16_t *in, int nx, int ox, int ny, int oy, uint16_t mx)
Definition: exr.c:511
static int rle_uncompress(EXRContext *ctx, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:257
#define A_OFFSET
Definition: exr.c:498
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:1516
static void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:484
static int decode_block(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
Definition: exr.c:1180
static int pxr24_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:676
static int rle(uint8_t *dst, const uint8_t *src, int compressed_size, int uncompressed_size)
Definition: exr.c:215
float im
Definition: fft.c:82
bitstream reader API header.
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
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_EXR
Definition: codec_id.h:229
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
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
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
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:288
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
for(j=16;j >0;--j)
static void half2float_table(uint32_t *mantissatable, uint32_t *exponenttable, uint16_t *offsettable)
Definition: half2float.h:40
static uint32_t half2float(uint16_t h, uint32_t *mantissatable, uint32_t *exponenttable, uint16_t *offsettable)
Definition: half2float.h:64
cl_device_type type
const char * key
static const int16_t alpha[]
Definition: ilbcdata.h:55
misc image utilities
int i
Definition: input.c:407
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
av_cold void ff_exrdsp_init(ExrDSPContext *c)
Definition: exrdsp.c:49
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
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
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
version
Definition: libkvazaar.c:326
#define cosf(x)
Definition: libm.h:78
#define expf(x)
Definition: libm.h:283
#define powf(x, y)
Definition: libm.h:50
static const struct @322 planes[]
#define FFALIGN(x, a)
Definition: macros.h:48
#define M_PI
Definition: mathematics.h:52
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
const char data[16]
Definition: mxf.c:142
AVOptions.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:190
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:428
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:384
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:389
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:385
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:431
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:483
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:490
@ AVCOL_TRC_SMPTEST428_1
Definition: pixfmt.h:503
@ AVCOL_TRC_SMPTEST2084
Definition: pixfmt.h:501
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:488
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:496
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:491
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
Definition: pixfmt.h:493
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:495
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:492
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:489
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
Definition: pixfmt.h:494
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:499
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:497
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
Definition: pixfmt.h:498
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:486
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:485
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:505
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:429
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
const char * name
Definition: qsvenc.c:46
#define td
Definition: regdef.h:70
#define blk(i)
Definition: sha.c:185
static int shift(int a, int b)
Definition: sonic.c:82
Describe the class of an AVClass context structure.
Definition: log.h:67
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
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1773
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
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:1844
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
AVDictionary * metadata
metadata.
Definition: frame.h:604
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
Definition: exr.c:99
int xsub
Definition: exr.c:100
int ysub
Definition: exr.c:100
enum ExrPixelType pixel_type
Definition: exr.c:101
int h
Definition: exr.c:160
int32_t xmin
Definition: exr.c:162
GetByteContext gb
Definition: exr.c:175
enum AVColorTransferCharacteristic apply_trc_type
Definition: exr.c:189
uint32_t xdelta
Definition: exr.c:164
int32_t ymin
Definition: exr.c:163
uint32_t sar
Definition: exr.c:161
const char * layer
Definition: exr.c:186
int is_luma
Definition: exr.c:173
float gamma
Definition: exr.c:190
int scan_lines_per_block
Definition: exr.c:166
EXRTileAttribute tile_attr
Definition: exr.c:168
int current_channel_offset
Definition: exr.c:181
uint32_t ydelta
Definition: exr.c:164
EXRThreadData * thread_data
Definition: exr.c:184
int selected_part
Definition: exr.c:187
uint32_t exponenttable[64]
Definition: exr.c:194
ExrDSPContext dsp
Definition: exr.c:149
int32_t ymax
Definition: exr.c:163
int nb_channels
Definition: exr.c:180
AVFrame * picture
Definition: exr.c:147
int current_part
Definition: exr.c:171
int w
Definition: exr.c:160
AVCodecContext * avctx
Definition: exr.c:148
uint16_t offsettable[64]
Definition: exr.c:195
int channel_offsets[4]
Definition: exr.c:157
int is_tile
Definition: exr.c:169
enum ExrCompr compression
Definition: exr.c:155
int is_multipart
Definition: exr.c:170
union av_intfloat32 gamma_table[65536]
Definition: exr.c:191
uint32_t chunk_count
Definition: exr.c:182
int32_t xmax
Definition: exr.c:162
int buf_size
Definition: exr.c:177
enum ExrPixelType pixel_type
Definition: exr.c:156
EXRChannel * channels
Definition: exr.c:179
uint32_t mantissatable[2048]
Definition: exr.c:193
const AVPixFmtDescriptor * desc
Definition: exr.c:158
const uint8_t * buf
Definition: exr.c:176
int tmp_size
Definition: exr.c:116
uint8_t * dc_data
Definition: exr.c:124
unsigned rle_size
Definition: exr.c:128
int run_sym
Definition: exr.c:139
uint8_t * ac_data
Definition: exr.c:121
HuffEntry * he
Definition: exr.c:140
uint16_t * lut
Definition: exr.c:119
uint8_t * rle_data
Definition: exr.c:127
uint8_t * rle_raw_data
Definition: exr.c:130
unsigned dc_size
Definition: exr.c:125
uint64_t * freq
Definition: exr.c:141
int channel_line_size
Definition: exr.c:137
uint8_t * bitmap
Definition: exr.c:118
unsigned ac_size
Definition: exr.c:122
unsigned rle_raw_size
Definition: exr.c:131
int uncompressed_size
Definition: exr.c:113
int xsize
Definition: exr.c:135
float block[3][64]
Definition: exr.c:133
uint8_t * uncompressed_data
Definition: exr.c:112
int ysize
Definition: exr.c:135
uint8_t * tmp
Definition: exr.c:115
VLC vlc
Definition: exr.c:142
int32_t ySize
Definition: exr.c:106
enum ExrTileLevelRound level_round
Definition: exr.c:108
enum ExrTileLevelMode level_mode
Definition: exr.c:107
int32_t xSize
Definition: exr.c:105
const uint8_t * buffer
Definition: bytestream.h:34
Definition: exr.c:93
uint8_t len
Definition: exr.c:94
uint32_t code
Definition: exr.c:96
uint16_t sym
Definition: exr.c:95
Definition: vlc.h:26
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
Definition: graph2dot.c:48
Definition: rpzaenc.c:58
uint8_t run
Definition: svq3.c:205
#define av_malloc_array(a, b)
#define avpriv_request_sample(...)
#define av_freep(p)
#define av_malloc(s)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
#define src
Definition: vp8dsp.c:255
static int16_t block[64]
Definition: dct.c:116
FILE * out
Definition: movenc.c:54
AVFormatContext * ctx
Definition: movenc.c:48
#define height
uint8_t pixel
Definition: tiny_ssim.c:42
int size
uint32_t i
Definition: intfloat.h:28
const char * b
Definition: vf_curves.c:118
const char * g
Definition: vf_curves.c:117
const char * r
Definition: vf_curves.c:116
if(ret< 0)
Definition: vf_mcdeint.c:282
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static double c[64]