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