FFmpeg  4.4.6
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  int l;
337  if (get_bits_left(&gbit) < 6)
338  return AVERROR_INVALIDDATA;
339  l = freq[im] = get_bits(&gbit, 6);
340 
341  if (l == LONG_ZEROCODE_RUN) {
342  int zerun = get_bits(&gbit, 8) + SHORTEST_LONG_RUN;
343 
344  if (im + zerun > iM + 1)
345  return AVERROR_INVALIDDATA;
346 
347  while (zerun--)
348  freq[im++] = 0;
349 
350  im--;
351  } else if (l >= SHORT_ZEROCODE_RUN) {
352  int zerun = l - SHORT_ZEROCODE_RUN + 2;
353 
354  if (im + zerun > iM + 1)
355  return AVERROR_INVALIDDATA;
356 
357  while (zerun--)
358  freq[im++] = 0;
359 
360  im--;
361  }
362  }
363 
364  bytestream2_skip(gb, (get_bits_count(&gbit) + 7) / 8);
366 
367  return 0;
368 }
369 
371  EXRThreadData *td, int im, int iM)
372 {
373  int j = 0;
374 
375  td->run_sym = -1;
376  for (int i = im; i < iM; i++) {
377  td->he[j].sym = i;
378  td->he[j].len = td->freq[i] & 63;
379  td->he[j].code = td->freq[i] >> 6;
380  if (td->he[j].len > 32) {
381  avpriv_request_sample(s->avctx, "Too big code length");
382  return AVERROR_PATCHWELCOME;
383  }
384  if (td->he[j].len > 0)
385  j++;
386  else
387  td->run_sym = i;
388  }
389 
390  if (im > 0)
391  td->run_sym = 0;
392  else if (iM < 65535)
393  td->run_sym = 65535;
394 
395  if (td->run_sym == -1) {
396  avpriv_request_sample(s->avctx, "No place for run symbol");
397  return AVERROR_PATCHWELCOME;
398  }
399 
400  td->he[j].sym = td->run_sym;
401  td->he[j].len = td->freq[iM] & 63;
402  if (td->he[j].len > 32) {
403  avpriv_request_sample(s->avctx, "Too big code length");
404  return AVERROR_PATCHWELCOME;
405  }
406  td->he[j].code = td->freq[iM] >> 6;
407  j++;
408 
409  ff_free_vlc(&td->vlc);
410  return ff_init_vlc_sparse(&td->vlc, 12, j,
411  &td->he[0].len, sizeof(td->he[0]), sizeof(td->he[0].len),
412  &td->he[0].code, sizeof(td->he[0]), sizeof(td->he[0].code),
413  &td->he[0].sym, sizeof(td->he[0]), sizeof(td->he[0].sym), 0);
414 }
415 
416 static int huf_decode(VLC *vlc, GetByteContext *gb, int nbits, int run_sym,
417  int no, uint16_t *out)
418 {
419  GetBitContext gbit;
420  int oe = 0;
421 
422  init_get_bits(&gbit, gb->buffer, nbits);
423  while (get_bits_left(&gbit) > 0 && oe < no) {
424  uint16_t x = get_vlc2(&gbit, vlc->table, 12, 3);
425 
426  if (x == run_sym) {
427  int run = get_bits(&gbit, 8);
428  uint16_t fill;
429 
430  if (oe == 0 || oe + run > no)
431  return AVERROR_INVALIDDATA;
432 
433  fill = out[oe - 1];
434 
435  while (run-- > 0)
436  out[oe++] = fill;
437  } else {
438  out[oe++] = x;
439  }
440  }
441 
442  return 0;
443 }
444 
446  EXRThreadData *td,
447  GetByteContext *gb,
448  uint16_t *dst, int dst_size)
449 {
450  int32_t im, iM;
451  uint32_t nBits;
452  int ret;
453 
454  im = bytestream2_get_le32(gb);
455  iM = bytestream2_get_le32(gb);
456  bytestream2_skip(gb, 4);
457  nBits = bytestream2_get_le32(gb);
458  if (im < 0 || im >= HUF_ENCSIZE ||
459  iM < 0 || iM >= HUF_ENCSIZE)
460  return AVERROR_INVALIDDATA;
461 
462  bytestream2_skip(gb, 4);
463 
464  if (!td->freq)
465  td->freq = av_malloc_array(HUF_ENCSIZE, sizeof(*td->freq));
466  if (!td->he)
467  td->he = av_calloc(HUF_ENCSIZE, sizeof(*td->he));
468  if (!td->freq || !td->he) {
469  ret = AVERROR(ENOMEM);
470  return ret;
471  }
472 
473  memset(td->freq, 0, sizeof(*td->freq) * HUF_ENCSIZE);
474  if ((ret = huf_unpack_enc_table(gb, im, iM, td->freq)) < 0)
475  return ret;
476 
477  if (nBits > 8 * bytestream2_get_bytes_left(gb)) {
478  ret = AVERROR_INVALIDDATA;
479  return ret;
480  }
481 
482  if ((ret = huf_build_dec_table(s, td, im, iM)) < 0)
483  return ret;
484  return huf_decode(&td->vlc, gb, nBits, td->run_sym, dst_size, dst);
485 }
486 
487 static inline void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
488 {
489  int16_t ls = l;
490  int16_t hs = h;
491  int hi = hs;
492  int ai = ls + (hi & 1) + (hi >> 1);
493  int16_t as = ai;
494  int16_t bs = ai - hi;
495 
496  *a = as;
497  *b = bs;
498 }
499 
500 #define NBITS 16
501 #define A_OFFSET (1 << (NBITS - 1))
502 #define MOD_MASK ((1 << NBITS) - 1)
503 
504 static inline void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
505 {
506  int m = l;
507  int d = h;
508  int bb = (m - (d >> 1)) & MOD_MASK;
509  int aa = (d + bb - A_OFFSET) & MOD_MASK;
510  *b = bb;
511  *a = aa;
512 }
513 
514 static void wav_decode(uint16_t *in, int nx, int ox,
515  int ny, int oy, uint16_t mx)
516 {
517  int w14 = (mx < (1 << 14));
518  int n = (nx > ny) ? ny : nx;
519  int p = 1;
520  int p2;
521 
522  while (p <= n)
523  p <<= 1;
524 
525  p >>= 1;
526  p2 = p;
527  p >>= 1;
528 
529  while (p >= 1) {
530  uint16_t *py = in;
531  uint16_t *ey = in + oy * (ny - p2);
532  uint16_t i00, i01, i10, i11;
533  int oy1 = oy * p;
534  int oy2 = oy * p2;
535  int ox1 = ox * p;
536  int ox2 = ox * p2;
537 
538  for (; py <= ey; py += oy2) {
539  uint16_t *px = py;
540  uint16_t *ex = py + ox * (nx - p2);
541 
542  for (; px <= ex; px += ox2) {
543  uint16_t *p01 = px + ox1;
544  uint16_t *p10 = px + oy1;
545  uint16_t *p11 = p10 + ox1;
546 
547  if (w14) {
548  wdec14(*px, *p10, &i00, &i10);
549  wdec14(*p01, *p11, &i01, &i11);
550  wdec14(i00, i01, px, p01);
551  wdec14(i10, i11, p10, p11);
552  } else {
553  wdec16(*px, *p10, &i00, &i10);
554  wdec16(*p01, *p11, &i01, &i11);
555  wdec16(i00, i01, px, p01);
556  wdec16(i10, i11, p10, p11);
557  }
558  }
559 
560  if (nx & p) {
561  uint16_t *p10 = px + oy1;
562 
563  if (w14)
564  wdec14(*px, *p10, &i00, p10);
565  else
566  wdec16(*px, *p10, &i00, p10);
567 
568  *px = i00;
569  }
570  }
571 
572  if (ny & p) {
573  uint16_t *px = py;
574  uint16_t *ex = py + ox * (nx - p2);
575 
576  for (; px <= ex; px += ox2) {
577  uint16_t *p01 = px + ox1;
578 
579  if (w14)
580  wdec14(*px, *p01, &i00, p01);
581  else
582  wdec16(*px, *p01, &i00, p01);
583 
584  *px = i00;
585  }
586  }
587 
588  p2 = p;
589  p >>= 1;
590  }
591 }
592 
593 static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
594  int dsize, EXRThreadData *td)
595 {
596  GetByteContext gb;
597  uint16_t maxval, min_non_zero, max_non_zero;
598  uint16_t *ptr;
599  uint16_t *tmp = (uint16_t *)td->tmp;
600  uint16_t *out;
601  uint16_t *in;
602  int ret, i, j;
603  int pixel_half_size;/* 1 for half, 2 for float and uint32 */
605  int tmp_offset;
606 
607  if (!td->bitmap)
608  td->bitmap = av_malloc(BITMAP_SIZE);
609  if (!td->lut)
610  td->lut = av_malloc(1 << 17);
611  if (!td->bitmap || !td->lut) {
612  av_freep(&td->bitmap);
613  av_freep(&td->lut);
614  return AVERROR(ENOMEM);
615  }
616 
617  bytestream2_init(&gb, src, ssize);
618  min_non_zero = bytestream2_get_le16(&gb);
619  max_non_zero = bytestream2_get_le16(&gb);
620 
621  if (max_non_zero >= BITMAP_SIZE)
622  return AVERROR_INVALIDDATA;
623 
624  memset(td->bitmap, 0, FFMIN(min_non_zero, BITMAP_SIZE));
625  if (min_non_zero <= max_non_zero)
626  bytestream2_get_buffer(&gb, td->bitmap + min_non_zero,
627  max_non_zero - min_non_zero + 1);
628  memset(td->bitmap + max_non_zero + 1, 0, BITMAP_SIZE - max_non_zero - 1);
629 
630  maxval = reverse_lut(td->bitmap, td->lut);
631 
632  bytestream2_skip(&gb, 4);
633  ret = huf_uncompress(s, td, &gb, tmp, dsize / sizeof(uint16_t));
634  if (ret)
635  return ret;
636 
637  ptr = tmp;
638  for (i = 0; i < s->nb_channels; i++) {
639  channel = &s->channels[i];
640 
641  if (channel->pixel_type == EXR_HALF)
642  pixel_half_size = 1;
643  else
644  pixel_half_size = 2;
645 
646  for (j = 0; j < pixel_half_size; j++)
647  wav_decode(ptr + j, td->xsize, pixel_half_size, td->ysize,
648  td->xsize * pixel_half_size, maxval);
649  ptr += td->xsize * td->ysize * pixel_half_size;
650  }
651 
652  apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));
653 
654  out = (uint16_t *)td->uncompressed_data;
655  for (i = 0; i < td->ysize; i++) {
656  tmp_offset = 0;
657  for (j = 0; j < s->nb_channels; j++) {
658  channel = &s->channels[j];
659  if (channel->pixel_type == EXR_HALF)
660  pixel_half_size = 1;
661  else
662  pixel_half_size = 2;
663 
664  in = tmp + tmp_offset * td->xsize * td->ysize + i * td->xsize * pixel_half_size;
665  tmp_offset += pixel_half_size;
666 
667 #if HAVE_BIGENDIAN
668  s->bbdsp.bswap16_buf(out, in, td->xsize * pixel_half_size);
669 #else
670  memcpy(out, in, td->xsize * 2 * pixel_half_size);
671 #endif
672  out += td->xsize * pixel_half_size;
673  }
674  }
675 
676  return 0;
677 }
678 
680  int compressed_size, int uncompressed_size,
681  EXRThreadData *td)
682 {
683  unsigned long dest_len, expected_len = 0;
684  const uint8_t *in = td->tmp;
685  uint8_t *out;
686  int c, i, j;
687 
688  for (i = 0; i < s->nb_channels; i++) {
689  if (s->channels[i].pixel_type == EXR_FLOAT) {
690  expected_len += (td->xsize * td->ysize * 3);/* PRX 24 store float in 24 bit instead of 32 */
691  } else if (s->channels[i].pixel_type == EXR_HALF) {
692  expected_len += (td->xsize * td->ysize * 2);
693  } else {//UINT 32
694  expected_len += (td->xsize * td->ysize * 4);
695  }
696  }
697 
698  dest_len = expected_len;
699 
700  if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK) {
701  return AVERROR_INVALIDDATA;
702  } else if (dest_len != expected_len) {
703  return AVERROR_INVALIDDATA;
704  }
705 
706  out = td->uncompressed_data;
707  for (i = 0; i < td->ysize; i++)
708  for (c = 0; c < s->nb_channels; c++) {
709  EXRChannel *channel = &s->channels[c];
710  const uint8_t *ptr[4];
711  uint32_t pixel = 0;
712 
713  switch (channel->pixel_type) {
714  case EXR_FLOAT:
715  ptr[0] = in;
716  ptr[1] = ptr[0] + td->xsize;
717  ptr[2] = ptr[1] + td->xsize;
718  in = ptr[2] + td->xsize;
719 
720  for (j = 0; j < td->xsize; ++j) {
721  uint32_t diff = ((unsigned)*(ptr[0]++) << 24) |
722  (*(ptr[1]++) << 16) |
723  (*(ptr[2]++) << 8);
724  pixel += diff;
725  bytestream_put_le32(&out, pixel);
726  }
727  break;
728  case EXR_HALF:
729  ptr[0] = in;
730  ptr[1] = ptr[0] + td->xsize;
731  in = ptr[1] + td->xsize;
732  for (j = 0; j < td->xsize; j++) {
733  uint32_t diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
734 
735  pixel += diff;
736  bytestream_put_le16(&out, pixel);
737  }
738  break;
739  case EXR_UINT:
740  ptr[0] = in;
741  ptr[1] = ptr[0] + s->xdelta;
742  ptr[2] = ptr[1] + s->xdelta;
743  ptr[3] = ptr[2] + s->xdelta;
744  in = ptr[3] + s->xdelta;
745 
746  for (j = 0; j < s->xdelta; ++j) {
747  uint32_t diff = ((uint32_t)*(ptr[0]++) << 24) |
748  (*(ptr[1]++) << 16) |
749  (*(ptr[2]++) << 8 ) |
750  (*(ptr[3]++));
751  pixel += diff;
752  bytestream_put_le32(&out, pixel);
753  }
754  break;
755  default:
756  return AVERROR_INVALIDDATA;
757  }
758  }
759 
760  return 0;
761 }
762 
763 static void unpack_14(const uint8_t b[14], uint16_t s[16])
764 {
765  unsigned short shift = (b[ 2] >> 2) & 15;
766  unsigned short bias = (0x20 << shift);
767  int i;
768 
769  s[ 0] = (b[0] << 8) | b[1];
770 
771  s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
772  s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
773  s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
774 
775  s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
776  s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
777  s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
778  s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
779 
780  s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
781  s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
782  s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
783  s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
784 
785  s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
786  s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
787  s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
788  s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
789 
790  for (i = 0; i < 16; ++i) {
791  if (s[i] & 0x8000)
792  s[i] &= 0x7fff;
793  else
794  s[i] = ~s[i];
795  }
796 }
797 
798 static void unpack_3(const uint8_t b[3], uint16_t s[16])
799 {
800  int i;
801 
802  s[0] = (b[0] << 8) | b[1];
803 
804  if (s[0] & 0x8000)
805  s[0] &= 0x7fff;
806  else
807  s[0] = ~s[0];
808 
809  for (i = 1; i < 16; i++)
810  s[i] = s[0];
811 }
812 
813 
814 static int b44_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
815  int uncompressed_size, EXRThreadData *td) {
816  const int8_t *sr = src;
817  int stay_to_uncompress = compressed_size;
818  int nb_b44_block_w, nb_b44_block_h;
819  int index_tl_x, index_tl_y, index_out, index_tmp;
820  uint16_t tmp_buffer[16]; /* B44 use 4x4 half float pixel */
821  int c, iY, iX, y, x;
822  int target_channel_offset = 0;
823 
824  /* calc B44 block count */
825  nb_b44_block_w = td->xsize / 4;
826  if ((td->xsize % 4) != 0)
827  nb_b44_block_w++;
828 
829  nb_b44_block_h = td->ysize / 4;
830  if ((td->ysize % 4) != 0)
831  nb_b44_block_h++;
832 
833  for (c = 0; c < s->nb_channels; c++) {
834  if (s->channels[c].pixel_type == EXR_HALF) {/* B44 only compress half float data */
835  for (iY = 0; iY < nb_b44_block_h; iY++) {
836  for (iX = 0; iX < nb_b44_block_w; iX++) {/* For each B44 block */
837  if (stay_to_uncompress < 3) {
838  av_log(s, AV_LOG_ERROR, "Not enough data for B44A block: %d", stay_to_uncompress);
839  return AVERROR_INVALIDDATA;
840  }
841 
842  if (src[compressed_size - stay_to_uncompress + 2] == 0xfc) { /* B44A block */
843  unpack_3(sr, tmp_buffer);
844  sr += 3;
845  stay_to_uncompress -= 3;
846  } else {/* B44 Block */
847  if (stay_to_uncompress < 14) {
848  av_log(s, AV_LOG_ERROR, "Not enough data for B44 block: %d", stay_to_uncompress);
849  return AVERROR_INVALIDDATA;
850  }
851  unpack_14(sr, tmp_buffer);
852  sr += 14;
853  stay_to_uncompress -= 14;
854  }
855 
856  /* copy data to uncompress buffer (B44 block can exceed target resolution)*/
857  index_tl_x = iX * 4;
858  index_tl_y = iY * 4;
859 
860  for (y = index_tl_y; y < FFMIN(index_tl_y + 4, td->ysize); y++) {
861  for (x = index_tl_x; x < FFMIN(index_tl_x + 4, td->xsize); x++) {
862  index_out = target_channel_offset * td->xsize + y * td->channel_line_size + 2 * x;
863  index_tmp = (y-index_tl_y) * 4 + (x-index_tl_x);
864  td->uncompressed_data[index_out] = tmp_buffer[index_tmp] & 0xff;
865  td->uncompressed_data[index_out + 1] = tmp_buffer[index_tmp] >> 8;
866  }
867  }
868  }
869  }
870  target_channel_offset += 2;
871  } else {/* Float or UINT 32 channel */
872  if (stay_to_uncompress < td->ysize * td->xsize * 4) {
873  av_log(s, AV_LOG_ERROR, "Not enough data for uncompress channel: %d", stay_to_uncompress);
874  return AVERROR_INVALIDDATA;
875  }
876 
877  for (y = 0; y < td->ysize; y++) {
878  index_out = target_channel_offset * td->xsize + y * td->channel_line_size;
879  memcpy(&td->uncompressed_data[index_out], sr, td->xsize * 4);
880  sr += td->xsize * 4;
881  }
882  target_channel_offset += 4;
883 
884  stay_to_uncompress -= td->ysize * td->xsize * 4;
885  }
886  }
887 
888  return 0;
889 }
890 
891 static int ac_uncompress(EXRContext *s, GetByteContext *gb, float *block)
892 {
893  int ret = 0, n = 1;
894 
895  while (n < 64) {
896  uint16_t val = bytestream2_get_ne16(gb);
897 
898  if (val == 0xff00) {
899  n = 64;
900  } else if ((val >> 8) == 0xff) {
901  n += val & 0xff;
902  } else {
903  ret = n;
905  s->mantissatable,
906  s->exponenttable,
907  s->offsettable));
908  n++;
909  }
910  }
911 
912  return ret;
913 }
914 
915 static void idct_1d(float *blk, int step)
916 {
917  const float a = .5f * cosf( M_PI / 4.f);
918  const float b = .5f * cosf( M_PI / 16.f);
919  const float c = .5f * cosf( M_PI / 8.f);
920  const float d = .5f * cosf(3.f*M_PI / 16.f);
921  const float e = .5f * cosf(5.f*M_PI / 16.f);
922  const float f = .5f * cosf(3.f*M_PI / 8.f);
923  const float g = .5f * cosf(7.f*M_PI / 16.f);
924 
925  float alpha[4], beta[4], theta[4], gamma[4];
926 
927  alpha[0] = c * blk[2 * step];
928  alpha[1] = f * blk[2 * step];
929  alpha[2] = c * blk[6 * step];
930  alpha[3] = f * blk[6 * step];
931 
932  beta[0] = b * blk[1 * step] + d * blk[3 * step] + e * blk[5 * step] + g * blk[7 * step];
933  beta[1] = d * blk[1 * step] - g * blk[3 * step] - b * blk[5 * step] - e * blk[7 * step];
934  beta[2] = e * blk[1 * step] - b * blk[3 * step] + g * blk[5 * step] + d * blk[7 * step];
935  beta[3] = g * blk[1 * step] - e * blk[3 * step] + d * blk[5 * step] - b * blk[7 * step];
936 
937  theta[0] = a * (blk[0 * step] + blk[4 * step]);
938  theta[3] = a * (blk[0 * step] - blk[4 * step]);
939 
940  theta[1] = alpha[0] + alpha[3];
941  theta[2] = alpha[1] - alpha[2];
942 
943  gamma[0] = theta[0] + theta[1];
944  gamma[1] = theta[3] + theta[2];
945  gamma[2] = theta[3] - theta[2];
946  gamma[3] = theta[0] - theta[1];
947 
948  blk[0 * step] = gamma[0] + beta[0];
949  blk[1 * step] = gamma[1] + beta[1];
950  blk[2 * step] = gamma[2] + beta[2];
951  blk[3 * step] = gamma[3] + beta[3];
952 
953  blk[4 * step] = gamma[3] - beta[3];
954  blk[5 * step] = gamma[2] - beta[2];
955  blk[6 * step] = gamma[1] - beta[1];
956  blk[7 * step] = gamma[0] - beta[0];
957 }
958 
959 static void dct_inverse(float *block)
960 {
961  for (int i = 0; i < 8; i++)
962  idct_1d(block + i, 8);
963 
964  for (int i = 0; i < 8; i++) {
965  idct_1d(block, 1);
966  block += 8;
967  }
968 }
969 
970 static void convert(float y, float u, float v,
971  float *b, float *g, float *r)
972 {
973  *r = y + 1.5747f * v;
974  *g = y - 0.1873f * u - 0.4682f * v;
975  *b = y + 1.8556f * u;
976 }
977 
978 static float to_linear(float x, float scale)
979 {
980  float ax = fabsf(x);
981 
982  if (ax <= 1.f) {
983  return FFSIGN(x) * powf(ax, 2.2f * scale);
984  } else {
985  const float log_base = expf(2.2f * scale);
986 
987  return FFSIGN(x) * powf(log_base, ax - 1.f);
988  }
989 }
990 
991 static int dwa_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
992  int uncompressed_size, EXRThreadData *td)
993 {
994  int64_t version, lo_usize, lo_size;
995  int64_t ac_size, dc_size, rle_usize, rle_csize, rle_raw_size;
996  int64_t ac_count, dc_count, ac_compression;
997  const int dc_w = td->xsize >> 3;
998  const int dc_h = td->ysize >> 3;
999  GetByteContext gb, agb;
1000  int skip, ret;
1001 
1002  if (compressed_size <= 88)
1003  return AVERROR_INVALIDDATA;
1004 
1005  version = AV_RL64(src + 0);
1006  if (version != 2)
1007  return AVERROR_INVALIDDATA;
1008 
1009  lo_usize = AV_RL64(src + 8);
1010  lo_size = AV_RL64(src + 16);
1011  ac_size = AV_RL64(src + 24);
1012  dc_size = AV_RL64(src + 32);
1013  rle_csize = AV_RL64(src + 40);
1014  rle_usize = AV_RL64(src + 48);
1015  rle_raw_size = AV_RL64(src + 56);
1016  ac_count = AV_RL64(src + 64);
1017  dc_count = AV_RL64(src + 72);
1018  ac_compression = AV_RL64(src + 80);
1019 
1020  if ( compressed_size < (uint64_t)(lo_size | ac_size | dc_size | rle_csize) || compressed_size < 88LL + lo_size + ac_size + dc_size + rle_csize
1021  || ac_count > (uint64_t)INT_MAX/2
1022  )
1023  return AVERROR_INVALIDDATA;
1024 
1025  bytestream2_init(&gb, src + 88, compressed_size - 88);
1026  skip = bytestream2_get_le16(&gb);
1027  if (skip < 2)
1028  return AVERROR_INVALIDDATA;
1029 
1030  bytestream2_skip(&gb, skip - 2);
1031 
1032  if (lo_size > 0) {
1033  if (lo_usize > uncompressed_size)
1034  return AVERROR_INVALIDDATA;
1035  bytestream2_skip(&gb, lo_size);
1036  }
1037 
1038  if (ac_size > 0) {
1039  unsigned long dest_len;
1040  GetByteContext agb = gb;
1041 
1042  if (ac_count > 3LL * td->xsize * s->scan_lines_per_block)
1043  return AVERROR_INVALIDDATA;
1044 
1045  dest_len = ac_count * 2LL;
1046 
1047  av_fast_padded_malloc(&td->ac_data, &td->ac_size, dest_len);
1048  if (!td->ac_data)
1049  return AVERROR(ENOMEM);
1050 
1051  switch (ac_compression) {
1052  case 0:
1053  ret = huf_uncompress(s, td, &agb, (int16_t *)td->ac_data, ac_count);
1054  if (ret < 0)
1055  return ret;
1056  break;
1057  case 1:
1058  if (uncompress(td->ac_data, &dest_len, agb.buffer, ac_size) != Z_OK ||
1059  dest_len != ac_count * 2LL)
1060  return AVERROR_INVALIDDATA;
1061  break;
1062  default:
1063  return AVERROR_INVALIDDATA;
1064  }
1065 
1066  bytestream2_skip(&gb, ac_size);
1067  }
1068 
1069  {
1070  unsigned long dest_len;
1071  GetByteContext agb = gb;
1072 
1073  if (dc_count != dc_w * dc_h * 3)
1074  return AVERROR_INVALIDDATA;
1075 
1076  dest_len = dc_count * 2LL;
1077 
1078  av_fast_padded_malloc(&td->dc_data, &td->dc_size, FFALIGN(dest_len, 64) * 2);
1079  if (!td->dc_data)
1080  return AVERROR(ENOMEM);
1081 
1082  if (uncompress(td->dc_data + FFALIGN(dest_len, 64), &dest_len, agb.buffer, dc_size) != Z_OK ||
1083  (dest_len != dc_count * 2LL))
1084  return AVERROR_INVALIDDATA;
1085 
1086  s->dsp.predictor(td->dc_data + FFALIGN(dest_len, 64), dest_len);
1087  s->dsp.reorder_pixels(td->dc_data, td->dc_data + FFALIGN(dest_len, 64), dest_len);
1088 
1089  bytestream2_skip(&gb, dc_size);
1090  }
1091 
1092  if (rle_raw_size > 0 && rle_csize > 0 && rle_usize > 0) {
1093  unsigned long dest_len = rle_usize;
1094 
1095  av_fast_padded_malloc(&td->rle_data, &td->rle_size, rle_usize);
1096  if (!td->rle_data)
1097  return AVERROR(ENOMEM);
1098 
1099  av_fast_padded_malloc(&td->rle_raw_data, &td->rle_raw_size, rle_raw_size);
1100  if (!td->rle_raw_data)
1101  return AVERROR(ENOMEM);
1102 
1103  if (uncompress(td->rle_data, &dest_len, gb.buffer, rle_csize) != Z_OK ||
1104  (dest_len != rle_usize))
1105  return AVERROR_INVALIDDATA;
1106 
1107  ret = rle(td->rle_raw_data, td->rle_data, rle_usize, rle_raw_size);
1108  if (ret < 0)
1109  return ret;
1110  bytestream2_skip(&gb, rle_csize);
1111  }
1112 
1113  bytestream2_init(&agb, td->ac_data, ac_count * 2);
1114 
1115  for (int y = 0; y < td->ysize; y += 8) {
1116  for (int x = 0; x < td->xsize; x += 8) {
1117  memset(td->block, 0, sizeof(td->block));
1118 
1119  for (int j = 0; j < 3; j++) {
1120  float *block = td->block[j];
1121  const int idx = (x >> 3) + (y >> 3) * dc_w + dc_w * dc_h * j;
1122  uint16_t *dc = (uint16_t *)td->dc_data;
1123  union av_intfloat32 dc_val;
1124 
1125  dc_val.i = half2float(dc[idx], s->mantissatable,
1126  s->exponenttable, s->offsettable);
1127 
1128  block[0] = dc_val.f;
1129  ac_uncompress(s, &agb, block);
1130  dct_inverse(block);
1131  }
1132 
1133  {
1134  const float scale = s->pixel_type == EXR_FLOAT ? 2.f : 1.f;
1135  const int o = s->nb_channels == 4;
1136  float *bo = ((float *)td->uncompressed_data) +
1137  y * td->xsize * s->nb_channels + td->xsize * (o + 0) + x;
1138  float *go = ((float *)td->uncompressed_data) +
1139  y * td->xsize * s->nb_channels + td->xsize * (o + 1) + x;
1140  float *ro = ((float *)td->uncompressed_data) +
1141  y * td->xsize * s->nb_channels + td->xsize * (o + 2) + x;
1142  float *yb = td->block[0];
1143  float *ub = td->block[1];
1144  float *vb = td->block[2];
1145 
1146  for (int yy = 0; yy < 8; yy++) {
1147  for (int xx = 0; xx < 8; xx++) {
1148  const int idx = xx + yy * 8;
1149 
1150  convert(yb[idx], ub[idx], vb[idx], &bo[xx], &go[xx], &ro[xx]);
1151 
1152  bo[xx] = to_linear(bo[xx], scale);
1153  go[xx] = to_linear(go[xx], scale);
1154  ro[xx] = to_linear(ro[xx], scale);
1155  }
1156 
1157  bo += td->xsize * s->nb_channels;
1158  go += td->xsize * s->nb_channels;
1159  ro += td->xsize * s->nb_channels;
1160  }
1161  }
1162  }
1163  }
1164 
1165  if (s->nb_channels < 4)
1166  return 0;
1167 
1168  for (int y = 0; y < td->ysize && td->rle_raw_data; y++) {
1169  uint32_t *ao = ((uint32_t *)td->uncompressed_data) + y * td->xsize * s->nb_channels;
1170  uint8_t *ai0 = td->rle_raw_data + y * td->xsize;
1171  uint8_t *ai1 = td->rle_raw_data + y * td->xsize + rle_raw_size / 2;
1172 
1173  for (int x = 0; x < td->xsize; x++) {
1174  uint16_t ha = ai0[x] | (ai1[x] << 8);
1175 
1176  ao[x] = half2float(ha, s->mantissatable, s->exponenttable, s->offsettable);
1177  }
1178  }
1179 
1180  return 0;
1181 }
1182 
1183 static int decode_block(AVCodecContext *avctx, void *tdata,
1184  int jobnr, int threadnr)
1185 {
1186  EXRContext *s = avctx->priv_data;
1187  AVFrame *const p = s->picture;
1188  EXRThreadData *td = &s->thread_data[threadnr];
1189  const uint8_t *channel_buffer[4] = { 0 };
1190  const uint8_t *buf = s->buf;
1191  uint64_t line_offset, uncompressed_size;
1192  uint8_t *ptr;
1193  uint32_t data_size;
1194  int line, col = 0;
1195  uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
1196  const uint8_t *src;
1197  int step = s->desc->flags & AV_PIX_FMT_FLAG_FLOAT ? 4 : 2 * s->desc->nb_components;
1198  int bxmin = 0, axmax = 0, window_xoffset = 0;
1199  int window_xmin, window_xmax, window_ymin, window_ymax;
1200  int data_xoffset, data_yoffset, data_window_offset, xsize, ysize;
1201  int i, x, buf_size = s->buf_size;
1202  int c, rgb_channel_count;
1203  float one_gamma = 1.0f / s->gamma;
1204  avpriv_trc_function trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
1205  int ret;
1206 
1207  line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
1208 
1209  if (s->is_tile) {
1210  if (buf_size < 20 || line_offset > buf_size - 20)
1211  return AVERROR_INVALIDDATA;
1212 
1213  src = buf + line_offset + 20;
1214  if (s->is_multipart)
1215  src += 4;
1216 
1217  tile_x = AV_RL32(src - 20);
1218  tile_y = AV_RL32(src - 16);
1219  tile_level_x = AV_RL32(src - 12);
1220  tile_level_y = AV_RL32(src - 8);
1221 
1222  data_size = AV_RL32(src - 4);
1223  if (data_size <= 0 || data_size > buf_size - line_offset - 20)
1224  return AVERROR_INVALIDDATA;
1225 
1226  if (tile_level_x || tile_level_y) { /* tile level, is not the full res level */
1227  avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
1228  return AVERROR_PATCHWELCOME;
1229  }
1230 
1231  if (tile_x && s->tile_attr.xSize + (int64_t)FFMAX(s->xmin, 0) >= INT_MAX / tile_x )
1232  return AVERROR_INVALIDDATA;
1233  if (tile_y && s->tile_attr.ySize + (int64_t)FFMAX(s->ymin, 0) >= INT_MAX / tile_y )
1234  return AVERROR_INVALIDDATA;
1235 
1236  line = s->ymin + s->tile_attr.ySize * tile_y;
1237  col = s->tile_attr.xSize * tile_x;
1238 
1239  if (line < s->ymin || line > s->ymax ||
1240  s->xmin + col < s->xmin || s->xmin + col > s->xmax)
1241  return AVERROR_INVALIDDATA;
1242 
1243  td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tile_y * s->tile_attr.ySize);
1244  td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tile_x * s->tile_attr.xSize);
1245 
1246  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1247  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1248  return AVERROR_INVALIDDATA;
1249 
1250  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1251  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1252  } else {
1253  if (buf_size < 8 || line_offset > buf_size - 8)
1254  return AVERROR_INVALIDDATA;
1255 
1256  src = buf + line_offset + 8;
1257  if (s->is_multipart)
1258  src += 4;
1259  line = AV_RL32(src - 8);
1260 
1261  if (line < s->ymin || line > s->ymax)
1262  return AVERROR_INVALIDDATA;
1263 
1264  data_size = AV_RL32(src - 4);
1265  if (data_size <= 0 || data_size > buf_size - line_offset - 8)
1266  return AVERROR_INVALIDDATA;
1267 
1268  td->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1); /* s->ydelta - line ?? */
1269  td->xsize = s->xdelta;
1270 
1271  if (td->xsize * (uint64_t)s->current_channel_offset > INT_MAX ||
1272  av_image_check_size2(td->xsize, td->ysize, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx) < 0)
1273  return AVERROR_INVALIDDATA;
1274 
1275  td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
1276  uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
1277 
1278  if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
1279  line_offset > buf_size - uncompressed_size)) ||
1280  (s->compression != EXR_RAW && (data_size > uncompressed_size ||
1281  line_offset > buf_size - data_size))) {
1282  return AVERROR_INVALIDDATA;
1283  }
1284  }
1285 
1286  window_xmin = FFMIN(avctx->width, FFMAX(0, s->xmin + col));
1287  window_xmax = FFMIN(avctx->width, FFMAX(0, s->xmin + col + td->xsize));
1288  window_ymin = FFMIN(avctx->height, FFMAX(0, line ));
1289  window_ymax = FFMIN(avctx->height, FFMAX(0, line + td->ysize));
1290  xsize = window_xmax - window_xmin;
1291  ysize = window_ymax - window_ymin;
1292 
1293  /* tile or scanline not visible skip decoding */
1294  if (xsize <= 0 || ysize <= 0)
1295  return 0;
1296 
1297  /* is the first tile or is a scanline */
1298  if(col == 0) {
1299  window_xmin = 0;
1300  /* pixels to add at the left of the display window */
1301  window_xoffset = FFMAX(0, s->xmin);
1302  /* bytes to add at the left of the display window */
1303  bxmin = window_xoffset * step;
1304  }
1305 
1306  /* is the last tile or is a scanline */
1307  if(col + td->xsize == s->xdelta) {
1308  window_xmax = avctx->width;
1309  /* bytes to add at the right of the display window */
1310  axmax = FFMAX(0, (avctx->width - (s->xmax + 1))) * step;
1311  }
1312 
1313  if (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
1314  av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
1315  if (!td->tmp)
1316  return AVERROR(ENOMEM);
1317  }
1318 
1319  if (data_size < uncompressed_size) {
1320  av_fast_padded_malloc(&td->uncompressed_data,
1321  &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
1322 
1323  if (!td->uncompressed_data)
1324  return AVERROR(ENOMEM);
1325 
1326  ret = AVERROR_INVALIDDATA;
1327  switch (s->compression) {
1328  case EXR_ZIP1:
1329  case EXR_ZIP16:
1330  ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
1331  break;
1332  case EXR_PIZ:
1333  ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
1334  break;
1335  case EXR_PXR24:
1336  ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
1337  break;
1338  case EXR_RLE:
1339  ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
1340  break;
1341  case EXR_B44:
1342  case EXR_B44A:
1343  ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
1344  break;
1345  case EXR_DWAA:
1346  case EXR_DWAB:
1347  ret = dwa_uncompress(s, src, data_size, uncompressed_size, td);
1348  break;
1349  }
1350  if (ret < 0) {
1351  av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
1352  return ret;
1353  }
1354  src = td->uncompressed_data;
1355  }
1356 
1357  /* offsets to crop data outside display window */
1358  data_xoffset = FFABS(FFMIN(0, s->xmin + col)) * (s->pixel_type == EXR_HALF ? 2 : 4);
1359  data_yoffset = FFABS(FFMIN(0, line));
1360  data_window_offset = (data_yoffset * td->channel_line_size) + data_xoffset;
1361 
1362  if (!s->is_luma) {
1363  channel_buffer[0] = src + (td->xsize * s->channel_offsets[0]) + data_window_offset;
1364  channel_buffer[1] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1365  channel_buffer[2] = src + (td->xsize * s->channel_offsets[2]) + data_window_offset;
1366  rgb_channel_count = 3;
1367  } else { /* put y data in the first channel_buffer */
1368  channel_buffer[0] = src + (td->xsize * s->channel_offsets[1]) + data_window_offset;
1369  rgb_channel_count = 1;
1370  }
1371  if (s->channel_offsets[3] >= 0)
1372  channel_buffer[3] = src + (td->xsize * s->channel_offsets[3]) + data_window_offset;
1373 
1374  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
1375  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
1376  int channel_count = s->channel_offsets[3] >= 0 ? 4 : rgb_channel_count;
1377  if (s->is_luma) {
1378  channel_buffer[1] = channel_buffer[0];
1379  channel_buffer[2] = channel_buffer[0];
1380  }
1381 
1382  for (c = 0; c < channel_count; c++) {
1383  int plane = s->desc->comp[c].plane;
1384  ptr = p->data[plane] + window_ymin * p->linesize[plane] + (window_xmin * 4);
1385 
1386  for (i = 0; i < ysize; i++, ptr += p->linesize[plane]) {
1387  const uint8_t *src;
1388  union av_intfloat32 *ptr_x;
1389 
1390  src = channel_buffer[c];
1391  ptr_x = (union av_intfloat32 *)ptr;
1392 
1393  // Zero out the start if xmin is not 0
1394  memset(ptr_x, 0, bxmin);
1395  ptr_x += window_xoffset;
1396 
1397  if (s->pixel_type == EXR_FLOAT ||
1398  s->compression == EXR_DWAA ||
1399  s->compression == EXR_DWAB) {
1400  // 32-bit
1401  union av_intfloat32 t;
1402  if (trc_func && c < 3) {
1403  for (x = 0; x < xsize; x++) {
1404  t.i = bytestream_get_le32(&src);
1405  t.f = trc_func(t.f);
1406  *ptr_x++ = t;
1407  }
1408  } else if (one_gamma != 1.f) {
1409  for (x = 0; x < xsize; x++) {
1410  t.i = bytestream_get_le32(&src);
1411  if (t.f > 0.0f && c < 3) /* avoid negative values */
1412  t.f = powf(t.f, one_gamma);
1413  *ptr_x++ = t;
1414  }
1415  } else {
1416  for (x = 0; x < xsize; x++) {
1417  t.i = bytestream_get_le32(&src);
1418  *ptr_x++ = t;
1419  }
1420  }
1421  } else if (s->pixel_type == EXR_HALF) {
1422  // 16-bit
1423  if (c < 3 || !trc_func) {
1424  for (x = 0; x < xsize; x++) {
1425  *ptr_x++ = s->gamma_table[bytestream_get_le16(&src)];
1426  }
1427  } else {
1428  for (x = 0; x < xsize; x++) {
1429  ptr_x[0].i = half2float(bytestream_get_le16(&src),
1430  s->mantissatable,
1431  s->exponenttable,
1432  s->offsettable);
1433  ptr_x++;
1434  }
1435  }
1436  }
1437 
1438  // Zero out the end if xmax+1 is not w
1439  memset(ptr_x, 0, axmax);
1440  channel_buffer[c] += td->channel_line_size;
1441  }
1442  }
1443  } else {
1444 
1445  av_assert1(s->pixel_type == EXR_UINT);
1446  ptr = p->data[0] + window_ymin * p->linesize[0] + (window_xmin * s->desc->nb_components * 2);
1447 
1448  for (i = 0; i < ysize; i++, ptr += p->linesize[0]) {
1449 
1450  const uint8_t * a;
1451  const uint8_t *rgb[3];
1452  uint16_t *ptr_x;
1453 
1454  for (c = 0; c < rgb_channel_count; c++) {
1455  rgb[c] = channel_buffer[c];
1456  }
1457 
1458  if (channel_buffer[3])
1459  a = channel_buffer[3];
1460 
1461  ptr_x = (uint16_t *) ptr;
1462 
1463  // Zero out the start if xmin is not 0
1464  memset(ptr_x, 0, bxmin);
1465  ptr_x += window_xoffset * s->desc->nb_components;
1466 
1467  for (x = 0; x < xsize; x++) {
1468  for (c = 0; c < rgb_channel_count; c++) {
1469  *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
1470  }
1471 
1472  if (channel_buffer[3])
1473  *ptr_x++ = bytestream_get_le32(&a) >> 16;
1474  }
1475 
1476  // Zero out the end if xmax+1 is not w
1477  memset(ptr_x, 0, axmax);
1478 
1479  channel_buffer[0] += td->channel_line_size;
1480  channel_buffer[1] += td->channel_line_size;
1481  channel_buffer[2] += td->channel_line_size;
1482  if (channel_buffer[3])
1483  channel_buffer[3] += td->channel_line_size;
1484  }
1485  }
1486 
1487  return 0;
1488 }
1489 
1491 {
1492  GetByteContext *gb = &s->gb;
1493 
1494  while (bytestream2_get_bytes_left(gb) > 0) {
1495  if (!bytestream2_peek_byte(gb))
1496  break;
1497 
1498  // Process unknown variables
1499  for (int i = 0; i < 2; i++) // value_name and value_type
1500  while (bytestream2_get_byte(gb) != 0);
1501 
1502  // Skip variable length
1503  bytestream2_skip(gb, bytestream2_get_le32(gb));
1504  }
1505 }
1506 
1507 /**
1508  * Check if the variable name corresponds to its data type.
1509  *
1510  * @param s the EXRContext
1511  * @param value_name name of the variable to check
1512  * @param value_type type of the variable to check
1513  * @param minimum_length minimum length of the variable data
1514  *
1515  * @return bytes to read containing variable data
1516  * -1 if variable is not found
1517  * 0 if buffer ended prematurely
1518  */
1520  const char *value_name,
1521  const char *value_type,
1522  unsigned int minimum_length)
1523 {
1524  GetByteContext *gb = &s->gb;
1525  int var_size = -1;
1526 
1527  if (bytestream2_get_bytes_left(gb) >= minimum_length &&
1528  !strcmp(gb->buffer, value_name)) {
1529  // found value_name, jump to value_type (null terminated strings)
1530  gb->buffer += strlen(value_name) + 1;
1531  if (!strcmp(gb->buffer, value_type)) {
1532  gb->buffer += strlen(value_type) + 1;
1533  var_size = bytestream2_get_le32(gb);
1534  // don't go read past boundaries
1535  if (var_size > bytestream2_get_bytes_left(gb))
1536  var_size = 0;
1537  } else {
1538  // value_type not found, reset the buffer
1539  gb->buffer -= strlen(value_name) + 1;
1540  av_log(s->avctx, AV_LOG_WARNING,
1541  "Unknown data type %s for header variable %s.\n",
1542  value_type, value_name);
1543  }
1544  }
1545 
1546  return var_size;
1547 }
1548 
1550 {
1551  AVDictionary *metadata = NULL;
1552  GetByteContext *gb = &s->gb;
1553  int magic_number, version, flags;
1554  int layer_match = 0;
1555  int ret;
1556  int dup_channels = 0;
1557 
1558  s->current_channel_offset = 0;
1559  s->xmin = ~0;
1560  s->xmax = ~0;
1561  s->ymin = ~0;
1562  s->ymax = ~0;
1563  s->xdelta = ~0;
1564  s->ydelta = ~0;
1565  s->channel_offsets[0] = -1;
1566  s->channel_offsets[1] = -1;
1567  s->channel_offsets[2] = -1;
1568  s->channel_offsets[3] = -1;
1569  s->pixel_type = EXR_UNKNOWN;
1570  s->compression = EXR_UNKN;
1571  s->nb_channels = 0;
1572  s->w = 0;
1573  s->h = 0;
1574  s->tile_attr.xSize = -1;
1575  s->tile_attr.ySize = -1;
1576  s->is_tile = 0;
1577  s->is_multipart = 0;
1578  s->is_luma = 0;
1579  s->current_part = 0;
1580 
1581  if (bytestream2_get_bytes_left(gb) < 10) {
1582  av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
1583  return AVERROR_INVALIDDATA;
1584  }
1585 
1586  magic_number = bytestream2_get_le32(gb);
1587  if (magic_number != 20000630) {
1588  /* As per documentation of OpenEXR, it is supposed to be
1589  * int 20000630 little-endian */
1590  av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
1591  return AVERROR_INVALIDDATA;
1592  }
1593 
1594  version = bytestream2_get_byte(gb);
1595  if (version != 2) {
1596  avpriv_report_missing_feature(s->avctx, "Version %d", version);
1597  return AVERROR_PATCHWELCOME;
1598  }
1599 
1600  flags = bytestream2_get_le24(gb);
1601 
1602  if (flags & 0x02)
1603  s->is_tile = 1;
1604  if (flags & 0x10)
1605  s->is_multipart = 1;
1606  if (flags & 0x08) {
1607  avpriv_report_missing_feature(s->avctx, "deep data");
1608  return AVERROR_PATCHWELCOME;
1609  }
1610 
1611  // Parse the header
1612  while (bytestream2_get_bytes_left(gb) > 0) {
1613  int var_size;
1614 
1615  while (s->is_multipart && s->current_part < s->selected_part &&
1616  bytestream2_get_bytes_left(gb) > 0) {
1617  if (bytestream2_peek_byte(gb)) {
1619  } else {
1620  bytestream2_skip(gb, 1);
1621  if (!bytestream2_peek_byte(gb))
1622  break;
1623  }
1624  bytestream2_skip(gb, 1);
1625  s->current_part++;
1626  }
1627 
1628  if (!bytestream2_peek_byte(gb)) {
1629  if (!s->is_multipart)
1630  break;
1631  bytestream2_skip(gb, 1);
1632  if (s->current_part == s->selected_part) {
1633  while (bytestream2_get_bytes_left(gb) > 0) {
1634  if (bytestream2_peek_byte(gb)) {
1636  } else {
1637  bytestream2_skip(gb, 1);
1638  if (!bytestream2_peek_byte(gb))
1639  break;
1640  }
1641  }
1642  }
1643  if (!bytestream2_peek_byte(gb))
1644  break;
1645  s->current_part++;
1646  }
1647 
1648  if ((var_size = check_header_variable(s, "channels",
1649  "chlist", 38)) >= 0) {
1650  GetByteContext ch_gb;
1651  if (!var_size) {
1652  ret = AVERROR_INVALIDDATA;
1653  goto fail;
1654  }
1655 
1656  bytestream2_init(&ch_gb, gb->buffer, var_size);
1657 
1658  while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
1660  enum ExrPixelType current_pixel_type;
1661  int channel_index = -1;
1662  int xsub, ysub;
1663 
1664  if (strcmp(s->layer, "") != 0) {
1665  if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
1666  layer_match = 1;
1667  av_log(s->avctx, AV_LOG_INFO,
1668  "Channel match layer : %s.\n", ch_gb.buffer);
1669  ch_gb.buffer += strlen(s->layer);
1670  if (*ch_gb.buffer == '.')
1671  ch_gb.buffer++; /* skip dot if not given */
1672  } else {
1673  layer_match = 0;
1674  av_log(s->avctx, AV_LOG_INFO,
1675  "Channel doesn't match layer : %s.\n", ch_gb.buffer);
1676  }
1677  } else {
1678  layer_match = 1;
1679  }
1680 
1681  if (layer_match) { /* only search channel if the layer match is valid */
1682  if (!av_strcasecmp(ch_gb.buffer, "R") ||
1683  !av_strcasecmp(ch_gb.buffer, "X") ||
1684  !av_strcasecmp(ch_gb.buffer, "U")) {
1685  channel_index = 0;
1686  s->is_luma = 0;
1687  } else if (!av_strcasecmp(ch_gb.buffer, "G") ||
1688  !av_strcasecmp(ch_gb.buffer, "V")) {
1689  channel_index = 1;
1690  s->is_luma = 0;
1691  } else if (!av_strcasecmp(ch_gb.buffer, "Y")) {
1692  channel_index = 1;
1693  s->is_luma = 1;
1694  } else if (!av_strcasecmp(ch_gb.buffer, "B") ||
1695  !av_strcasecmp(ch_gb.buffer, "Z") ||
1696  !av_strcasecmp(ch_gb.buffer, "W")) {
1697  channel_index = 2;
1698  s->is_luma = 0;
1699  } else if (!av_strcasecmp(ch_gb.buffer, "A")) {
1700  channel_index = 3;
1701  } else {
1702  av_log(s->avctx, AV_LOG_WARNING,
1703  "Unsupported channel %.256s.\n", ch_gb.buffer);
1704  }
1705  }
1706 
1707  /* skip until you get a 0 */
1708  while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1709  bytestream2_get_byte(&ch_gb))
1710  continue;
1711 
1712  if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1713  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1714  ret = AVERROR_INVALIDDATA;
1715  goto fail;
1716  }
1717 
1718  current_pixel_type = bytestream2_get_le32(&ch_gb);
1719  if (current_pixel_type >= EXR_UNKNOWN) {
1720  avpriv_report_missing_feature(s->avctx, "Pixel type %d",
1721  current_pixel_type);
1722  ret = AVERROR_PATCHWELCOME;
1723  goto fail;
1724  }
1725 
1726  bytestream2_skip(&ch_gb, 4);
1727  xsub = bytestream2_get_le32(&ch_gb);
1728  ysub = bytestream2_get_le32(&ch_gb);
1729 
1730  if (xsub != 1 || ysub != 1) {
1732  "Subsampling %dx%d",
1733  xsub, ysub);
1734  ret = AVERROR_PATCHWELCOME;
1735  goto fail;
1736  }
1737 
1738  if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
1739  if (s->pixel_type != EXR_UNKNOWN &&
1740  s->pixel_type != current_pixel_type) {
1741  av_log(s->avctx, AV_LOG_ERROR,
1742  "RGB channels not of the same depth.\n");
1743  ret = AVERROR_INVALIDDATA;
1744  goto fail;
1745  }
1746  s->pixel_type = current_pixel_type;
1747  s->channel_offsets[channel_index] = s->current_channel_offset;
1748  } else if (channel_index >= 0) {
1749  av_log(s->avctx, AV_LOG_WARNING,
1750  "Multiple channels with index %d.\n", channel_index);
1751  if (++dup_channels > 10) {
1752  ret = AVERROR_INVALIDDATA;
1753  goto fail;
1754  }
1755  }
1756 
1757  s->channels = av_realloc(s->channels,
1758  ++s->nb_channels * sizeof(EXRChannel));
1759  if (!s->channels) {
1760  ret = AVERROR(ENOMEM);
1761  goto fail;
1762  }
1763  channel = &s->channels[s->nb_channels - 1];
1764  channel->pixel_type = current_pixel_type;
1765  channel->xsub = xsub;
1766  channel->ysub = ysub;
1767 
1768  if (current_pixel_type == EXR_HALF) {
1769  s->current_channel_offset += 2;
1770  } else {/* Float or UINT32 */
1771  s->current_channel_offset += 4;
1772  }
1773  }
1774 
1775  /* Check if all channels are set with an offset or if the channels
1776  * are causing an overflow */
1777  if (!s->is_luma) {/* if we expected to have at least 3 channels */
1778  if (FFMIN3(s->channel_offsets[0],
1779  s->channel_offsets[1],
1780  s->channel_offsets[2]) < 0) {
1781  if (s->channel_offsets[0] < 0)
1782  av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1783  if (s->channel_offsets[1] < 0)
1784  av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1785  if (s->channel_offsets[2] < 0)
1786  av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1787  ret = AVERROR_INVALIDDATA;
1788  goto fail;
1789  }
1790  }
1791 
1792  // skip one last byte and update main gb
1793  gb->buffer = ch_gb.buffer + 1;
1794  continue;
1795  } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1796  31)) >= 0) {
1797  int xmin, ymin, xmax, ymax;
1798  if (!var_size) {
1799  ret = AVERROR_INVALIDDATA;
1800  goto fail;
1801  }
1802 
1803  xmin = bytestream2_get_le32(gb);
1804  ymin = bytestream2_get_le32(gb);
1805  xmax = bytestream2_get_le32(gb);
1806  ymax = bytestream2_get_le32(gb);
1807 
1808  if (xmin > xmax || ymin > ymax ||
1809  ymax == INT_MAX || xmax == INT_MAX ||
1810  (unsigned)xmax - xmin >= INT_MAX ||
1811  (unsigned)ymax - ymin >= INT_MAX) {
1812  ret = AVERROR_INVALIDDATA;
1813  goto fail;
1814  }
1815  s->xmin = xmin;
1816  s->xmax = xmax;
1817  s->ymin = ymin;
1818  s->ymax = ymax;
1819  s->xdelta = (s->xmax - s->xmin) + 1;
1820  s->ydelta = (s->ymax - s->ymin) + 1;
1821 
1822  continue;
1823  } else if ((var_size = check_header_variable(s, "displayWindow",
1824  "box2i", 34)) >= 0) {
1825  int32_t sx, sy, dx, dy;
1826 
1827  if (!var_size) {
1828  ret = AVERROR_INVALIDDATA;
1829  goto fail;
1830  }
1831 
1832  sx = bytestream2_get_le32(gb);
1833  sy = bytestream2_get_le32(gb);
1834  dx = bytestream2_get_le32(gb);
1835  dy = bytestream2_get_le32(gb);
1836 
1837  s->w = (unsigned)dx - sx + 1;
1838  s->h = (unsigned)dy - sy + 1;
1839 
1840  continue;
1841  } else if ((var_size = check_header_variable(s, "lineOrder",
1842  "lineOrder", 25)) >= 0) {
1843  int line_order;
1844  if (!var_size) {
1845  ret = AVERROR_INVALIDDATA;
1846  goto fail;
1847  }
1848 
1849  line_order = bytestream2_get_byte(gb);
1850  av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1851  if (line_order > 2) {
1852  av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1853  ret = AVERROR_INVALIDDATA;
1854  goto fail;
1855  }
1856 
1857  continue;
1858  } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1859  "float", 31)) >= 0) {
1860  if (!var_size) {
1861  ret = AVERROR_INVALIDDATA;
1862  goto fail;
1863  }
1864 
1865  s->sar = bytestream2_get_le32(gb);
1866 
1867  continue;
1868  } else if ((var_size = check_header_variable(s, "compression",
1869  "compression", 29)) >= 0) {
1870  if (!var_size) {
1871  ret = AVERROR_INVALIDDATA;
1872  goto fail;
1873  }
1874 
1875  if (s->compression == EXR_UNKN)
1876  s->compression = bytestream2_get_byte(gb);
1877  else {
1878  bytestream2_skip(gb, 1);
1879  av_log(s->avctx, AV_LOG_WARNING,
1880  "Found more than one compression attribute.\n");
1881  }
1882 
1883  continue;
1884  } else if ((var_size = check_header_variable(s, "tiles",
1885  "tiledesc", 22)) >= 0) {
1886  char tileLevel;
1887 
1888  if (!s->is_tile)
1889  av_log(s->avctx, AV_LOG_WARNING,
1890  "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
1891 
1892  s->tile_attr.xSize = bytestream2_get_le32(gb);
1893  s->tile_attr.ySize = bytestream2_get_le32(gb);
1894 
1895  tileLevel = bytestream2_get_byte(gb);
1896  s->tile_attr.level_mode = tileLevel & 0x0f;
1897  s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
1898 
1899  if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN) {
1900  avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
1901  s->tile_attr.level_mode);
1902  ret = AVERROR_PATCHWELCOME;
1903  goto fail;
1904  }
1905 
1906  if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
1907  avpriv_report_missing_feature(s->avctx, "Tile level round %d",
1908  s->tile_attr.level_round);
1909  ret = AVERROR_PATCHWELCOME;
1910  goto fail;
1911  }
1912 
1913  continue;
1914  } else if ((var_size = check_header_variable(s, "writer",
1915  "string", 1)) >= 0) {
1916  uint8_t key[256] = { 0 };
1917 
1918  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1919  av_dict_set(&metadata, "writer", key, 0);
1920 
1921  continue;
1922  } else if ((var_size = check_header_variable(s, "framesPerSecond",
1923  "rational", 33)) >= 0) {
1924  if (!var_size) {
1925  ret = AVERROR_INVALIDDATA;
1926  goto fail;
1927  }
1928 
1929  s->avctx->framerate.num = bytestream2_get_le32(gb);
1930  s->avctx->framerate.den = bytestream2_get_le32(gb);
1931 
1932  continue;
1933  } else if ((var_size = check_header_variable(s, "chunkCount",
1934  "int", 23)) >= 0) {
1935 
1936  s->chunk_count = bytestream2_get_le32(gb);
1937 
1938  continue;
1939  } else if ((var_size = check_header_variable(s, "type",
1940  "string", 16)) >= 0) {
1941  uint8_t key[256] = { 0 };
1942 
1943  bytestream2_get_buffer(gb, key, FFMIN(sizeof(key) - 1, var_size));
1944  if (strncmp("scanlineimage", key, var_size) &&
1945  strncmp("tiledimage", key, var_size)) {
1946  ret = AVERROR_PATCHWELCOME;
1947  goto fail;
1948  }
1949 
1950  continue;
1951  } else if ((var_size = check_header_variable(s, "preview",
1952  "preview", 16)) >= 0) {
1953  uint32_t pw = bytestream2_get_le32(gb);
1954  uint32_t ph = bytestream2_get_le32(gb);
1955  uint64_t psize = pw * (uint64_t)ph;
1956  if (psize > INT64_MAX / 4) {
1957  ret = AVERROR_INVALIDDATA;
1958  goto fail;
1959  }
1960  psize *= 4;
1961 
1962  if ((int64_t)psize >= bytestream2_get_bytes_left(gb)) {
1963  ret = AVERROR_INVALIDDATA;
1964  goto fail;
1965  }
1966 
1967  bytestream2_skip(gb, psize);
1968 
1969  continue;
1970  }
1971 
1972  // Check if there are enough bytes for a header
1973  if (bytestream2_get_bytes_left(gb) <= 9) {
1974  av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1975  ret = AVERROR_INVALIDDATA;
1976  goto fail;
1977  }
1978 
1979  // Process unknown variables
1980  {
1981  uint8_t name[256] = { 0 };
1982  uint8_t type[256] = { 0 };
1983  uint8_t value[256] = { 0 };
1984  int i = 0, size;
1985 
1986  while (bytestream2_get_bytes_left(gb) > 0 &&
1987  bytestream2_peek_byte(gb) && i < 255) {
1988  name[i++] = bytestream2_get_byte(gb);
1989  }
1990 
1991  bytestream2_skip(gb, 1);
1992  i = 0;
1993  while (bytestream2_get_bytes_left(gb) > 0 &&
1994  bytestream2_peek_byte(gb) && i < 255) {
1995  type[i++] = bytestream2_get_byte(gb);
1996  }
1997  bytestream2_skip(gb, 1);
1998  size = bytestream2_get_le32(gb);
1999 
2000  bytestream2_get_buffer(gb, value, FFMIN(sizeof(value) - 1, size));
2001  if (!strcmp(type, "string"))
2002  av_dict_set(&metadata, name, value, 0);
2003  }
2004  }
2005 
2006  if (s->compression == EXR_UNKN) {
2007  av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
2008  ret = AVERROR_INVALIDDATA;
2009  goto fail;
2010  }
2011 
2012  if (s->is_tile) {
2013  if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
2014  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
2015  ret = AVERROR_INVALIDDATA;
2016  goto fail;
2017  }
2018  }
2019 
2020  if (bytestream2_get_bytes_left(gb) <= 0) {
2021  av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
2022  ret = AVERROR_INVALIDDATA;
2023  goto fail;
2024  }
2025 
2026  frame->metadata = metadata;
2027 
2028  // aaand we are done
2029  bytestream2_skip(gb, 1);
2030  return 0;
2031 fail:
2032  av_dict_free(&metadata);
2033  return ret;
2034 }
2035 
2036 static int decode_frame(AVCodecContext *avctx, void *data,
2037  int *got_frame, AVPacket *avpkt)
2038 {
2039  EXRContext *s = avctx->priv_data;
2040  GetByteContext *gb = &s->gb;
2041  ThreadFrame frame = { .f = data };
2042  AVFrame *picture = data;
2043  uint8_t *ptr;
2044 
2045  int i, y, ret, ymax;
2046  int planes;
2047  int out_line_size;
2048  int nb_blocks; /* nb scanline or nb tile */
2049  uint64_t start_offset_table;
2050  uint64_t start_next_scanline;
2051  PutByteContext offset_table_writer;
2052 
2053  bytestream2_init(gb, avpkt->data, avpkt->size);
2054 
2055  if ((ret = decode_header(s, picture)) < 0)
2056  return ret;
2057 
2058  if ((s->compression == EXR_DWAA || s->compression == EXR_DWAB) &&
2059  s->pixel_type == EXR_HALF) {
2060  s->current_channel_offset *= 2;
2061  for (int i = 0; i < 4; i++)
2062  s->channel_offsets[i] *= 2;
2063  }
2064 
2065  switch (s->pixel_type) {
2066  case EXR_FLOAT:
2067  case EXR_HALF:
2068  if (s->channel_offsets[3] >= 0) {
2069  if (!s->is_luma) {
2070  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2071  } else {
2072  /* todo: change this when a floating point pixel format with luma with alpha is implemented */
2073  avctx->pix_fmt = AV_PIX_FMT_GBRAPF32;
2074  }
2075  } else {
2076  if (!s->is_luma) {
2077  avctx->pix_fmt = AV_PIX_FMT_GBRPF32;
2078  } else {
2079  avctx->pix_fmt = AV_PIX_FMT_GRAYF32;
2080  }
2081  }
2082  break;
2083  case EXR_UINT:
2084  if (s->channel_offsets[3] >= 0) {
2085  if (!s->is_luma) {
2086  avctx->pix_fmt = AV_PIX_FMT_RGBA64;
2087  } else {
2088  avctx->pix_fmt = AV_PIX_FMT_YA16;
2089  }
2090  } else {
2091  if (!s->is_luma) {
2092  avctx->pix_fmt = AV_PIX_FMT_RGB48;
2093  } else {
2094  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
2095  }
2096  }
2097  break;
2098  default:
2099  av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
2100  return AVERROR_INVALIDDATA;
2101  }
2102 
2103  if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
2104  avctx->color_trc = s->apply_trc_type;
2105 
2106  switch (s->compression) {
2107  case EXR_RAW:
2108  case EXR_RLE:
2109  case EXR_ZIP1:
2110  s->scan_lines_per_block = 1;
2111  break;
2112  case EXR_PXR24:
2113  case EXR_ZIP16:
2114  s->scan_lines_per_block = 16;
2115  break;
2116  case EXR_PIZ:
2117  case EXR_B44:
2118  case EXR_B44A:
2119  case EXR_DWAA:
2120  s->scan_lines_per_block = 32;
2121  break;
2122  case EXR_DWAB:
2123  s->scan_lines_per_block = 256;
2124  break;
2125  default:
2126  avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
2127  return AVERROR_PATCHWELCOME;
2128  }
2129 
2130  /* Verify the xmin, xmax, ymin and ymax before setting the actual image size.
2131  * It's possible for the data window can larger or outside the display window */
2132  if (s->xmin > s->xmax || s->ymin > s->ymax ||
2133  s->ydelta == 0xFFFFFFFF || s->xdelta == 0xFFFFFFFF) {
2134  av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
2135  return AVERROR_INVALIDDATA;
2136  }
2137 
2138  if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
2139  return ret;
2140 
2141  ff_set_sar(s->avctx, av_d2q(av_int2float(s->sar), 255));
2142 
2143  s->desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2144  if (!s->desc)
2145  return AVERROR_INVALIDDATA;
2146 
2147  if (s->desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
2148  planes = s->desc->nb_components;
2149  out_line_size = avctx->width * 4;
2150  } else {
2151  planes = 1;
2152  out_line_size = avctx->width * 2 * s->desc->nb_components;
2153  }
2154 
2155  if (s->is_tile) {
2156  nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
2157  ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
2158  } else { /* scanline */
2159  nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
2160  s->scan_lines_per_block;
2161  }
2162 
2163  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2164  return ret;
2165 
2166  if (bytestream2_get_bytes_left(gb)/8 < nb_blocks)
2167  return AVERROR_INVALIDDATA;
2168 
2169  // check offset table and recreate it if need
2170  if (!s->is_tile && bytestream2_peek_le64(gb) == 0) {
2171  av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
2172 
2173  start_offset_table = bytestream2_tell(gb);
2174  start_next_scanline = start_offset_table + nb_blocks * 8;
2175  bytestream2_init_writer(&offset_table_writer, &avpkt->data[start_offset_table], nb_blocks * 8);
2176 
2177  for (y = 0; y < nb_blocks; y++) {
2178  /* write offset of prev scanline in offset table */
2179  bytestream2_put_le64(&offset_table_writer, start_next_scanline);
2180 
2181  /* get len of next scanline */
2182  bytestream2_seek(gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
2183  start_next_scanline += (bytestream2_get_le32(gb) + 8);
2184  }
2185  bytestream2_seek(gb, start_offset_table, SEEK_SET);
2186  }
2187 
2188  // save pointer we are going to use in decode_block
2189  s->buf = avpkt->data;
2190  s->buf_size = avpkt->size;
2191 
2192  // Zero out the start if ymin is not 0
2193  for (i = 0; i < planes; i++) {
2194  ptr = picture->data[i];
2195  for (y = 0; y < FFMIN(s->ymin, s->h); y++) {
2196  memset(ptr, 0, out_line_size);
2197  ptr += picture->linesize[i];
2198  }
2199  }
2200 
2201  s->picture = picture;
2202 
2203  avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
2204 
2205  ymax = FFMAX(0, s->ymax + 1);
2206  // Zero out the end if ymax+1 is not h
2207  if (ymax < avctx->height)
2208  for (i = 0; i < planes; i++) {
2209  ptr = picture->data[i] + (ymax * picture->linesize[i]);
2210  for (y = ymax; y < avctx->height; y++) {
2211  memset(ptr, 0, out_line_size);
2212  ptr += picture->linesize[i];
2213  }
2214  }
2215 
2216  picture->pict_type = AV_PICTURE_TYPE_I;
2217  *got_frame = 1;
2218 
2219  return avpkt->size;
2220 }
2221 
2223 {
2224  EXRContext *s = avctx->priv_data;
2225  uint32_t i;
2226  union av_intfloat32 t;
2227  float one_gamma = 1.0f / s->gamma;
2228  avpriv_trc_function trc_func = NULL;
2229 
2230  half2float_table(s->mantissatable, s->exponenttable, s->offsettable);
2231 
2232  s->avctx = avctx;
2233 
2234  ff_exrdsp_init(&s->dsp);
2235 
2236 #if HAVE_BIGENDIAN
2237  ff_bswapdsp_init(&s->bbdsp);
2238 #endif
2239 
2240  trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
2241  if (trc_func) {
2242  for (i = 0; i < 65536; ++i) {
2243  t.i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2244  t.f = trc_func(t.f);
2245  s->gamma_table[i] = t;
2246  }
2247  } else {
2248  if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
2249  for (i = 0; i < 65536; ++i) {
2250  s->gamma_table[i].i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2251  }
2252  } else {
2253  for (i = 0; i < 65536; ++i) {
2254  t.i = half2float(i, s->mantissatable, s->exponenttable, s->offsettable);
2255  /* If negative value we reuse half value */
2256  if (t.f <= 0.0f) {
2257  s->gamma_table[i] = t;
2258  } else {
2259  t.f = powf(t.f, one_gamma);
2260  s->gamma_table[i] = t;
2261  }
2262  }
2263  }
2264  }
2265 
2266  // allocate thread data, used for non EXR_RAW compression types
2267  s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
2268  if (!s->thread_data)
2269  return AVERROR_INVALIDDATA;
2270 
2271  return 0;
2272 }
2273 
2275 {
2276  EXRContext *s = avctx->priv_data;
2277  int i;
2278  for (i = 0; i < avctx->thread_count; i++) {
2279  EXRThreadData *td = &s->thread_data[i];
2280  av_freep(&td->uncompressed_data);
2281  av_freep(&td->tmp);
2282  av_freep(&td->bitmap);
2283  av_freep(&td->lut);
2284  av_freep(&td->he);
2285  av_freep(&td->freq);
2286  av_freep(&td->ac_data);
2287  av_freep(&td->dc_data);
2288  av_freep(&td->rle_data);
2289  av_freep(&td->rle_raw_data);
2290  ff_free_vlc(&td->vlc);
2291  }
2292 
2293  av_freep(&s->thread_data);
2294  av_freep(&s->channels);
2295 
2296  return 0;
2297 }
2298 
2299 #define OFFSET(x) offsetof(EXRContext, x)
2300 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2301 static const AVOption options[] = {
2302  { "layer", "Set the decoding layer", OFFSET(layer),
2303  AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
2304  { "part", "Set the decoding part", OFFSET(selected_part),
2305  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
2306  { "gamma", "Set the float gamma value when decoding", OFFSET(gamma),
2307  AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD },
2308 
2309  // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
2310  { "apply_trc", "color transfer characteristics to apply to EXR linear input", OFFSET(apply_trc_type),
2311  AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD, "apply_trc_type"},
2312  { "bt709", "BT.709", 0,
2313  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2314  { "gamma", "gamma", 0,
2315  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2316  { "gamma22", "BT.470 M", 0,
2317  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2318  { "gamma28", "BT.470 BG", 0,
2319  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2320  { "smpte170m", "SMPTE 170 M", 0,
2321  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2322  { "smpte240m", "SMPTE 240 M", 0,
2323  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2324  { "linear", "Linear", 0,
2325  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2326  { "log", "Log", 0,
2327  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2328  { "log_sqrt", "Log square root", 0,
2329  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2330  { "iec61966_2_4", "IEC 61966-2-4", 0,
2331  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2332  { "bt1361", "BT.1361", 0,
2333  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2334  { "iec61966_2_1", "IEC 61966-2-1", 0,
2335  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2336  { "bt2020_10bit", "BT.2020 - 10 bit", 0,
2337  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2338  { "bt2020_12bit", "BT.2020 - 12 bit", 0,
2339  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2340  { "smpte2084", "SMPTE ST 2084", 0,
2341  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2342  { "smpte428_1", "SMPTE ST 428-1", 0,
2343  AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
2344 
2345  { NULL },
2346 };
2347 
2348 static const AVClass exr_class = {
2349  .class_name = "EXR",
2350  .item_name = av_default_item_name,
2351  .option = options,
2352  .version = LIBAVUTIL_VERSION_INT,
2353 };
2354 
2356  .name = "exr",
2357  .long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
2358  .type = AVMEDIA_TYPE_VIDEO,
2359  .id = AV_CODEC_ID_EXR,
2360  .priv_data_size = sizeof(EXRContext),
2361  .init = decode_init,
2362  .close = decode_end,
2363  .decode = decode_frame,
2364  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
2366  .priv_class = &exr_class,
2367 };
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:572
#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
long long int64_t
Definition: coverity.c:34
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:915
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:370
static void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:504
#define USHORT_RANGE
Definition: exr.c:270
static const AVOption options[]
Definition: exr.c:2301
#define MOD_MASK
Definition: exr.c:502
AVCodec ff_exr_decoder
Definition: exr.c:2355
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:978
#define SHORT_ZEROCODE_RUN
Definition: exr.c:322
static av_cold int decode_init(AVCodecContext *avctx)
Definition: exr.c:2222
static const AVClass exr_class
Definition: exr.c:2348
static int decode_header(EXRContext *s, AVFrame *frame)
Definition: exr.c:1549
static int dwa_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:991
#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:814
static void unpack_14(const uint8_t b[14], uint16_t s[16])
Definition: exr.c:763
static av_cold int decode_end(AVCodecContext *avctx)
Definition: exr.c:2274
static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize, int dsize, EXRThreadData *td)
Definition: exr.c:593
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:1490
static void dct_inverse(float *block)
Definition: exr.c:959
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:416
static void convert(float y, float u, float v, float *b, float *g, float *r)
Definition: exr.c:970
#define BITMAP_SIZE
Definition: exr.c:271
static void unpack_3(const uint8_t b[3], uint16_t s[16])
Definition: exr.c:798
#define VD
Definition: exr.c:2300
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:2036
static int huf_uncompress(EXRContext *s, EXRThreadData *td, GetByteContext *gb, uint16_t *dst, int dst_size)
Definition: exr.c:445
static int ac_uncompress(EXRContext *s, GetByteContext *gb, float *block)
Definition: exr.c:891
#define OFFSET(x)
Definition: exr.c:2299
static void wav_decode(uint16_t *in, int nx, int ox, int ny, int oy, uint16_t mx)
Definition: exr.c:514
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:501
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:1519
static void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
Definition: exr.c:487
static int decode_block(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr)
Definition: exr.c:1183
static int pxr24_uncompress(EXRContext *s, const uint8_t *src, int compressed_size, int uncompressed_size, EXRThreadData *td)
Definition: exr.c:679
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:1777
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:1848
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]