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

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