git.sesse.net Git - ffmpeg/blob - libavcodec/exr.c

   1 /*
   2  * OpenEXR (.exr) image decoder
   3  * Copyright (c) 2009 Jimmy Christensen
   4  *
   5  * This file is part of Libav
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * OpenEXR decoder
  25  * @author Jimmy Christensen
  26  *
  27  * For more information on the OpenEXR format, visit:
  28  *  http://openexr.com/
  29  *
  30  * exr_flt2uint() and exr_halflt2uint() is credited to  Reimar Döffinger
  31  */
  32
  33 #include <zlib.h>
  34
  35 #include "libavutil/imgutils.h"
  36 #include "libavutil/opt.h"
  37
  38 #include "avcodec.h"
  39 #include "bytestream.h"
  40 #include "get_bits.h"
  41 #include "internal.h"
  42 #include "mathops.h"
  43 #include "thread.h"
  44
  45 enum ExrCompr {
  46     EXR_RAW,
  47     EXR_RLE,
  48     EXR_ZIP1,
  49     EXR_ZIP16,
  50     EXR_PIZ,
  51     EXR_PXR24,
  52     EXR_B44,
  53     EXR_B44A,
  54     EXR_UNKN,
  55 };
  56
  57 enum ExrPixelType {
  58     EXR_UINT,
  59     EXR_HALF,
  60     EXR_FLOAT,
  61     EXR_UNKNOWN,
  62 };
  63
  64 typedef struct EXRChannel {
  65     int xsub, ysub;
  66     enum ExrPixelType pixel_type;
  67 } EXRChannel;
  68
  69 typedef struct EXRThreadData {
  70     uint8_t *uncompressed_data;
  71     int uncompressed_size;
  72
  73     uint8_t *tmp;
  74     int tmp_size;
  75
  76     uint8_t *bitmap;
  77     uint16_t *lut;
  78 } EXRThreadData;
  79
  80 typedef struct EXRContext {
  81     AVClass *class;
  82     AVFrame *picture;
  83     AVCodecContext *avctx;
  84
  85     enum ExrCompr compression;
  86     enum ExrPixelType pixel_type;
  87     int channel_offsets[4]; // 0 = red, 1 = green, 2 = blue and 3 = alpha
  88     const AVPixFmtDescriptor *desc;
  89
  90     int w, h;
  91     uint32_t xmax, xmin;
  92     uint32_t ymax, ymin;
  93     uint32_t xdelta, ydelta;
  94     int ysize;
  95
  96     uint64_t scan_line_size;
  97     int scan_lines_per_block;
  98
  99     GetByteContext gb;
 100     const uint8_t *buf;
 101     int buf_size;
 102
 103     EXRChannel *channels;
 104     int nb_channels;
 105
 106     EXRThreadData *thread_data;
 107
 108     const char *layer;
 109 } EXRContext;
 110
 111 /**
 112  * Convert from 32-bit float as uint32_t to uint16_t.
 113  *
 114  * @param v 32-bit float
 115  *
 116  * @return normalized 16-bit unsigned int
 117  */
 118 static inline uint16_t exr_flt2uint(uint32_t v)
 119 {
 120     unsigned int exp = v >> 23;
 121     // "HACK": negative values result in exp<  0, so clipping them to 0
 122     // is also handled by this condition, avoids explicit check for sign bit.
 123     if (exp <= 127 + 7 - 24) // we would shift out all bits anyway
 124         return 0;
 125     if (exp >= 127)
 126         return 0xffff;
 127     v &= 0x007fffff;
 128     return (v + (1 << 23)) >> (127 + 7 - exp);
 129 }
 130
 131 /**
 132  * Convert from 16-bit float as uint16_t to uint16_t.
 133  *
 134  * @param v 16-bit float
 135  *
 136  * @return normalized 16-bit unsigned int
 137  */
 138 static inline uint16_t exr_halflt2uint(uint16_t v)
 139 {
 140     unsigned exp = 14 - (v >> 10);
 141     if (exp >= 14) {
 142         if (exp == 14)
 143             return (v >> 9) & 1;
 144         else
 145             return (v & 0x8000) ? 0 : 0xffff;
 146     }
 147     v <<= 6;
 148     return (v + (1 << 16)) >> (exp + 1);
 149 }
 150
 151 static void predictor(uint8_t *src, int size)
 152 {
 153     uint8_t *t    = src + 1;
 154     uint8_t *stop = src + size;
 155
 156     while (t < stop) {
 157         int d = (int) t[-1] + (int) t[0] - 128;
 158         t[0] = d;
 159         ++t;
 160     }
 161 }
 162
 163 static void reorder_pixels(uint8_t *src, uint8_t *dst, int size)
 164 {
 165     const int8_t *t1 = src;
 166     const int8_t *t2 = src + (size + 1) / 2;
 167     int8_t *s        = dst;
 168     int8_t *stop     = s + size;
 169
 170     while (1) {
 171         if (s < stop)
 172             *(s++) = *(t1++);
 173         else
 174             break;
 175
 176         if (s < stop)
 177             *(s++) = *(t2++);
 178         else
 179             break;
 180     }
 181 }
 182
 183 static int zip_uncompress(const uint8_t *src, int compressed_size,
 184                           int uncompressed_size, EXRThreadData *td)
 185 {
 186     unsigned long dest_len = uncompressed_size;
 187
 188     if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK ||
 189         dest_len != uncompressed_size)
 190         return AVERROR_INVALIDDATA;
 191
 192     predictor(td->tmp, uncompressed_size);
 193     reorder_pixels(td->tmp, td->uncompressed_data, uncompressed_size);
 194
 195     return 0;
 196 }
 197
 198 static int rle_uncompress(const uint8_t *src, int compressed_size,
 199                           int uncompressed_size, EXRThreadData *td)
 200 {
 201     uint8_t *d      = td->tmp;
 202     const int8_t *s = src;
 203     int ssize       = compressed_size;
 204     int dsize       = uncompressed_size;
 205     uint8_t *dend   = d + dsize;
 206     int count;
 207
 208     while (ssize > 0) {
 209         count = *s++;
 210
 211         if (count < 0) {
 212             count = -count;
 213
 214             if ((dsize -= count) < 0 ||
 215                 (ssize -= count + 1) < 0)
 216                 return AVERROR_INVALIDDATA;
 217
 218             while (count--)
 219                 *d++ = *s++;
 220         } else {
 221             count++;
 222
 223             if ((dsize -= count) < 0 ||
 224                 (ssize -= 2) < 0)
 225                 return AVERROR_INVALIDDATA;
 226
 227             while (count--)
 228                 *d++ = *s;
 229
 230             s++;
 231         }
 232     }
 233
 234     if (dend != d)
 235         return AVERROR_INVALIDDATA;
 236
 237     predictor(td->tmp, uncompressed_size);
 238     reorder_pixels(td->tmp, td->uncompressed_data, uncompressed_size);
 239
 240     return 0;
 241 }
 242
 243 #define USHORT_RANGE (1 << 16)
 244 #define BITMAP_SIZE  (1 << 13)
 245
 246 static uint16_t reverse_lut(const uint8_t *bitmap, uint16_t *lut)
 247 {
 248     int i, k = 0;
 249
 250     for (i = 0; i < USHORT_RANGE; i++)
 251         if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
 252             lut[k++] = i;
 253
 254     i = k - 1;
 255
 256     memset(lut + k, 0, (USHORT_RANGE - k) * 2);
 257
 258     return i;
 259 }
 260
 261 static void apply_lut(const uint16_t *lut, uint16_t *dst, int dsize)
 262 {
 263     int i;
 264
 265     for (i = 0; i < dsize; ++i)
 266         dst[i] = lut[dst[i]];
 267 }
 268
 269 #define HUF_ENCBITS 16  // literal (value) bit length
 270 #define HUF_DECBITS 14  // decoding bit size (>= 8)
 271
 272 #define HUF_ENCSIZE ((1 << HUF_ENCBITS) + 1)  // encoding table size
 273 #define HUF_DECSIZE (1 << HUF_DECBITS)        // decoding table size
 274 #define HUF_DECMASK (HUF_DECSIZE - 1)
 275
 276 typedef struct HufDec {
 277     int len;
 278     int lit;
 279     int *p;
 280 } HufDec;
 281
 282 static void huf_canonical_code_table(uint64_t *hcode)
 283 {
 284     uint64_t c, n[59] = { 0 };
 285     int i;
 286
 287     for (i = 0; i < HUF_ENCSIZE; ++i)
 288         n[hcode[i]] += 1;
 289
 290     c = 0;
 291     for (i = 58; i > 0; --i) {
 292         uint64_t nc = ((c + n[i]) >> 1);
 293         n[i] = c;
 294         c    = nc;
 295     }
 296
 297     for (i = 0; i < HUF_ENCSIZE; ++i) {
 298         int l = hcode[i];
 299
 300         if (l > 0)
 301             hcode[i] = l | (n[l]++ << 6);
 302     }
 303 }
 304
 305 #define SHORT_ZEROCODE_RUN  59
 306 #define LONG_ZEROCODE_RUN   63
 307 #define SHORTEST_LONG_RUN   (2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN)
 308 #define LONGEST_LONG_RUN    (255 + SHORTEST_LONG_RUN)
 309
 310 static int huf_unpack_enc_table(GetByteContext *gb,
 311                                 int32_t im, int32_t iM, uint64_t *hcode)
 312 {
 313     GetBitContext gbit;
 314
 315     init_get_bits8(&gbit, gb->buffer, bytestream2_get_bytes_left(gb));
 316
 317     for (; im <= iM; im++) {
 318         uint64_t l = hcode[im] = get_bits(&gbit, 6);
 319
 320         if (l == LONG_ZEROCODE_RUN) {
 321             int zerun = get_bits(&gbit, 8) + SHORTEST_LONG_RUN;
 322
 323             if (im + zerun > iM + 1)
 324                 return AVERROR_INVALIDDATA;
 325
 326             while (zerun--)
 327                 hcode[im++] = 0;
 328
 329             im--;
 330         } else if (l >= SHORT_ZEROCODE_RUN) {
 331             int zerun = l - SHORT_ZEROCODE_RUN + 2;
 332
 333             if (im + zerun > iM + 1)
 334                 return AVERROR_INVALIDDATA;
 335
 336             while (zerun--)
 337                 hcode[im++] = 0;
 338
 339             im--;
 340         }
 341     }
 342
 343     bytestream2_skip(gb, (get_bits_count(&gbit) + 7) / 8);
 344     huf_canonical_code_table(hcode);
 345
 346     return 0;
 347 }
 348
 349 static int huf_build_dec_table(const uint64_t *hcode, int im,
 350                                int iM, HufDec *hdecod)
 351 {
 352     for (; im <= iM; im++) {
 353         uint64_t c = hcode[im] >> 6;
 354         int i, l = hcode[im] & 63;
 355
 356         if (c >> l)
 357             return AVERROR_INVALIDDATA;
 358
 359         if (l > HUF_DECBITS) {
 360             HufDec *pl = hdecod + (c >> (l - HUF_DECBITS));
 361             if (pl->len)
 362                 return AVERROR_INVALIDDATA;
 363
 364             pl->lit++;
 365
 366             pl->p = av_realloc(pl->p, pl->lit * sizeof(int));
 367             if (!pl->p)
 368                 return AVERROR(ENOMEM);
 369
 370             pl->p[pl->lit - 1] = im;
 371         } else if (l) {
 372             HufDec *pl = hdecod + (c << (HUF_DECBITS - l));
 373
 374             for (i = 1 << (HUF_DECBITS - l); i > 0; i--, pl++) {
 375                 if (pl->len || pl->p)
 376                     return AVERROR_INVALIDDATA;
 377                 pl->len = l;
 378                 pl->lit = im;
 379             }
 380         }
 381     }
 382
 383     return 0;
 384 }
 385
 386 #define get_char(c, lc, gb)                                                   \
 387 {                                                                             \
 388         c   = (c << 8) | bytestream2_get_byte(gb);                            \
 389         lc += 8;                                                              \
 390 }
 391
 392 #define get_code(po, rlc, c, lc, gb, out, oe)                                 \
 393 {                                                                             \
 394         if (po == rlc) {                                                      \
 395             if (lc < 8)                                                       \
 396                 get_char(c, lc, gb);                                          \
 397             lc -= 8;                                                          \
 398                                                                               \
 399             cs = c >> lc;                                                     \
 400                                                                               \
 401             if (out + cs > oe)                                                \
 402                 return AVERROR_INVALIDDATA;                                   \
 403                                                                               \
 404             s = out[-1];                                                      \
 405                                                                               \
 406             while (cs-- > 0)                                                  \
 407                 *out++ = s;                                                   \
 408         } else if (out < oe) {                                                \
 409             *out++ = po;                                                      \
 410         } else {                                                              \
 411             return AVERROR_INVALIDDATA;                                       \
 412         }                                                                     \
 413 }
 414
 415 static int huf_decode(const uint64_t *hcode, const HufDec *hdecod,
 416                       GetByteContext *gb, int nbits,
 417                       int rlc, int no, uint16_t *out)
 418 {
 419     uint64_t c        = 0;
 420     uint16_t *outb    = out;
 421     uint16_t *oe      = out + no;
 422     const uint8_t *ie = gb->buffer + (nbits + 7) / 8; // input byte size
 423     uint8_t cs, s;
 424     int i, lc = 0;
 425
 426     while (gb->buffer < ie) {
 427         get_char(c, lc, gb);
 428
 429         while (lc >= HUF_DECBITS) {
 430             const HufDec pl = hdecod[(c >> (lc - HUF_DECBITS)) & HUF_DECMASK];
 431
 432             if (pl.len) {
 433                 lc -= pl.len;
 434                 get_code(pl.lit, rlc, c, lc, gb, out, oe);
 435             } else {
 436                 int j;
 437
 438                 if (!pl.p)
 439                     return AVERROR_INVALIDDATA;
 440
 441                 for (j = 0; j < pl.lit; j++) {
 442                     int l = hcode[pl.p[j]] & 63;
 443
 444                     while (lc < l && bytestream2_get_bytes_left(gb) > 0)
 445                         get_char(c, lc, gb);
 446
 447                     if (lc >= l) {
 448                         if ((hcode[pl.p[j]] >> 6) ==
 449                             ((c >> (lc - l)) & ((1LL << l) - 1))) {
 450                             lc -= l;
 451                             get_code(pl.p[j], rlc, c, lc, gb, out, oe);
 452                             break;
 453                         }
 454                     }
 455                 }
 456
 457                 if (j == pl.lit)
 458                     return AVERROR_INVALIDDATA;
 459             }
 460         }
 461     }
 462
 463     i   = (8 - nbits) & 7;
 464     c >>= i;
 465     lc -= i;
 466
 467     while (lc > 0) {
 468         const HufDec pl = hdecod[(c << (HUF_DECBITS - lc)) & HUF_DECMASK];
 469
 470         if (pl.len) {
 471             lc -= pl.len;
 472             get_code(pl.lit, rlc, c, lc, gb, out, oe);
 473         } else {
 474             return AVERROR_INVALIDDATA;
 475         }
 476     }
 477
 478     if (out - outb != no)
 479         return AVERROR_INVALIDDATA;
 480     return 0;
 481 }
 482
 483 static int huf_uncompress(GetByteContext *gb,
 484                           uint16_t *dst, int dst_size)
 485 {
 486     int32_t src_size, im, iM;
 487     uint32_t nBits;
 488     uint64_t *freq;
 489     HufDec *hdec;
 490     int ret, i;
 491
 492     src_size = bytestream2_get_le32(gb);
 493     im       = bytestream2_get_le32(gb);
 494     iM       = bytestream2_get_le32(gb);
 495     bytestream2_skip(gb, 4);
 496     nBits = bytestream2_get_le32(gb);
 497     if (im < 0 || im >= HUF_ENCSIZE ||
 498         iM < 0 || iM >= HUF_ENCSIZE ||
 499         src_size < 0)
 500         return AVERROR_INVALIDDATA;
 501
 502     bytestream2_skip(gb, 4);
 503
 504     freq = av_mallocz_array(HUF_ENCSIZE, sizeof(*freq));
 505     hdec = av_mallocz_array(HUF_DECSIZE, sizeof(*hdec));
 506     if (!freq || !hdec) {
 507         ret = AVERROR(ENOMEM);
 508         goto fail;
 509     }
 510
 511     if ((ret = huf_unpack_enc_table(gb, im, iM, freq)) < 0)
 512         goto fail;
 513
 514     if (nBits > 8 * bytestream2_get_bytes_left(gb)) {
 515         ret = AVERROR_INVALIDDATA;
 516         goto fail;
 517     }
 518
 519     if ((ret = huf_build_dec_table(freq, im, iM, hdec)) < 0)
 520         goto fail;
 521     ret = huf_decode(freq, hdec, gb, nBits, iM, dst_size, dst);
 522
 523 fail:
 524     for (i = 0; i < HUF_DECSIZE; i++)
 525         if (hdec)
 526             av_freep(&hdec[i].p);
 527
 528     av_free(freq);
 529     av_free(hdec);
 530
 531     return ret;
 532 }
 533
 534 static inline void wdec14(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
 535 {
 536     int16_t ls = l;
 537     int16_t hs = h;
 538     int hi     = hs;
 539     int ai     = ls + (hi & 1) + (hi >> 1);
 540     int16_t as = ai;
 541     int16_t bs = ai - hi;
 542
 543     *a = as;
 544     *b = bs;
 545 }
 546
 547 #define NBITS      16
 548 #define A_OFFSET  (1 << (NBITS - 1))
 549 #define MOD_MASK  ((1 << NBITS) - 1)
 550
 551 static inline void wdec16(uint16_t l, uint16_t h, uint16_t *a, uint16_t *b)
 552 {
 553     int m  = l;
 554     int d  = h;
 555     int bb = (m - (d >> 1)) & MOD_MASK;
 556     int aa = (d + bb - A_OFFSET) & MOD_MASK;
 557     *b = bb;
 558     *a = aa;
 559 }
 560
 561 static void wav_decode(uint16_t *in, int nx, int ox,
 562                        int ny, int oy, uint16_t mx)
 563 {
 564     int w14 = (mx < (1 << 14));
 565     int n   = (nx > ny) ? ny : nx;
 566     int p   = 1;
 567     int p2;
 568
 569     while (p <= n)
 570         p <<= 1;
 571
 572     p >>= 1;
 573     p2  = p;
 574     p >>= 1;
 575
 576     while (p >= 1) {
 577         uint16_t *py = in;
 578         uint16_t *ey = in + oy * (ny - p2);
 579         uint16_t i00, i01, i10, i11;
 580         int oy1 = oy * p;
 581         int oy2 = oy * p2;
 582         int ox1 = ox * p;
 583         int ox2 = ox * p2;
 584
 585         for (; py <= ey; py += oy2) {
 586             uint16_t *px = py;
 587             uint16_t *ex = py + ox * (nx - p2);
 588
 589             for (; px <= ex; px += ox2) {
 590                 uint16_t *p01 = px + ox1;
 591                 uint16_t *p10 = px + oy1;
 592                 uint16_t *p11 = p10 + ox1;
 593
 594                 if (w14) {
 595                     wdec14(*px, *p10, &i00, &i10);
 596                     wdec14(*p01, *p11, &i01, &i11);
 597                     wdec14(i00, i01, px, p01);
 598                     wdec14(i10, i11, p10, p11);
 599                 } else {
 600                     wdec16(*px, *p10, &i00, &i10);
 601                     wdec16(*p01, *p11, &i01, &i11);
 602                     wdec16(i00, i01, px, p01);
 603                     wdec16(i10, i11, p10, p11);
 604                 }
 605             }
 606
 607             if (nx & p) {
 608                 uint16_t *p10 = px + oy1;
 609
 610                 if (w14)
 611                     wdec14(*px, *p10, &i00, p10);
 612                 else
 613                     wdec16(*px, *p10, &i00, p10);
 614
 615                 *px = i00;
 616             }
 617         }
 618
 619         if (ny & p) {
 620             uint16_t *px = py;
 621             uint16_t *ex = py + ox * (nx - p2);
 622
 623             for (; px <= ex; px += ox2) {
 624                 uint16_t *p01 = px + ox1;
 625
 626                 if (w14)
 627                     wdec14(*px, *p01, &i00, p01);
 628                 else
 629                     wdec16(*px, *p01, &i00, p01);
 630
 631                 *px = i00;
 632             }
 633         }
 634
 635         p2  = p;
 636         p >>= 1;
 637     }
 638 }
 639
 640 static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
 641                           int dsize, EXRThreadData *td)
 642 {
 643     GetByteContext gb;
 644     uint16_t maxval, min_non_zero, max_non_zero;
 645     uint16_t *ptr;
 646     uint16_t *tmp = (uint16_t *)td->tmp;
 647     uint8_t *out;
 648     int ret, i, j;
 649
 650     if (!td->bitmap)
 651         td->bitmap = av_malloc(BITMAP_SIZE);
 652     if (!td->lut)
 653         td->lut = av_malloc(1 << 17);
 654     if (!td->bitmap || !td->lut) {
 655         av_free(td->bitmap);
 656         av_free(td->lut);
 657         return AVERROR(ENOMEM);
 658     }
 659
 660     bytestream2_init(&gb, src, ssize);
 661     min_non_zero = bytestream2_get_le16(&gb);
 662     max_non_zero = bytestream2_get_le16(&gb);
 663
 664     if (max_non_zero >= BITMAP_SIZE)
 665         return AVERROR_INVALIDDATA;
 666
 667     memset(td->bitmap, 0, FFMIN(min_non_zero, BITMAP_SIZE));
 668     if (min_non_zero <= max_non_zero)
 669         bytestream2_get_buffer(&gb, td->bitmap + min_non_zero,
 670                                max_non_zero - min_non_zero + 1);
 671     memset(td->bitmap + max_non_zero, 0, BITMAP_SIZE - max_non_zero);
 672
 673     maxval = reverse_lut(td->bitmap, td->lut);
 674
 675     ret = huf_uncompress(&gb, tmp, dsize / sizeof(uint16_t));
 676     if (ret)
 677         return ret;
 678
 679     ptr = tmp;
 680     for (i = 0; i < s->nb_channels; i++) {
 681         EXRChannel *channel = &s->channels[i];
 682         int size = channel->pixel_type;
 683
 684         for (j = 0; j < size; j++)
 685             wav_decode(ptr + j, s->xdelta, size, s->ysize,
 686                        s->xdelta * size, maxval);
 687         ptr += s->xdelta * s->ysize * size;
 688     }
 689
 690     apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));
 691
 692     out = td->uncompressed_data;
 693     for (i = 0; i < s->ysize; i++)
 694         for (j = 0; j < s->nb_channels; j++) {
 695             uint16_t *in = tmp + j * s->xdelta * s->ysize + i * s->xdelta;
 696             memcpy(out, in, s->xdelta * 2);
 697             out += s->xdelta * 2;
 698         }
 699
 700     return 0;
 701 }
 702
 703 static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
 704                             int compressed_size, int uncompressed_size,
 705                             EXRThreadData *td)
 706 {
 707     unsigned long dest_len = uncompressed_size;
 708     const uint8_t *in = td->tmp;
 709     uint8_t *out;
 710     int c, i, j;
 711
 712     if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK ||
 713         dest_len != uncompressed_size)
 714         return AVERROR_INVALIDDATA;
 715
 716     out = td->uncompressed_data;
 717     for (i = 0; i < s->ysize; i++)
 718         for (c = 0; c < s->nb_channels; c++) {
 719             EXRChannel *channel = &s->channels[c];
 720             const uint8_t *ptr[4];
 721             uint32_t pixel = 0;
 722
 723             switch (channel->pixel_type) {
 724             case EXR_FLOAT:
 725                 ptr[0] = in;
 726                 ptr[1] = ptr[0] + s->xdelta;
 727                 ptr[2] = ptr[1] + s->xdelta;
 728                 in     = ptr[2] + s->xdelta;
 729
 730                 for (j = 0; j < s->xdelta; ++j) {
 731                     uint32_t diff = (*(ptr[0]++) << 24) |
 732                                     (*(ptr[1]++) << 16) |
 733                                     (*(ptr[2]++) << 8);
 734                     pixel += diff;
 735                     bytestream_put_le32(&out, pixel);
 736                 }
 737                 break;
 738             case EXR_HALF:
 739                 ptr[0] = in;
 740                 ptr[1] = ptr[0] + s->xdelta;
 741                 in     = ptr[1] + s->xdelta;
 742                 for (j = 0; j < s->xdelta; j++) {
 743                     uint32_t diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
 744
 745                     pixel += diff;
 746                     bytestream_put_le16(&out, pixel);
 747                 }
 748                 break;
 749             default:
 750                 return AVERROR_INVALIDDATA;
 751             }
 752         }
 753
 754     return 0;
 755 }
 756
 757 static int decode_block(AVCodecContext *avctx, void *tdata,
 758                         int jobnr, int threadnr)
 759 {
 760     EXRContext *s = avctx->priv_data;
 761     AVFrame *const p = s->picture;
 762     EXRThreadData *td = &s->thread_data[threadnr];
 763     const uint8_t *channel_buffer[4] = { 0 };
 764     const uint8_t *buf = s->buf;
 765     uint64_t line_offset, uncompressed_size;
 766     uint32_t xdelta = s->xdelta;
 767     uint16_t *ptr_x;
 768     uint8_t *ptr;
 769     uint32_t data_size, line;
 770     const uint8_t *src;
 771     int axmax = (avctx->width - (s->xmax + 1)) * 2 * s->desc->nb_components;
 772     int bxmin = s->xmin * 2 * s->desc->nb_components;
 773     int i, x, buf_size = s->buf_size;
 774     int ret;
 775
 776     line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
 777     // Check if the buffer has the required bytes needed from the offset
 778     if (line_offset > buf_size - 8)
 779         return AVERROR_INVALIDDATA;
 780
 781     src  = buf + line_offset + 8;
 782     line = AV_RL32(src - 8);
 783     if (line < s->ymin || line > s->ymax)
 784         return AVERROR_INVALIDDATA;
 785
 786     data_size = AV_RL32(src - 4);
 787     if (data_size <= 0 || data_size > buf_size)
 788         return AVERROR_INVALIDDATA;
 789
 790     s->ysize          = FFMIN(s->scan_lines_per_block, s->ymax - line + 1);
 791     uncompressed_size = s->scan_line_size * s->ysize;
 792     if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
 793                                  line_offset > buf_size - uncompressed_size)) ||
 794         (s->compression != EXR_RAW && (data_size > uncompressed_size ||
 795                                  line_offset > buf_size - data_size))) {
 796         return AVERROR_INVALIDDATA;
 797     }
 798
 799     if (data_size < uncompressed_size) {
 800         av_fast_padded_malloc(&td->uncompressed_data,
 801                               &td->uncompressed_size, uncompressed_size);
 802         av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
 803         if (!td->uncompressed_data || !td->tmp)
 804             return AVERROR(ENOMEM);
 805
 806         ret = AVERROR_INVALIDDATA;
 807         switch (s->compression) {
 808         case EXR_ZIP1:
 809         case EXR_ZIP16:
 810             ret = zip_uncompress(src, data_size, uncompressed_size, td);
 811             break;
 812         case EXR_PIZ:
 813             ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
 814             break;
 815         case EXR_PXR24:
 816             ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
 817             break;
 818         case EXR_RLE:
 819             ret = rle_uncompress(src, data_size, uncompressed_size, td);
 820         }
 821         if (ret < 0) {
 822             av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
 823             return ret;
 824         }
 825         src = td->uncompressed_data;
 826     }
 827
 828     channel_buffer[0] = src + xdelta * s->channel_offsets[0];
 829     channel_buffer[1] = src + xdelta * s->channel_offsets[1];
 830     channel_buffer[2] = src + xdelta * s->channel_offsets[2];
 831     if (s->channel_offsets[3] >= 0)
 832         channel_buffer[3] = src + xdelta * s->channel_offsets[3];
 833
 834     ptr = p->data[0] + line * p->linesize[0];
 835     for (i = 0;
 836          i < s->scan_lines_per_block && line + i <= s->ymax;
 837          i++, ptr += p->linesize[0]) {
 838         const uint8_t *r, *g, *b, *a;
 839
 840         r = channel_buffer[0];
 841         g = channel_buffer[1];
 842         b = channel_buffer[2];
 843         if (channel_buffer[3])
 844             a = channel_buffer[3];
 845
 846         ptr_x = (uint16_t *) ptr;
 847
 848         // Zero out the start if xmin is not 0
 849         memset(ptr_x, 0, bxmin);
 850         ptr_x += s->xmin * s->desc->nb_components;
 851         if (s->pixel_type == EXR_FLOAT) {
 852             // 32-bit
 853             for (x = 0; x < xdelta; x++) {
 854                 *ptr_x++ = exr_flt2uint(bytestream_get_le32(&r));
 855                 *ptr_x++ = exr_flt2uint(bytestream_get_le32(&g));
 856                 *ptr_x++ = exr_flt2uint(bytestream_get_le32(&b));
 857                 if (channel_buffer[3])
 858                     *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
 859             }
 860         } else {
 861             // 16-bit
 862             for (x = 0; x < xdelta; x++) {
 863                 *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&r));
 864                 *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&g));
 865                 *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&b));
 866                 if (channel_buffer[3])
 867                     *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&a));
 868             }
 869         }
 870
 871         // Zero out the end if xmax+1 is not w
 872         memset(ptr_x, 0, axmax);
 873
 874         channel_buffer[0] += s->scan_line_size;
 875         channel_buffer[1] += s->scan_line_size;
 876         channel_buffer[2] += s->scan_line_size;
 877         if (channel_buffer[3])
 878             channel_buffer[3] += s->scan_line_size;
 879     }
 880
 881     return 0;
 882 }
 883
 884 /**
 885  * Check if the variable name corresponds to its data type.
 886  *
 887  * @param s              the EXRContext
 888  * @param value_name     name of the variable to check
 889  * @param value_type     type of the variable to check
 890  * @param minimum_length minimum length of the variable data
 891  *
 892  * @return bytes to read containing variable data
 893  *         -1 if variable is not found
 894  *         0 if buffer ended prematurely
 895  */
 896 static int check_header_variable(EXRContext *s,
 897                                  const char *value_name,
 898                                  const char *value_type,
 899                                  unsigned int minimum_length)
 900 {
 901     int var_size = -1;
 902
 903     if (bytestream2_get_bytes_left(&s->gb) >= minimum_length &&
 904         !strcmp(s->gb.buffer, value_name)) {
 905         // found value_name, jump to value_type (null terminated strings)
 906         s->gb.buffer += strlen(value_name) + 1;
 907         if (!strcmp(s->gb.buffer, value_type)) {
 908             s->gb.buffer += strlen(value_type) + 1;
 909             var_size = bytestream2_get_le32(&s->gb);
 910             // don't go read past boundaries
 911             if (var_size > bytestream2_get_bytes_left(&s->gb))
 912                 var_size = 0;
 913         } else {
 914             // value_type not found, reset the buffer
 915             s->gb.buffer -= strlen(value_name) + 1;
 916             av_log(s->avctx, AV_LOG_WARNING,
 917                    "Unknown data type %s for header variable %s.\n",
 918                    value_type, value_name);
 919         }
 920     }
 921
 922     return var_size;
 923 }
 924
 925 static int decode_header(EXRContext *s)
 926 {
 927     int current_channel_offset = 0;
 928     int magic_number, version, flags, i;
 929
 930     if (bytestream2_get_bytes_left(&s->gb) < 10) {
 931         av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
 932         return AVERROR_INVALIDDATA;
 933     }
 934
 935     magic_number = bytestream2_get_le32(&s->gb);
 936     if (magic_number != 20000630) {
 937         /* As per documentation of OpenEXR, it is supposed to be
 938          * int 20000630 little-endian */
 939         av_log(s->avctx, AV_LOG_ERROR, "Wrong magic number %d.\n", magic_number);
 940         return AVERROR_INVALIDDATA;
 941     }
 942
 943     version = bytestream2_get_byte(&s->gb);
 944     if (version != 2) {
 945         avpriv_report_missing_feature(s->avctx, "Version %d", version);
 946         return AVERROR_PATCHWELCOME;
 947     }
 948
 949     flags = bytestream2_get_le24(&s->gb);
 950     if (flags & 0x02) {
 951         avpriv_report_missing_feature(s->avctx, "Tile support");
 952         return AVERROR_PATCHWELCOME;
 953     }
 954
 955     // Parse the header
 956     while (bytestream2_get_bytes_left(&s->gb) > 0 && *s->gb.buffer) {
 957         int var_size;
 958         if ((var_size = check_header_variable(s, "channels",
 959                                               "chlist", 38)) >= 0) {
 960             GetByteContext ch_gb;
 961             if (!var_size)
 962                 return AVERROR_INVALIDDATA;
 963
 964             bytestream2_init(&ch_gb, s->gb.buffer, var_size);
 965
 966             while (bytestream2_get_bytes_left(&ch_gb) >= 19) {
 967                 EXRChannel *channel;
 968                 enum ExrPixelType current_pixel_type;
 969                 int channel_index = -1;
 970                 int xsub, ysub;
 971
 972                 if (strcmp(s->layer, "") != 0) {
 973                     if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
 974                         ch_gb.buffer += strlen(s->layer);
 975                         if (*ch_gb.buffer == '.')
 976                             ch_gb.buffer++;         /* skip dot if not given */
 977                         av_log(s->avctx, AV_LOG_INFO,
 978                                "Layer %s.%s matched.\n", s->layer, ch_gb.buffer);
 979                     }
 980                 }
 981
 982                 if (!strcmp(ch_gb.buffer, "R") ||
 983                     !strcmp(ch_gb.buffer, "X") ||
 984                     !strcmp(ch_gb.buffer, "U"))
 985                     channel_index = 0;
 986                 else if (!strcmp(ch_gb.buffer, "G") ||
 987                          !strcmp(ch_gb.buffer, "Y") ||
 988                          !strcmp(ch_gb.buffer, "V"))
 989                     channel_index = 1;
 990                 else if (!strcmp(ch_gb.buffer, "B") ||
 991                          !strcmp(ch_gb.buffer, "Z") ||
 992                          !strcmp(ch_gb.buffer, "W"))
 993                     channel_index = 2;
 994                 else if (!strcmp(ch_gb.buffer, "A"))
 995                     channel_index = 3;
 996                 else
 997                     av_log(s->avctx, AV_LOG_WARNING,
 998                            "Unsupported channel %.256s.\n", ch_gb.buffer);
 999
1000                 /* skip until you get a 0 */
1001                 while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
1002                        bytestream2_get_byte(&ch_gb))
1003                     continue;
1004
1005                 if (bytestream2_get_bytes_left(&ch_gb) < 4) {
1006                     av_log(s->avctx, AV_LOG_ERROR, "Incomplete header.\n");
1007                     return AVERROR_INVALIDDATA;
1008                 }
1009
1010                 current_pixel_type = bytestream2_get_le32(&ch_gb);
1011                 if (current_pixel_type >= EXR_UNKNOWN) {
1012                     avpriv_report_missing_feature(s->avctx,
1013                                                   "Pixel type %d.\n",
1014                                                   current_pixel_type);
1015                     return AVERROR_PATCHWELCOME;
1016                 }
1017
1018                 bytestream2_skip(&ch_gb, 4);
1019                 xsub = bytestream2_get_le32(&ch_gb);
1020                 ysub = bytestream2_get_le32(&ch_gb);
1021                 if (xsub != 1 || ysub != 1) {
1022                     avpriv_report_missing_feature(s->avctx,
1023                                                   "Subsampling %dx%d",
1024                                                   xsub, ysub);
1025                     return AVERROR_PATCHWELCOME;
1026                 }
1027
1028                 if (channel_index >= 0) {
1029                     if (s->pixel_type != EXR_UNKNOWN &&
1030                         s->pixel_type != current_pixel_type) {
1031                         av_log(s->avctx, AV_LOG_ERROR,
1032                                "RGB channels not of the same depth.\n");
1033                         return AVERROR_INVALIDDATA;
1034                     }
1035                     s->pixel_type                     = current_pixel_type;
1036                     s->channel_offsets[channel_index] = current_channel_offset;
1037                 }
1038
1039                 s->channels = av_realloc(s->channels,
1040                                          ++s->nb_channels * sizeof(EXRChannel));
1041                 if (!s->channels)
1042                     return AVERROR(ENOMEM);
1043                 channel             = &s->channels[s->nb_channels - 1];
1044                 channel->pixel_type = current_pixel_type;
1045                 channel->xsub       = xsub;
1046                 channel->ysub       = ysub;
1047
1048                 current_channel_offset += 1 << current_pixel_type;
1049             }
1050
1051             /* Check if all channels are set with an offset or if the channels
1052              * are causing an overflow  */
1053             if (FFMIN3(s->channel_offsets[0],
1054                        s->channel_offsets[1],
1055                        s->channel_offsets[2]) < 0) {
1056                 if (s->channel_offsets[0] < 0)
1057                     av_log(s->avctx, AV_LOG_ERROR, "Missing red channel.\n");
1058                 if (s->channel_offsets[1] < 0)
1059                     av_log(s->avctx, AV_LOG_ERROR, "Missing green channel.\n");
1060                 if (s->channel_offsets[2] < 0)
1061                     av_log(s->avctx, AV_LOG_ERROR, "Missing blue channel.\n");
1062                 return AVERROR_INVALIDDATA;
1063             }
1064
1065             // skip one last byte and update main gb
1066             s->gb.buffer = ch_gb.buffer + 1;
1067             continue;
1068         } else if ((var_size = check_header_variable(s, "dataWindow", "box2i",
1069                                                      31)) >= 0) {
1070             if (!var_size)
1071                 return AVERROR_INVALIDDATA;
1072
1073             s->xmin   = bytestream2_get_le32(&s->gb);
1074             s->ymin   = bytestream2_get_le32(&s->gb);
1075             s->xmax   = bytestream2_get_le32(&s->gb);
1076             s->ymax   = bytestream2_get_le32(&s->gb);
1077             s->xdelta = (s->xmax - s->xmin) + 1;
1078             s->ydelta = (s->ymax - s->ymin) + 1;
1079
1080             continue;
1081         } else if ((var_size = check_header_variable(s, "displayWindow",
1082                                                      "box2i", 34)) >= 0) {
1083             if (!var_size)
1084                 return AVERROR_INVALIDDATA;
1085
1086             bytestream2_skip(&s->gb, 8);
1087             s->w = bytestream2_get_le32(&s->gb) + 1;
1088             s->h = bytestream2_get_le32(&s->gb) + 1;
1089
1090             continue;
1091         } else if ((var_size = check_header_variable(s, "lineOrder",
1092                                                      "lineOrder", 25)) >= 0) {
1093             int line_order;
1094             if (!var_size)
1095                 return AVERROR_INVALIDDATA;
1096
1097             line_order = bytestream2_get_byte(&s->gb);
1098             av_log(s->avctx, AV_LOG_DEBUG, "line order: %d.\n", line_order);
1099             if (line_order > 2) {
1100                 av_log(s->avctx, AV_LOG_ERROR, "Unknown line order.\n");
1101                 return AVERROR_INVALIDDATA;
1102             }
1103
1104             continue;
1105         } else if ((var_size = check_header_variable(s, "pixelAspectRatio",
1106                                                      "float", 31)) >= 0) {
1107             if (!var_size)
1108                 return AVERROR_INVALIDDATA;
1109
1110             s->avctx->sample_aspect_ratio =
1111                 av_d2q(av_int2float(bytestream2_get_le32(&s->gb)), 255);
1112
1113             continue;
1114         } else if ((var_size = check_header_variable(s, "compression",
1115                                                      "compression", 29)) >= 0) {
1116             if (!var_size)
1117                 return AVERROR_INVALIDDATA;
1118
1119             if (s->compression == EXR_UNKN)
1120                 s->compression = bytestream2_get_byte(&s->gb);
1121             else
1122                 av_log(s->avctx, AV_LOG_WARNING,
1123                        "Found more than one compression attribute.\n");
1124
1125             continue;
1126         }
1127
1128         // Check if there are enough bytes for a header
1129         if (bytestream2_get_bytes_left(&s->gb) <= 9) {
1130             av_log(s->avctx, AV_LOG_ERROR, "Incomplete header\n");
1131             return AVERROR_INVALIDDATA;
1132         }
1133
1134         // Process unknown variables
1135         for (i = 0; i < 2; i++) // value_name and value_type
1136             while (bytestream2_get_byte(&s->gb) != 0);
1137
1138         // Skip variable length
1139         bytestream2_skip(&s->gb, bytestream2_get_le32(&s->gb));
1140     }
1141
1142     if (s->compression == EXR_UNKN) {
1143         av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
1144         return AVERROR_INVALIDDATA;
1145     }
1146     s->scan_line_size = s->xdelta * current_channel_offset;
1147
1148     if (bytestream2_get_bytes_left(&s->gb) <= 0) {
1149         av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
1150         return AVERROR_INVALIDDATA;
1151     }
1152
1153     // aaand we are done
1154     bytestream2_skip(&s->gb, 1);
1155     return 0;
1156 }
1157
1158 static int decode_frame(AVCodecContext *avctx, void *data,
1159                         int *got_frame, AVPacket *avpkt)
1160 {
1161     EXRContext *s = avctx->priv_data;
1162     ThreadFrame frame = { .f = data };
1163     AVFrame *picture = data;
1164     uint8_t *ptr;
1165
1166     int y, ret;
1167     int out_line_size;
1168     int scan_line_blocks;
1169
1170     bytestream2_init(&s->gb, avpkt->data, avpkt->size);
1171
1172     if ((ret = decode_header(s)) < 0)
1173         return ret;
1174
1175     switch (s->pixel_type) {
1176     case EXR_FLOAT:
1177     case EXR_HALF:
1178         if (s->channel_offsets[3] >= 0)
1179             avctx->pix_fmt = AV_PIX_FMT_RGBA64;
1180         else
1181             avctx->pix_fmt = AV_PIX_FMT_RGB48;
1182         break;
1183     case EXR_UINT:
1184         avpriv_request_sample(avctx, "32-bit unsigned int");
1185         return AVERROR_PATCHWELCOME;
1186     default:
1187         av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
1188         return AVERROR_INVALIDDATA;
1189     }
1190
1191     switch (s->compression) {
1192     case EXR_RAW:
1193     case EXR_RLE:
1194     case EXR_ZIP1:
1195         s->scan_lines_per_block = 1;
1196         break;
1197     case EXR_PXR24:
1198     case EXR_ZIP16:
1199         s->scan_lines_per_block = 16;
1200         break;
1201     case EXR_PIZ:
1202         s->scan_lines_per_block = 32;
1203         break;
1204     default:
1205         avpriv_report_missing_feature(avctx, "Compression %d", s->compression);
1206         return AVERROR_PATCHWELCOME;
1207     }
1208
1209     /* Verify the xmin, xmax, ymin, ymax and xdelta before setting
1210      * the actual image size. */
1211     if (s->xmin > s->xmax                  ||
1212         s->ymin > s->ymax                  ||
1213         s->xdelta != s->xmax - s->xmin + 1 ||
1214         s->xmax >= s->w                    ||
1215         s->ymax >= s->h) {
1216         av_log(avctx, AV_LOG_ERROR, "Wrong or missing size information.\n");
1217         return AVERROR_INVALIDDATA;
1218     }
1219
1220     if ((ret = ff_set_dimensions(avctx, s->w, s->h)) < 0)
1221         return ret;
1222
1223     s->desc          = av_pix_fmt_desc_get(avctx->pix_fmt);
1224     if (!s->desc)
1225         return AVERROR_INVALIDDATA;
1226     out_line_size    = avctx->width * 2 * s->desc->nb_components;
1227     scan_line_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
1228                        s->scan_lines_per_block;
1229
1230     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1231         return ret;
1232
1233     if (bytestream2_get_bytes_left(&s->gb) < scan_line_blocks * 8)
1234         return AVERROR_INVALIDDATA;
1235
1236     // save pointer we are going to use in decode_block
1237     s->buf      = avpkt->data;
1238     s->buf_size = avpkt->size;
1239     ptr         = picture->data[0];
1240
1241     // Zero out the start if ymin is not 0
1242     for (y = 0; y < s->ymin; y++) {
1243         memset(ptr, 0, out_line_size);
1244         ptr += picture->linesize[0];
1245     }
1246
1247     s->picture = picture;
1248     avctx->execute2(avctx, decode_block, s->thread_data, NULL, scan_line_blocks);
1249
1250     // Zero out the end if ymax+1 is not h
1251     for (y = s->ymax + 1; y < avctx->height; y++) {
1252         memset(ptr, 0, out_line_size);
1253         ptr += picture->linesize[0];
1254     }
1255
1256     picture->pict_type = AV_PICTURE_TYPE_I;
1257     *got_frame = 1;
1258
1259     return avpkt->size;
1260 }
1261
1262 static av_cold int decode_init(AVCodecContext *avctx)
1263 {
1264     EXRContext *s = avctx->priv_data;
1265
1266     s->avctx              = avctx;
1267     s->xmin               = ~0;
1268     s->xmax               = ~0;
1269     s->ymin               = ~0;
1270     s->ymax               = ~0;
1271     s->xdelta             = ~0;
1272     s->ydelta             = ~0;
1273     s->channel_offsets[0] = -1;
1274     s->channel_offsets[1] = -1;
1275     s->channel_offsets[2] = -1;
1276     s->channel_offsets[3] = -1;
1277     s->pixel_type         = EXR_UNKNOWN;
1278     s->compression        = EXR_UNKN;
1279     s->nb_channels        = 0;
1280     s->w                  = 0;
1281     s->h                  = 0;
1282
1283     // allocate thread data, used for non EXR_RAW compreesion types
1284     s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
1285     if (!s->thread_data)
1286         return AVERROR_INVALIDDATA;
1287
1288     return 0;
1289 }
1290
1291 static int decode_init_thread_copy(AVCodecContext *avctx)
1292 {    EXRContext *s = avctx->priv_data;
1293
1294     // allocate thread data, used for non EXR_RAW compreesion types
1295     s->thread_data = av_mallocz_array(avctx->thread_count, sizeof(EXRThreadData));
1296     if (!s->thread_data)
1297         return AVERROR_INVALIDDATA;
1298
1299     return 0;
1300 }
1301
1302 static av_cold int decode_end(AVCodecContext *avctx)
1303 {
1304     EXRContext *s = avctx->priv_data;
1305     int i;
1306     for (i = 0; i < avctx->thread_count; i++) {
1307         EXRThreadData *td = &s->thread_data[i];
1308         av_freep(&td->uncompressed_data);
1309         av_freep(&td->tmp);
1310         av_freep(&td->bitmap);
1311         av_freep(&td->lut);
1312     }
1313
1314     av_freep(&s->thread_data);
1315     av_freep(&s->channels);
1316
1317     return 0;
1318 }
1319
1320 #define OFFSET(x) offsetof(EXRContext, x)
1321 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1322 static const AVOption options[] = {
1323     { "layer", "Set the decoding layer", OFFSET(layer),
1324         AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
1325     { NULL },
1326 };
1327
1328 static const AVClass exr_class = {
1329     .class_name = "EXR",
1330     .item_name  = av_default_item_name,
1331     .option     = options,
1332     .version    = LIBAVUTIL_VERSION_INT,
1333 };
1334
1335 AVCodec ff_exr_decoder = {
1336     .name             = "exr",
1337     .long_name        = NULL_IF_CONFIG_SMALL("OpenEXR image"),
1338     .type             = AVMEDIA_TYPE_VIDEO,
1339     .id               = AV_CODEC_ID_EXR,
1340     .priv_data_size   = sizeof(EXRContext),
1341     .init             = decode_init,
1342     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1343     .close            = decode_end,
1344     .decode           = decode_frame,
1345     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS |
1346                         CODEC_CAP_SLICE_THREADS,
1347     .priv_class       = &exr_class,
1348 };