summaryrefslogtreecommitdiff
path: root/libavcodec/exr.c
diff options
context:
space:
mode:
Diffstat (limited to 'libavcodec/exr.c')
-rw-r--r--libavcodec/exr.c654
1 files changed, 510 insertions, 144 deletions
diff --git a/libavcodec/exr.c b/libavcodec/exr.c
index d10841d8d6..c87187c05c 100644
--- a/libavcodec/exr.c
+++ b/libavcodec/exr.c
@@ -1,21 +1,24 @@
/*
* OpenEXR (.exr) image decoder
+ * Copyright (c) 2006 Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
* Copyright (c) 2009 Jimmy Christensen
*
- * This file is part of Libav
+ * B44/B44A, Tile added by Jokyo Images support by CNC - French National Center for Cinema
*
- * Libav is free software; you can redistribute it and/or
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * Libav is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
@@ -34,9 +37,11 @@
#include <float.h>
#include <zlib.h>
+#include "libavutil/common.h"
#include "libavutil/imgutils.h"
#include "libavutil/intfloat.h"
#include "libavutil/opt.h"
+#include "libavutil/color_utils.h"
#include "avcodec.h"
#include "bytestream.h"
@@ -64,11 +69,31 @@ enum ExrPixelType {
EXR_UNKNOWN,
};
+enum ExrTileLevelMode {
+ EXR_TILE_LEVEL_ONE,
+ EXR_TILE_LEVEL_MIPMAP,
+ EXR_TILE_LEVEL_RIPMAP,
+ EXR_TILE_LEVEL_UNKNOWN,
+};
+
+enum ExrTileLevelRound {
+ EXR_TILE_ROUND_UP,
+ EXR_TILE_ROUND_DOWN,
+ EXR_TILE_ROUND_UNKNOWN,
+};
+
typedef struct EXRChannel {
int xsub, ysub;
enum ExrPixelType pixel_type;
} EXRChannel;
+typedef struct EXRTileAttribute {
+ int32_t xSize;
+ int32_t ySize;
+ enum ExrTileLevelMode level_mode;
+ enum ExrTileLevelRound level_round;
+} EXRTileAttribute;
+
typedef struct EXRThreadData {
uint8_t *uncompressed_data;
int uncompressed_size;
@@ -78,6 +103,10 @@ typedef struct EXRThreadData {
uint8_t *bitmap;
uint16_t *lut;
+
+ int ysize, xsize;
+
+ int channel_line_size;
} EXRThreadData;
typedef struct EXRContext {
@@ -94,22 +123,25 @@ typedef struct EXRContext {
uint32_t xmax, xmin;
uint32_t ymax, ymin;
uint32_t xdelta, ydelta;
- int ysize;
- uint64_t scan_line_size;
int scan_lines_per_block;
+ EXRTileAttribute tile_attr; /* header data attribute of tile */
+ int is_tile; /* 0 if scanline, 1 if tile */
+
GetByteContext gb;
const uint8_t *buf;
int buf_size;
EXRChannel *channels;
int nb_channels;
+ int current_channel_offset;
EXRThreadData *thread_data;
const char *layer;
+ enum AVColorTransferCharacteristic apply_trc_type;
float gamma;
uint16_t gamma_table[65536];
} EXRContext;
@@ -490,7 +522,8 @@ static int huf_decode(const uint64_t *hcode, const HufDec *hdecod,
uint16_t *outb = out;
uint16_t *oe = out + no;
const uint8_t *ie = gb->buffer + (nbits + 7) / 8; // input byte size
- uint8_t cs, s;
+ uint8_t cs;
+ uint16_t s;
int i, lc = 0;
while (gb->buffer < ie) {
@@ -722,8 +755,8 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
if (!td->lut)
td->lut = av_malloc(1 << 17);
if (!td->bitmap || !td->lut) {
- av_free(td->bitmap);
- av_free(td->lut);
+ av_freep(&td->bitmap);
+ av_freep(&td->lut);
return AVERROR(ENOMEM);
}
@@ -738,7 +771,7 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
if (min_non_zero <= max_non_zero)
bytestream2_get_buffer(&gb, td->bitmap + min_non_zero,
max_non_zero - min_non_zero + 1);
- memset(td->bitmap + max_non_zero, 0, BITMAP_SIZE - max_non_zero);
+ memset(td->bitmap + max_non_zero + 1, 0, BITMAP_SIZE - max_non_zero - 1);
maxval = reverse_lut(td->bitmap, td->lut);
@@ -752,19 +785,19 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
int size = channel->pixel_type;
for (j = 0; j < size; j++)
- wav_decode(ptr + j, s->xdelta, size, s->ysize,
- s->xdelta * size, maxval);
- ptr += s->xdelta * s->ysize * size;
+ wav_decode(ptr + j, td->xsize, size, td->ysize,
+ td->xsize * size, maxval);
+ ptr += td->xsize * td->ysize * size;
}
apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));
out = td->uncompressed_data;
- for (i = 0; i < s->ysize; i++)
+ for (i = 0; i < td->ysize; i++)
for (j = 0; j < s->nb_channels; j++) {
- uint16_t *in = tmp + j * s->xdelta * s->ysize + i * s->xdelta;
- memcpy(out, in, s->xdelta * 2);
- out += s->xdelta * 2;
+ uint16_t *in = tmp + j * td->xsize * td->ysize + i * td->xsize;
+ memcpy(out, in, td->xsize * 2);
+ out += td->xsize * 2;
}
return 0;
@@ -774,17 +807,31 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
int compressed_size, int uncompressed_size,
EXRThreadData *td)
{
- unsigned long dest_len = uncompressed_size;
+ unsigned long dest_len, expected_len = 0;
const uint8_t *in = td->tmp;
uint8_t *out;
int c, i, j;
- if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK ||
- dest_len != uncompressed_size)
+ for (i = 0; i < s->nb_channels; i++) {
+ if (s->channels[i].pixel_type == EXR_FLOAT) {
+ expected_len += (td->xsize * td->ysize * 3);/* PRX 24 store float in 24 bit instead of 32 */
+ } else if (s->channels[i].pixel_type == EXR_HALF) {
+ expected_len += (td->xsize * td->ysize * 2);
+ } else {//UINT 32
+ expected_len += (td->xsize * td->ysize * 4);
+ }
+ }
+
+ dest_len = expected_len;
+
+ if (uncompress(td->tmp, &dest_len, src, compressed_size) != Z_OK) {
+ return AVERROR_INVALIDDATA;
+ } else if (dest_len != expected_len) {
return AVERROR_INVALIDDATA;
+ }
out = td->uncompressed_data;
- for (i = 0; i < s->ysize; i++)
+ for (i = 0; i < td->ysize; i++)
for (c = 0; c < s->nb_channels; c++) {
EXRChannel *channel = &s->channels[c];
const uint8_t *ptr[4];
@@ -793,11 +840,11 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
switch (channel->pixel_type) {
case EXR_FLOAT:
ptr[0] = in;
- ptr[1] = ptr[0] + s->xdelta;
- ptr[2] = ptr[1] + s->xdelta;
- in = ptr[2] + s->xdelta;
+ ptr[1] = ptr[0] + td->xsize;
+ ptr[2] = ptr[1] + td->xsize;
+ in = ptr[2] + td->xsize;
- for (j = 0; j < s->xdelta; ++j) {
+ for (j = 0; j < td->xsize; ++j) {
uint32_t diff = (*(ptr[0]++) << 24) |
(*(ptr[1]++) << 16) |
(*(ptr[2]++) << 8);
@@ -807,9 +854,9 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
break;
case EXR_HALF:
ptr[0] = in;
- ptr[1] = ptr[0] + s->xdelta;
- in = ptr[1] + s->xdelta;
- for (j = 0; j < s->xdelta; j++) {
+ ptr[1] = ptr[0] + td->xsize;
+ in = ptr[1] + td->xsize;
+ for (j = 0; j < td->xsize; j++) {
uint32_t diff = (*(ptr[0]++) << 8) | *(ptr[1]++);
pixel += diff;
@@ -824,6 +871,134 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
return 0;
}
+static void unpack_14(const uint8_t b[14], uint16_t s[16])
+{
+ unsigned short shift = (b[ 2] >> 2);
+ unsigned short bias = (0x20 << shift);
+ int i;
+
+ s[ 0] = (b[0] << 8) | b[1];
+
+ s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
+ s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
+ s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
+
+ s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
+ s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
+ s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
+ s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
+
+ s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
+ s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
+ s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
+ s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
+
+ s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
+ s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
+ s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
+ s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
+
+ for (i = 0; i < 16; ++i) {
+ if (s[i] & 0x8000)
+ s[i] &= 0x7fff;
+ else
+ s[i] = ~s[i];
+ }
+}
+
+static void unpack_3(const uint8_t b[3], uint16_t s[16])
+{
+ int i;
+
+ s[0] = (b[0] << 8) | b[1];
+
+ if (s[0] & 0x8000)
+ s[0] &= 0x7fff;
+ else
+ s[0] = ~s[0];
+
+ for (i = 1; i < 16; i++)
+ s[i] = s[0];
+}
+
+
+static int b44_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
+ int uncompressed_size, EXRThreadData *td) {
+ const int8_t *sr = src;
+ int stayToUncompress = compressed_size;
+ int nbB44BlockW, nbB44BlockH;
+ int indexHgX, indexHgY, indexOut, indexTmp;
+ uint16_t tmpBuffer[16]; /* B44 use 4x4 half float pixel */
+ int c, iY, iX, y, x;
+ int target_channel_offset = 0;
+
+ /* calc B44 block count */
+ nbB44BlockW = td->xsize / 4;
+ if ((td->xsize % 4) != 0)
+ nbB44BlockW++;
+
+ nbB44BlockH = td->ysize / 4;
+ if ((td->ysize % 4) != 0)
+ nbB44BlockH++;
+
+ for (c = 0; c < s->nb_channels; c++) {
+ if (s->channels[c].pixel_type == EXR_HALF) {/* B44 only compress half float data */
+ for (iY = 0; iY < nbB44BlockH; iY++) {
+ for (iX = 0; iX < nbB44BlockW; iX++) {/* For each B44 block */
+ if (stayToUncompress < 3) {
+ av_log(s, AV_LOG_ERROR, "Not enough data for B44A block: %d", stayToUncompress);
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (src[compressed_size - stayToUncompress + 2] == 0xfc) { /* B44A block */
+ unpack_3(sr, tmpBuffer);
+ sr += 3;
+ stayToUncompress -= 3;
+ } else {/* B44 Block */
+ if (stayToUncompress < 14) {
+ av_log(s, AV_LOG_ERROR, "Not enough data for B44 block: %d", stayToUncompress);
+ return AVERROR_INVALIDDATA;
+ }
+ unpack_14(sr, tmpBuffer);
+ sr += 14;
+ stayToUncompress -= 14;
+ }
+
+ /* copy data to uncompress buffer (B44 block can exceed target resolution)*/
+ indexHgX = iX * 4;
+ indexHgY = iY * 4;
+
+ for (y = indexHgY; y < FFMIN(indexHgY + 4, td->ysize); y++) {
+ for (x = indexHgX; x < FFMIN(indexHgX + 4, td->xsize); x++) {
+ indexOut = target_channel_offset * td->xsize + y * td->channel_line_size + 2 * x;
+ indexTmp = (y-indexHgY) * 4 + (x-indexHgX);
+ td->uncompressed_data[indexOut] = tmpBuffer[indexTmp] & 0xff;
+ td->uncompressed_data[indexOut + 1] = tmpBuffer[indexTmp] >> 8;
+ }
+ }
+ }
+ }
+ target_channel_offset += 2;
+ } else {/* Float or UINT 32 channel */
+ if (stayToUncompress < td->ysize * td->xsize * 4) {
+ av_log(s, AV_LOG_ERROR, "Not enough data for uncompress channel: %d", stayToUncompress);
+ return AVERROR_INVALIDDATA;
+ }
+
+ for (y = 0; y < td->ysize; y++) {
+ indexOut = target_channel_offset * td->xsize + y * td->channel_line_size;
+ memcpy(&td->uncompressed_data[indexOut], sr, td->xsize * 4);
+ sr += td->xsize * 4;
+ }
+ target_channel_offset += 4;
+
+ stayToUncompress -= td->ysize * td->xsize * 4;
+ }
+ }
+
+ return 0;
+}
+
static int decode_block(AVCodecContext *avctx, void *tdata,
int jobnr, int threadnr)
{
@@ -833,45 +1008,94 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
const uint8_t *channel_buffer[4] = { 0 };
const uint8_t *buf = s->buf;
uint64_t line_offset, uncompressed_size;
- uint32_t xdelta = s->xdelta;
uint16_t *ptr_x;
uint8_t *ptr;
- uint32_t data_size, line;
+ uint32_t data_size, line, col = 0;
+ uint32_t tileX, tileY, tileLevelX, tileLevelY;
const uint8_t *src;
- int axmax = (avctx->width - (s->xmax + 1)) * 2 * s->desc->nb_components;
- int bxmin = s->xmin * 2 * s->desc->nb_components;
+ int axmax = (avctx->width - (s->xmax + 1)) * 2 * s->desc->nb_components; /* nb pixel to add at the right of the datawindow */
+ int bxmin = s->xmin * 2 * s->desc->nb_components; /* nb pixel to add at the left of the datawindow */
int i, x, buf_size = s->buf_size;
float one_gamma = 1.0f / s->gamma;
+ avpriv_trc_function trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
int ret;
line_offset = AV_RL64(s->gb.buffer + jobnr * 8);
- // Check if the buffer has the required bytes needed from the offset
- if (line_offset > buf_size - 8)
- return AVERROR_INVALIDDATA;
- src = buf + line_offset + 8;
- line = AV_RL32(src - 8);
- if (line < s->ymin || line > s->ymax)
- return AVERROR_INVALIDDATA;
+ if (s->is_tile) {
+ if (line_offset > buf_size - 20)
+ return AVERROR_INVALIDDATA;
- data_size = AV_RL32(src - 4);
- if (data_size <= 0 || data_size > buf_size)
- return AVERROR_INVALIDDATA;
+ src = buf + line_offset + 20;
- s->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1);
- uncompressed_size = s->scan_line_size * s->ysize;
- if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
- line_offset > buf_size - uncompressed_size)) ||
- (s->compression != EXR_RAW && (data_size > uncompressed_size ||
- line_offset > buf_size - data_size))) {
- return AVERROR_INVALIDDATA;
+ tileX = AV_RL32(src - 20);
+ tileY = AV_RL32(src - 16);
+ tileLevelX = AV_RL32(src - 12);
+ tileLevelY = AV_RL32(src - 8);
+
+ data_size = AV_RL32(src - 4);
+ if (data_size <= 0 || data_size > buf_size)
+ return AVERROR_INVALIDDATA;
+
+ if (tileLevelX || tileLevelY) { /* tile level, is not the full res level */
+ avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
+ return AVERROR_PATCHWELCOME;
+ }
+
+ line = s->tile_attr.ySize * tileY;
+ col = s->tile_attr.xSize * tileX;
+
+ td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tileY * s->tile_attr.ySize);
+ td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tileX * s->tile_attr.xSize);
+
+ if (col) { /* not the first tile of the line */
+ bxmin = 0; /* doesn't add pixel at the left of the datawindow */
+ }
+
+ if ((col + td->xsize) != s->xdelta)/* not the last tile of the line */
+ axmax = 0; /* doesn't add pixel at the right of the datawindow */
+
+ td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
+ uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
+ } else {
+ if (line_offset > buf_size - 8)
+ return AVERROR_INVALIDDATA;
+
+ src = buf + line_offset + 8;
+ line = AV_RL32(src - 8);
+
+ if (line < s->ymin || line > s->ymax)
+ return AVERROR_INVALIDDATA;
+
+ data_size = AV_RL32(src - 4);
+ if (data_size <= 0 || data_size > buf_size)
+ return AVERROR_INVALIDDATA;
+
+ td->ysize = FFMIN(s->scan_lines_per_block, s->ymax - line + 1); /* s->ydelta - line ?? */
+ td->xsize = s->xdelta;
+
+ td->channel_line_size = td->xsize * s->current_channel_offset;/* uncompress size of one line */
+ uncompressed_size = td->channel_line_size * (uint64_t)td->ysize;/* uncompress size of the block */
+
+ if ((s->compression == EXR_RAW && (data_size != uncompressed_size ||
+ line_offset > buf_size - uncompressed_size)) ||
+ (s->compression != EXR_RAW && (data_size > uncompressed_size ||
+ line_offset > buf_size - data_size))) {
+ return AVERROR_INVALIDDATA;
+ }
+ }
+
+ if (data_size < uncompressed_size || s->is_tile) { /* td->tmp is use for tile reorganization */
+ av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
+ if (!td->tmp)
+ return AVERROR(ENOMEM);
}
if (data_size < uncompressed_size) {
av_fast_padded_malloc(&td->uncompressed_data,
&td->uncompressed_size, uncompressed_size);
- av_fast_padded_malloc(&td->tmp, &td->tmp_size, uncompressed_size);
- if (!td->uncompressed_data || !td->tmp)
+
+ if (!td->uncompressed_data)
return AVERROR(ENOMEM);
ret = AVERROR_INVALIDDATA;
@@ -888,6 +1112,11 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
break;
case EXR_RLE:
ret = rle_uncompress(src, data_size, uncompressed_size, td);
+ break;
+ case EXR_B44:
+ case EXR_B44A:
+ ret = b44_uncompress(s, src, data_size, uncompressed_size, td);
+ break;
}
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "decode_block() failed.\n");
@@ -896,16 +1125,17 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
src = td->uncompressed_data;
}
- channel_buffer[0] = src + xdelta * s->channel_offsets[0];
- channel_buffer[1] = src + xdelta * s->channel_offsets[1];
- channel_buffer[2] = src + xdelta * s->channel_offsets[2];
+ channel_buffer[0] = src + td->xsize * s->channel_offsets[0];
+ channel_buffer[1] = src + td->xsize * s->channel_offsets[1];
+ channel_buffer[2] = src + td->xsize * s->channel_offsets[2];
if (s->channel_offsets[3] >= 0)
- channel_buffer[3] = src + xdelta * s->channel_offsets[3];
+ channel_buffer[3] = src + td->xsize * s->channel_offsets[3];
+
+ ptr = p->data[0] + line * p->linesize[0] + (col * s->desc->nb_components * 2);
- ptr = p->data[0] + line * p->linesize[0];
for (i = 0;
- i < s->scan_lines_per_block && line + i <= s->ymax;
- i++, ptr += p->linesize[0]) {
+ i < td->ysize; i++, ptr += p->linesize[0]) {
+
const uint8_t *r, *g, *b, *a;
r = channel_buffer[0];
@@ -919,30 +1149,50 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
// Zero out the start if xmin is not 0
memset(ptr_x, 0, bxmin);
ptr_x += s->xmin * s->desc->nb_components;
+
if (s->pixel_type == EXR_FLOAT) {
// 32-bit
- for (x = 0; x < xdelta; x++) {
- union av_intfloat32 t;
- t.i = bytestream_get_le32(&r);
- if (t.f > 0.0f) /* avoid negative values */
- t.f = powf(t.f, one_gamma);
- *ptr_x++ = exr_flt2uint(t.i);
-
- t.i = bytestream_get_le32(&g);
- if (t.f > 0.0f)
- t.f = powf(t.f, one_gamma);
- *ptr_x++ = exr_flt2uint(t.i);
-
- t.i = bytestream_get_le32(&b);
- if (t.f > 0.0f)
- t.f = powf(t.f, one_gamma);
- *ptr_x++ = exr_flt2uint(t.i);
- if (channel_buffer[3])
- *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
+ if (trc_func) {
+ for (x = 0; x < td->xsize; x++) {
+ union av_intfloat32 t;
+ t.i = bytestream_get_le32(&r);
+ t.f = trc_func(t.f);
+ *ptr_x++ = exr_flt2uint(t.i);
+
+ t.i = bytestream_get_le32(&g);
+ t.f = trc_func(t.f);
+ *ptr_x++ = exr_flt2uint(t.i);
+
+ t.i = bytestream_get_le32(&b);
+ t.f = trc_func(t.f);
+ *ptr_x++ = exr_flt2uint(t.i);
+ if (channel_buffer[3])
+ *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
+ }
+ } else {
+ for (x = 0; x < td->xsize; x++) {
+ union av_intfloat32 t;
+ t.i = bytestream_get_le32(&r);
+ if (t.f > 0.0f) /* avoid negative values */
+ t.f = powf(t.f, one_gamma);
+ *ptr_x++ = exr_flt2uint(t.i);
+
+ t.i = bytestream_get_le32(&g);
+ if (t.f > 0.0f)
+ t.f = powf(t.f, one_gamma);
+ *ptr_x++ = exr_flt2uint(t.i);
+
+ t.i = bytestream_get_le32(&b);
+ if (t.f > 0.0f)
+ t.f = powf(t.f, one_gamma);
+ *ptr_x++ = exr_flt2uint(t.i);
+ if (channel_buffer[3])
+ *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
+ }
}
} else {
// 16-bit
- for (x = 0; x < xdelta; x++) {
+ for (x = 0; x < td->xsize; x++) {
*ptr_x++ = s->gamma_table[bytestream_get_le16(&r)];
*ptr_x++ = s->gamma_table[bytestream_get_le16(&g)];
*ptr_x++ = s->gamma_table[bytestream_get_le16(&b)];
@@ -954,11 +1204,11 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
// Zero out the end if xmax+1 is not w
memset(ptr_x, 0, axmax);
- channel_buffer[0] += s->scan_line_size;
- channel_buffer[1] += s->scan_line_size;
- channel_buffer[2] += s->scan_line_size;
+ channel_buffer[0] += td->channel_line_size;
+ channel_buffer[1] += td->channel_line_size;
+ channel_buffer[2] += td->channel_line_size;
if (channel_buffer[3])
- channel_buffer[3] += s->scan_line_size;
+ channel_buffer[3] += td->channel_line_size;
}
return 0;
@@ -1007,8 +1257,28 @@ static int check_header_variable(EXRContext *s,
static int decode_header(EXRContext *s)
{
- int current_channel_offset = 0;
- int magic_number, version, flags, i;
+ int magic_number, version, i, flags, sar = 0;
+ int layer_match = 0;
+
+ s->current_channel_offset = 0;
+ s->xmin = ~0;
+ s->xmax = ~0;
+ s->ymin = ~0;
+ s->ymax = ~0;
+ s->xdelta = ~0;
+ s->ydelta = ~0;
+ s->channel_offsets[0] = -1;
+ s->channel_offsets[1] = -1;
+ s->channel_offsets[2] = -1;
+ s->channel_offsets[3] = -1;
+ s->pixel_type = EXR_UNKNOWN;
+ s->compression = EXR_UNKN;
+ s->nb_channels = 0;
+ s->w = 0;
+ s->h = 0;
+ s->tile_attr.xSize = -1;
+ s->tile_attr.ySize = -1;
+ s->is_tile = 0;
if (bytestream2_get_bytes_left(&s->gb) < 10) {
av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
@@ -1030,8 +1300,13 @@ static int decode_header(EXRContext *s)
}
flags = bytestream2_get_le24(&s->gb);
- if (flags & 0x02) {
- avpriv_report_missing_feature(s->avctx, "Tile support");
+
+ if (flags == 0x00)
+ s->is_tile = 0;
+ else if (flags & 0x02)
+ s->is_tile = 1;
+ else{
+ avpriv_report_missing_feature(s->avctx, "flags %d", flags);
return AVERROR_PATCHWELCOME;
}
@@ -1054,31 +1329,39 @@ static int decode_header(EXRContext *s)
if (strcmp(s->layer, "") != 0) {
if (strncmp(ch_gb.buffer, s->layer, strlen(s->layer)) == 0) {
+ layer_match = 1;
+ av_log(s->avctx, AV_LOG_INFO,
+ "Channel match layer : %s.\n", ch_gb.buffer);
ch_gb.buffer += strlen(s->layer);
if (*ch_gb.buffer == '.')
ch_gb.buffer++; /* skip dot if not given */
+ } else {
av_log(s->avctx, AV_LOG_INFO,
- "Layer %s.%s matched.\n", s->layer, ch_gb.buffer);
+ "Channel doesn't match layer : %s.\n", ch_gb.buffer);
}
+ } else {
+ layer_match = 1;
}
- if (!strcmp(ch_gb.buffer, "R") ||
- !strcmp(ch_gb.buffer, "X") ||
- !strcmp(ch_gb.buffer, "U"))
- channel_index = 0;
- else if (!strcmp(ch_gb.buffer, "G") ||
- !strcmp(ch_gb.buffer, "Y") ||
- !strcmp(ch_gb.buffer, "V"))
- channel_index = 1;
- else if (!strcmp(ch_gb.buffer, "B") ||
- !strcmp(ch_gb.buffer, "Z") ||
- !strcmp(ch_gb.buffer, "W"))
- channel_index = 2;
- else if (!strcmp(ch_gb.buffer, "A"))
- channel_index = 3;
- else
- av_log(s->avctx, AV_LOG_WARNING,
- "Unsupported channel %.256s.\n", ch_gb.buffer);
+ if (layer_match) { /* only search channel if the layer match is valid */
+ if (!strcmp(ch_gb.buffer, "R") ||
+ !strcmp(ch_gb.buffer, "X") ||
+ !strcmp(ch_gb.buffer, "U"))
+ channel_index = 0;
+ else if (!strcmp(ch_gb.buffer, "G") ||
+ !strcmp(ch_gb.buffer, "Y") ||
+ !strcmp(ch_gb.buffer, "V"))
+ channel_index = 1;
+ else if (!strcmp(ch_gb.buffer, "B") ||
+ !strcmp(ch_gb.buffer, "Z") ||
+ !strcmp(ch_gb.buffer, "W"))
+ channel_index = 2;
+ else if (!strcmp(ch_gb.buffer, "A"))
+ channel_index = 3;
+ else
+ av_log(s->avctx, AV_LOG_WARNING,
+ "Unsupported channel %.256s.\n", ch_gb.buffer);
+ }
/* skip until you get a 0 */
while (bytestream2_get_bytes_left(&ch_gb) > 0 &&
@@ -1107,15 +1390,17 @@ static int decode_header(EXRContext *s)
return AVERROR_PATCHWELCOME;
}
- if (channel_index >= 0) {
- if (s->pixel_type != EXR_UNKNOWN &&
- s->pixel_type != current_pixel_type) {
- av_log(s->avctx, AV_LOG_ERROR,
- "RGB channels not of the same depth.\n");
- return AVERROR_INVALIDDATA;
+ if (s->channel_offsets[channel_index] == -1){/* channel have not been previously assign */
+ if (channel_index >= 0) {
+ if (s->pixel_type != EXR_UNKNOWN &&
+ s->pixel_type != current_pixel_type) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "RGB channels not of the same depth.\n");
+ return AVERROR_INVALIDDATA;
+ }
+ s->pixel_type = current_pixel_type;
+ s->channel_offsets[channel_index] = s->current_channel_offset;
}
- s->pixel_type = current_pixel_type;
- s->channel_offsets[channel_index] = current_channel_offset;
}
s->channels = av_realloc(s->channels,
@@ -1127,7 +1412,7 @@ static int decode_header(EXRContext *s)
channel->xsub = xsub;
channel->ysub = ysub;
- current_channel_offset += 1 << current_pixel_type;
+ s->current_channel_offset += 1 << current_pixel_type;
}
/* Check if all channels are set with an offset or if the channels
@@ -1189,8 +1474,7 @@ static int decode_header(EXRContext *s)
if (!var_size)
return AVERROR_INVALIDDATA;
- ff_set_sar(s->avctx,
- av_d2q(av_int2float(bytestream2_get_le32(&s->gb)), 255));
+ sar = bytestream2_get_le32(&s->gb);
continue;
} else if ((var_size = check_header_variable(s, "compression",
@@ -1205,6 +1489,34 @@ static int decode_header(EXRContext *s)
"Found more than one compression attribute.\n");
continue;
+ } else if ((var_size = check_header_variable(s, "tiles",
+ "tiledesc", 22)) >= 0) {
+ char tileLevel;
+
+ if (!s->is_tile)
+ av_log(s->avctx, AV_LOG_WARNING,
+ "Found tile attribute and scanline flags. Exr will be interpreted as scanline.\n");
+
+ s->tile_attr.xSize = bytestream2_get_le32(&s->gb);
+ s->tile_attr.ySize = bytestream2_get_le32(&s->gb);
+
+ tileLevel = bytestream2_get_byte(&s->gb);
+ s->tile_attr.level_mode = tileLevel & 0x0f;
+ s->tile_attr.level_round = (tileLevel >> 4) & 0x0f;
+
+ if (s->tile_attr.level_mode >= EXR_TILE_LEVEL_UNKNOWN){
+ avpriv_report_missing_feature(s->avctx, "Tile level mode %d",
+ s->tile_attr.level_mode);
+ return AVERROR_PATCHWELCOME;
+ }
+
+ if (s->tile_attr.level_round >= EXR_TILE_ROUND_UNKNOWN) {
+ avpriv_report_missing_feature(s->avctx, "Tile level round %d",
+ s->tile_attr.level_round);
+ return AVERROR_PATCHWELCOME;
+ }
+
+ continue;
}
// Check if there are enough bytes for a header
@@ -1221,11 +1533,19 @@ static int decode_header(EXRContext *s)
bytestream2_skip(&s->gb, bytestream2_get_le32(&s->gb));
}
+ ff_set_sar(s->avctx, av_d2q(av_int2float(sar), 255));
+
if (s->compression == EXR_UNKN) {
av_log(s->avctx, AV_LOG_ERROR, "Missing compression attribute.\n");
return AVERROR_INVALIDDATA;
}
- s->scan_line_size = s->xdelta * current_channel_offset;
+
+ if (s->is_tile) {
+ if (s->tile_attr.xSize < 1 || s->tile_attr.ySize < 1) {
+ av_log(s->avctx, AV_LOG_ERROR, "Invalid tile attribute.\n");
+ return AVERROR_INVALIDDATA;
+ }
+ }
if (bytestream2_get_bytes_left(&s->gb) <= 0) {
av_log(s->avctx, AV_LOG_ERROR, "Incomplete frame.\n");
@@ -1247,7 +1567,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
int y, ret;
int out_line_size;
- int scan_line_blocks;
+ int nb_blocks;/* nb scanline or nb tile */
bytestream2_init(&s->gb, avpkt->data, avpkt->size);
@@ -1270,6 +1590,9 @@ static int decode_frame(AVCodecContext *avctx, void *data,
return AVERROR_INVALIDDATA;
}
+ if (s->apply_trc_type != AVCOL_TRC_UNSPECIFIED)
+ avctx->color_trc = s->apply_trc_type;
+
switch (s->compression) {
case EXR_RAW:
case EXR_RLE:
@@ -1281,6 +1604,8 @@ static int decode_frame(AVCodecContext *avctx, void *data,
s->scan_lines_per_block = 16;
break;
case EXR_PIZ:
+ case EXR_B44:
+ case EXR_B44A:
s->scan_lines_per_block = 32;
break;
default:
@@ -1306,13 +1631,19 @@ static int decode_frame(AVCodecContext *avctx, void *data,
if (!s->desc)
return AVERROR_INVALIDDATA;
out_line_size = avctx->width * 2 * s->desc->nb_components;
- scan_line_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
- s->scan_lines_per_block;
+
+ if (s->is_tile) {
+ nb_blocks = ((s->xdelta + s->tile_attr.xSize - 1) / s->tile_attr.xSize) *
+ ((s->ydelta + s->tile_attr.ySize - 1) / s->tile_attr.ySize);
+ } else { /* scanline */
+ nb_blocks = (s->ydelta + s->scan_lines_per_block - 1) /
+ s->scan_lines_per_block;
+ }
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
return ret;
- if (bytestream2_get_bytes_left(&s->gb) < scan_line_blocks * 8)
+ if (bytestream2_get_bytes_left(&s->gb) < nb_blocks * 8)
return AVERROR_INVALIDDATA;
// save pointer we are going to use in decode_block
@@ -1327,7 +1658,8 @@ static int decode_frame(AVCodecContext *avctx, void *data,
}
s->picture = picture;
- avctx->execute2(avctx, decode_block, s->thread_data, NULL, scan_line_blocks);
+
+ avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
// Zero out the end if ymax+1 is not h
for (y = s->ymax + 1; y < avctx->height; y++) {
@@ -1347,36 +1679,31 @@ static av_cold int decode_init(AVCodecContext *avctx)
uint32_t i;
union av_intfloat32 t;
float one_gamma = 1.0f / s->gamma;
+ avpriv_trc_function trc_func = NULL;
s->avctx = avctx;
- s->xmin = ~0;
- s->xmax = ~0;
- s->ymin = ~0;
- s->ymax = ~0;
- s->xdelta = ~0;
- s->ydelta = ~0;
- s->channel_offsets[0] = -1;
- s->channel_offsets[1] = -1;
- s->channel_offsets[2] = -1;
- s->channel_offsets[3] = -1;
- s->pixel_type = EXR_UNKNOWN;
- s->compression = EXR_UNKN;
- s->nb_channels = 0;
- s->w = 0;
- s->h = 0;
- if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
- for (i = 0; i < 65536; ++i)
- s->gamma_table[i] = exr_halflt2uint(i);
- } else {
+ trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
+ if (trc_func) {
for (i = 0; i < 65536; ++i) {
t = exr_half2float(i);
- /* If negative value we reuse half value */
- if (t.f <= 0.0f) {
+ t.f = trc_func(t.f);
+ s->gamma_table[i] = exr_flt2uint(t.i);
+ }
+ } else {
+ if (one_gamma > 0.9999f && one_gamma < 1.0001f) {
+ for (i = 0; i < 65536; ++i)
s->gamma_table[i] = exr_halflt2uint(i);
- } else {
- t.f = powf(t.f, one_gamma);
- s->gamma_table[i] = exr_flt2uint(t.i);
+ } else {
+ for (i = 0; i < 65536; ++i) {
+ t = exr_half2float(i);
+ /* If negative value we reuse half value */
+ if (t.f <= 0.0f) {
+ s->gamma_table[i] = exr_halflt2uint(i);
+ } else {
+ t.f = powf(t.f, one_gamma);
+ s->gamma_table[i] = exr_flt2uint(t.i);
+ }
}
}
}
@@ -1389,6 +1716,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
return 0;
}
+#if HAVE_THREADS
static int decode_init_thread_copy(AVCodecContext *avctx)
{ EXRContext *s = avctx->priv_data;
@@ -1399,6 +1727,7 @@ static int decode_init_thread_copy(AVCodecContext *avctx)
return 0;
}
+#endif
static av_cold int decode_end(AVCodecContext *avctx)
{
@@ -1425,6 +1754,43 @@ static const AVOption options[] = {
AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
{ "gamma", "Set the float gamma value when decoding", OFFSET(gamma),
AV_OPT_TYPE_FLOAT, { .dbl = 1.0f }, 0.001, FLT_MAX, VD },
+
+ // XXX: Note the abuse of the enum using AVCOL_TRC_UNSPECIFIED to subsume the existing gamma option
+ { "apply_trc", "color transfer characteristics to apply to EXR linear input", OFFSET(apply_trc_type),
+ AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, VD, "apply_trc_type"},
+ { "bt709", "BT.709", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "gamma", "gamma", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "gamma22", "BT.470 M", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "gamma28", "BT.470 BG", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "smpte170m", "SMPTE 170 M", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "smpte240m", "SMPTE 240 M", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "linear", "Linear", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "log", "Log", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "log_sqrt", "Log square root", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "iec61966_2_4", "IEC 61966-2-4", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "bt1361", "BT.1361", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "iec61966_2_1", "IEC 61966-2-1", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "bt2020_10bit", "BT.2020 - 10 bit", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "bt2020_12bit", "BT.2020 - 12 bit", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "smpte2084", "SMPTE ST 2084", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+ { "smpte428_1", "SMPTE ST 428-1", 0,
+ AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, VD, "apply_trc_type"},
+
{ NULL },
};
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-09 14:18:53 +0000