FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/exrenc.c	Lines:	0	283	0.0 %
Date:	2021-04-20 15:25:36	Branches:	0	127	0.0 %


/*
 * Copyright (c) 2021 Paul B Mahol
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * OpenEXR encoder
 */

#include <float.h>
#include <zlib.h>

#include "libavutil/avassert.h"
#include "libavutil/opt.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/imgutils.h"
#include "libavutil/pixdesc.h"
#include "avcodec.h"
#include "bytestream.h"
#include "internal.h"
#include "float2half.h"

enum ExrCompr {
    EXR_RAW,
    EXR_RLE,
    EXR_ZIP1,
    EXR_ZIP16,
    EXR_NBCOMPR,
};

enum ExrPixelType {
    EXR_UINT,
    EXR_HALF,
    EXR_FLOAT,
    EXR_UNKNOWN,
};

static const char abgr_chlist[4] = { 'A', 'B', 'G', 'R' };
static const char bgr_chlist[4] = { 'B', 'G', 'R', 'A' };
static const uint8_t gbra_order[4] = { 3, 1, 0, 2 };
static const uint8_t gbr_order[4] = { 1, 0, 2, 0 };

typedef struct EXRScanlineData {
    uint8_t *compressed_data;
    unsigned int compressed_size;

    uint8_t *uncompressed_data;
    unsigned int uncompressed_size;

    uint8_t *tmp;
    unsigned int tmp_size;

    int64_t actual_size;
} EXRScanlineData;

typedef struct EXRContext {
    const AVClass *class;

    int compression;
    int pixel_type;
    int planes;
    int nb_scanlines;
    int scanline_height;
    float gamma;
    const char *ch_names;
    const uint8_t *ch_order;
    PutByteContext pb;

    EXRScanlineData *scanline;

    uint16_t basetable[512];
    uint8_t shifttable[512];
} EXRContext;

static int encode_init(AVCodecContext *avctx)
{
    EXRContext *s = avctx->priv_data;

    float2half_tables(s->basetable, s->shifttable);

    switch (avctx->pix_fmt) {
    case AV_PIX_FMT_GBRPF32:
        s->planes = 3;
        s->ch_names = bgr_chlist;
        s->ch_order = gbr_order;
        break;
    case AV_PIX_FMT_GBRAPF32:
        s->planes = 4;
        s->ch_names = abgr_chlist;
        s->ch_order = gbra_order;
        break;
    default:
        av_assert0(0);
    }

    switch (s->compression) {
    case EXR_RAW:
    case EXR_RLE:
    case EXR_ZIP1:
        s->scanline_height = 1;
        s->nb_scanlines = avctx->height;
        break;
    case EXR_ZIP16:
        s->scanline_height = 16;
        s->nb_scanlines = (avctx->height + s->scanline_height - 1) / s->scanline_height;
        break;
    default:
        av_assert0(0);
    }

    s->scanline = av_calloc(s->nb_scanlines, sizeof(*s->scanline));
    if (!s->scanline)
        return AVERROR(ENOMEM);

    return 0;
}

static int encode_close(AVCodecContext *avctx)
{
    EXRContext *s = avctx->priv_data;

    for (int y = 0; y < s->nb_scanlines && s->scanline; y++) {
        EXRScanlineData *scanline = &s->scanline[y];

        av_freep(&scanline->tmp);
        av_freep(&scanline->compressed_data);
        av_freep(&scanline->uncompressed_data);
    }

    av_freep(&s->scanline);

    return 0;
}

static void reorder_pixels(uint8_t *dst, const uint8_t *src, ptrdiff_t size)
{
    const ptrdiff_t half_size = (size + 1) / 2;
    uint8_t *t1 = dst;
    uint8_t *t2 = dst + half_size;

    for (ptrdiff_t i = 0; i < half_size; i++) {
        t1[i] = *(src++);
        t2[i] = *(src++);
    }
}

static void predictor(uint8_t *src, ptrdiff_t size)
{
    int p = src[0];

    for (ptrdiff_t i = 1; i < size; i++) {
        int d = src[i] - p + 384;

        p = src[i];
        src[i] = d;
    }
}

static int64_t rle_compress(uint8_t *out, int64_t out_size,
                            const uint8_t *in, int64_t in_size)
{
    int64_t i = 0, o = 0, run = 1, copy = 0;

    while (i < in_size) {
        while (i + run < in_size && in[i] == in[i + run] && run < 128)
            run++;

        if (run >= 3) {
            if (o + 2 >= out_size)
                return -1;
            out[o++] = run - 1;
            out[o++] = in[i];
            i += run;
        } else {
            if (i + run < in_size)
                copy += run;
            while (i + copy < in_size && copy < 127 && in[i + copy] != in[i + copy - 1])
                copy++;

            if (o + 1 + copy >= out_size)
                return -1;
            out[o++] = -copy;

            for (int x = 0; x < copy; x++)
                out[o + x] = in[i + x];

            o += copy;
            i += copy;
            copy = 0;
        }

        run = 1;
    }

    return o;
}

static int encode_scanline_rle(EXRContext *s, const AVFrame *frame)
{
    const int64_t element_size = s->pixel_type == EXR_HALF ? 2LL : 4LL;

    for (int y = 0; y < frame->height; y++) {
        EXRScanlineData *scanline = &s->scanline[y];
        int64_t tmp_size = element_size * s->planes * frame->width;
        int64_t max_compressed_size = tmp_size * 3 / 2;

        av_fast_padded_malloc(&scanline->uncompressed_data, &scanline->uncompressed_size, tmp_size);
        if (!scanline->uncompressed_data)
            return AVERROR(ENOMEM);

        av_fast_padded_malloc(&scanline->tmp, &scanline->tmp_size, tmp_size);
        if (!scanline->tmp)
            return AVERROR(ENOMEM);

        av_fast_padded_malloc(&scanline->compressed_data, &scanline->compressed_size, max_compressed_size);
        if (!scanline->compressed_data)
            return AVERROR(ENOMEM);

        switch (s->pixel_type) {
        case EXR_FLOAT:
            for (int p = 0; p < s->planes; p++) {
                int ch = s->ch_order[p];

                memcpy(scanline->uncompressed_data + frame->width * 4 * p,
                       frame->data[ch] + y * frame->linesize[ch], frame->width * 4);
            }
            break;
        case EXR_HALF:
            for (int p = 0; p < s->planes; p++) {
                int ch = s->ch_order[p];
                uint16_t *dst = (uint16_t *)(scanline->uncompressed_data + frame->width * 2 * p);
                uint32_t *src = (uint32_t *)(frame->data[ch] + y * frame->linesize[ch]);

                for (int x = 0; x < frame->width; x++)
                    dst[x] = float2half(src[x], s->basetable, s->shifttable);
            }
            break;
        }

        reorder_pixels(scanline->tmp, scanline->uncompressed_data, tmp_size);
        predictor(scanline->tmp, tmp_size);
        scanline->actual_size = rle_compress(scanline->compressed_data,
                                             max_compressed_size,
                                             scanline->tmp, tmp_size);

        if (scanline->actual_size <= 0 || scanline->actual_size >= tmp_size) {
            FFSWAP(uint8_t *, scanline->uncompressed_data, scanline->compressed_data);
            FFSWAP(int, scanline->uncompressed_size, scanline->compressed_size);
            scanline->actual_size = tmp_size;
        }
    }

    return 0;
}

static int encode_scanline_zip(EXRContext *s, const AVFrame *frame)
{
    const int64_t element_size = s->pixel_type == EXR_HALF ? 2LL : 4LL;

    for (int y = 0; y < s->nb_scanlines; y++) {
        EXRScanlineData *scanline = &s->scanline[y];
        const int scanline_height = FFMIN(s->scanline_height, frame->height - y * s->scanline_height);
        int64_t tmp_size = element_size * s->planes * frame->width * scanline_height;
        int64_t max_compressed_size = tmp_size * 3 / 2;
        unsigned long actual_size, source_size;

        av_fast_padded_malloc(&scanline->uncompressed_data, &scanline->uncompressed_size, tmp_size);
        if (!scanline->uncompressed_data)
            return AVERROR(ENOMEM);

        av_fast_padded_malloc(&scanline->tmp, &scanline->tmp_size, tmp_size);
        if (!scanline->tmp)
            return AVERROR(ENOMEM);

        av_fast_padded_malloc(&scanline->compressed_data, &scanline->compressed_size, max_compressed_size);
        if (!scanline->compressed_data)
            return AVERROR(ENOMEM);

        switch (s->pixel_type) {
        case EXR_FLOAT:
            for (int l = 0; l < scanline_height; l++) {
                const int scanline_size = frame->width * 4 * s->planes;

                for (int p = 0; p < s->planes; p++) {
                    int ch = s->ch_order[p];

                    memcpy(scanline->uncompressed_data + scanline_size * l + p * frame->width * 4,
                           frame->data[ch] + (y * s->scanline_height + l) * frame->linesize[ch],
                           frame->width * 4);
                }
            }
            break;
        case EXR_HALF:
            for (int l = 0; l < scanline_height; l++) {
                const int scanline_size = frame->width * 2 * s->planes;

                for (int p = 0; p < s->planes; p++) {
                    int ch = s->ch_order[p];
                    uint16_t *dst = (uint16_t *)(scanline->uncompressed_data + scanline_size * l + p * frame->width * 2);
                    uint32_t *src = (uint32_t *)(frame->data[ch] + (y * s->scanline_height + l) * frame->linesize[ch]);

                    for (int x = 0; x < frame->width; x++)
                        dst[x] = float2half(src[x], s->basetable, s->shifttable);
                }
            }
            break;
        }

        reorder_pixels(scanline->tmp, scanline->uncompressed_data, tmp_size);
        predictor(scanline->tmp, tmp_size);
        source_size = tmp_size;
        actual_size = max_compressed_size;
        compress(scanline->compressed_data, &actual_size,
                 scanline->tmp, source_size);

        scanline->actual_size = actual_size;
        if (scanline->actual_size >= tmp_size) {
            FFSWAP(uint8_t *, scanline->uncompressed_data, scanline->compressed_data);
            FFSWAP(int, scanline->uncompressed_size, scanline->compressed_size);
            scanline->actual_size = tmp_size;
        }
    }

    return 0;
}

static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                        const AVFrame *frame, int *got_packet)
{
    EXRContext *s = avctx->priv_data;
    PutByteContext *pb = &s->pb;
    int64_t offset;
    int ret;
    int64_t out_size = 2048LL + avctx->height * 16LL +
                      av_image_get_buffer_size(avctx->pix_fmt,
                                               avctx->width,
                                               avctx->height, 64) * 3LL / 2;

    if ((ret = ff_alloc_packet2(avctx, pkt, out_size, out_size)) < 0)
        return ret;

    bytestream2_init_writer(pb, pkt->data, pkt->size);

    bytestream2_put_le32(pb, 20000630);
    bytestream2_put_byte(pb, 2);
    bytestream2_put_le24(pb, 0);
    bytestream2_put_buffer(pb, "channels\0chlist\0", 16);
    bytestream2_put_le32(pb, s->planes * 18 + 1);

    for (int p = 0; p < s->planes; p++) {
        bytestream2_put_byte(pb, s->ch_names[p]);
        bytestream2_put_byte(pb, 0);
        bytestream2_put_le32(pb, s->pixel_type);
        bytestream2_put_le32(pb, 0);
        bytestream2_put_le32(pb, 1);
        bytestream2_put_le32(pb, 1);
    }
    bytestream2_put_byte(pb, 0);

    bytestream2_put_buffer(pb, "compression\0compression\0", 24);
    bytestream2_put_le32(pb, 1);
    bytestream2_put_byte(pb, s->compression);

    bytestream2_put_buffer(pb, "dataWindow\0box2i\0", 17);
    bytestream2_put_le32(pb, 16);
    bytestream2_put_le32(pb, 0);
    bytestream2_put_le32(pb, 0);
    bytestream2_put_le32(pb, avctx->width - 1);
    bytestream2_put_le32(pb, avctx->height - 1);

    bytestream2_put_buffer(pb, "displayWindow\0box2i\0", 20);
    bytestream2_put_le32(pb, 16);
    bytestream2_put_le32(pb, 0);
    bytestream2_put_le32(pb, 0);
    bytestream2_put_le32(pb, avctx->width - 1);
    bytestream2_put_le32(pb, avctx->height - 1);

    bytestream2_put_buffer(pb, "lineOrder\0lineOrder\0", 20);
    bytestream2_put_le32(pb, 1);
    bytestream2_put_byte(pb, 0);

    bytestream2_put_buffer(pb, "screenWindowCenter\0v2f\0", 23);
    bytestream2_put_le32(pb, 8);
    bytestream2_put_le64(pb, 0);

    bytestream2_put_buffer(pb, "screenWindowWidth\0float\0", 24);
    bytestream2_put_le32(pb, 4);
    bytestream2_put_le32(pb, av_float2int(1.f));

    if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
        bytestream2_put_buffer(pb, "pixelAspectRatio\0float\0", 23);
        bytestream2_put_le32(pb, 4);
        bytestream2_put_le32(pb, av_float2int(av_q2d(avctx->sample_aspect_ratio)));
    }

    if (avctx->framerate.num && avctx->framerate.den) {
        bytestream2_put_buffer(pb, "framesPerSecond\0rational\0", 25);
        bytestream2_put_le32(pb, 8);
        bytestream2_put_le32(pb, avctx->framerate.num);
        bytestream2_put_le32(pb, avctx->framerate.den);
    }

    bytestream2_put_buffer(pb, "gamma\0float\0", 12);
    bytestream2_put_le32(pb, 4);
    bytestream2_put_le32(pb, av_float2int(s->gamma));

    bytestream2_put_buffer(pb, "writer\0string\0", 14);
    bytestream2_put_le32(pb, 4);
    bytestream2_put_buffer(pb, "lavc", 4);
    bytestream2_put_byte(pb, 0);

    switch (s->compression) {
    case EXR_RAW:
        /* nothing to do */
        break;
    case EXR_RLE:
        encode_scanline_rle(s, frame);
        break;
    case EXR_ZIP16:
    case EXR_ZIP1:
        encode_scanline_zip(s, frame);
        break;
    default:
        av_assert0(0);
    }

    switch (s->compression) {
    case EXR_RAW:
        offset = bytestream2_tell_p(pb) + avctx->height * 8LL;

        if (s->pixel_type == EXR_FLOAT) {

            for (int y = 0; y < avctx->height; y++) {
                bytestream2_put_le64(pb, offset);
                offset += avctx->width * s->planes * 4 + 8;
            }

            for (int y = 0; y < avctx->height; y++) {
                bytestream2_put_le32(pb, y);
                bytestream2_put_le32(pb, s->planes * avctx->width * 4);
                for (int p = 0; p < s->planes; p++) {
                    int ch = s->ch_order[p];
                    bytestream2_put_buffer(pb, frame->data[ch] + y * frame->linesize[ch],
                                           avctx->width * 4);
                }
            }
        } else {
            for (int y = 0; y < avctx->height; y++) {
                bytestream2_put_le64(pb, offset);
                offset += avctx->width * s->planes * 2 + 8;
            }

            for (int y = 0; y < avctx->height; y++) {
                bytestream2_put_le32(pb, y);
                bytestream2_put_le32(pb, s->planes * avctx->width * 2);
                for (int p = 0; p < s->planes; p++) {
                    int ch = s->ch_order[p];
                    uint32_t *src = (uint32_t *)(frame->data[ch] + y * frame->linesize[ch]);

                    for (int x = 0; x < frame->width; x++)
                        bytestream2_put_le16(pb, float2half(src[x], s->basetable, s->shifttable));
                }
            }
        }
        break;
    case EXR_ZIP16:
    case EXR_ZIP1:
    case EXR_RLE:
        offset = bytestream2_tell_p(pb) + s->nb_scanlines * 8LL;

        for (int y = 0; y < s->nb_scanlines; y++) {
            EXRScanlineData *scanline = &s->scanline[y];

            bytestream2_put_le64(pb, offset);
            offset += scanline->actual_size + 8;
        }

        for (int y = 0; y < s->nb_scanlines; y++) {
            EXRScanlineData *scanline = &s->scanline[y];

            bytestream2_put_le32(pb, y * s->scanline_height);
            bytestream2_put_le32(pb, scanline->actual_size);
            bytestream2_put_buffer(pb, scanline->compressed_data,
                                   scanline->actual_size);
        }
        break;
    default:
        av_assert0(0);
    }

    av_shrink_packet(pkt, bytestream2_tell_p(pb));

    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;

    return 0;
}

#define OFFSET(x) offsetof(EXRContext, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
    { "compression", "set compression type", OFFSET(compression), AV_OPT_TYPE_INT,   {.i64=0}, 0, EXR_NBCOMPR-1, VE, "compr" },
    { "none",        "none",                 0,                   AV_OPT_TYPE_CONST, {.i64=EXR_RAW}, 0, 0, VE, "compr" },
    { "rle" ,        "RLE",                  0,                   AV_OPT_TYPE_CONST, {.i64=EXR_RLE}, 0, 0, VE, "compr" },
    { "zip1",        "ZIP1",                 0,                   AV_OPT_TYPE_CONST, {.i64=EXR_ZIP1}, 0, 0, VE, "compr" },
    { "zip16",       "ZIP16",                0,                   AV_OPT_TYPE_CONST, {.i64=EXR_ZIP16}, 0, 0, VE, "compr" },
    { "format", "set pixel type", OFFSET(pixel_type), AV_OPT_TYPE_INT,   {.i64=EXR_FLOAT}, EXR_HALF, EXR_UNKNOWN-1, VE, "pixel" },
    { "half" ,       NULL,                   0,                   AV_OPT_TYPE_CONST, {.i64=EXR_HALF},  0, 0, VE, "pixel" },
    { "float",       NULL,                   0,                   AV_OPT_TYPE_CONST, {.i64=EXR_FLOAT}, 0, 0, VE, "pixel" },
    { "gamma", "set gamma", OFFSET(gamma), AV_OPT_TYPE_FLOAT, {.dbl=1.f}, 0.001, FLT_MAX, VE },
    { NULL},
};

static const AVClass exr_class = {
    .class_name = "exr",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_exr_encoder = {
    .name           = "exr",
    .long_name      = NULL_IF_CONFIG_SMALL("OpenEXR image"),
    .priv_data_size = sizeof(EXRContext),
    .priv_class     = &exr_class,
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_EXR,
    .init           = encode_init,
    .encode2        = encode_frame,
    .close          = encode_close,
    .capabilities   = AV_CODEC_CAP_FRAME_THREADS,
    .pix_fmts       = (const enum AVPixelFormat[]) {
                                                 AV_PIX_FMT_GBRPF32,
                                                 AV_PIX_FMT_GBRAPF32,
                                                 AV_PIX_FMT_NONE },
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2021 Paul B Mahol
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			/**
22			* @file
23			* OpenEXR encoder
24			*/
25
26			#include <float.h>
27			#include <zlib.h>
28
29			#include "libavutil/avassert.h"
30			#include "libavutil/opt.h"
31			#include "libavutil/intreadwrite.h"
32			#include "libavutil/imgutils.h"
33			#include "libavutil/pixdesc.h"
34			#include "avcodec.h"
35			#include "bytestream.h"
36			#include "internal.h"
37			#include "float2half.h"
38
39			enum ExrCompr {
40			EXR_RAW,
41			EXR_RLE,
42			EXR_ZIP1,
43			EXR_ZIP16,
44			EXR_NBCOMPR,
45			};
46
47			enum ExrPixelType {
48			EXR_UINT,
49			EXR_HALF,
50			EXR_FLOAT,
51			EXR_UNKNOWN,
52			};
53
54			static const char abgr_chlist[4] = { 'A', 'B', 'G', 'R' };
55			static const char bgr_chlist[4] = { 'B', 'G', 'R', 'A' };
56			static const uint8_t gbra_order[4] = { 3, 1, 0, 2 };
57			static const uint8_t gbr_order[4] = { 1, 0, 2, 0 };
58
59			typedef struct EXRScanlineData {
60			uint8_t *compressed_data;
61			unsigned int compressed_size;
62
63			uint8_t *uncompressed_data;
64			unsigned int uncompressed_size;
65
66			uint8_t *tmp;
67			unsigned int tmp_size;
68
69			int64_t actual_size;
70			} EXRScanlineData;
71
72			typedef struct EXRContext {
73			const AVClass *class;
74
75			int compression;
76			int pixel_type;
77			int planes;
78			int nb_scanlines;
79			int scanline_height;
80			float gamma;
81			const char *ch_names;
82			const uint8_t *ch_order;
83			PutByteContext pb;
84
85			EXRScanlineData *scanline;
86
87			uint16_t basetable[512];
88			uint8_t shifttable[512];
89			} EXRContext;
90
91			static int encode_init(AVCodecContext *avctx)
92			{
93			EXRContext *s = avctx->priv_data;
94
95			float2half_tables(s->basetable, s->shifttable);
96
97			switch (avctx->pix_fmt) {
98			case AV_PIX_FMT_GBRPF32:
99			s->planes = 3;
100			s->ch_names = bgr_chlist;
101			s->ch_order = gbr_order;
102			break;
103			case AV_PIX_FMT_GBRAPF32:
104			s->planes = 4;
105			s->ch_names = abgr_chlist;
106			s->ch_order = gbra_order;
107			break;
108			default:
109			av_assert0(0);
110			}
111
112			switch (s->compression) {
113			case EXR_RAW:
114			case EXR_RLE:
115			case EXR_ZIP1:
116			s->scanline_height = 1;
117			s->nb_scanlines = avctx->height;
118			break;
119			case EXR_ZIP16:
120			s->scanline_height = 16;
121			s->nb_scanlines = (avctx->height + s->scanline_height - 1) / s->scanline_height;
122			break;
123			default:
124			av_assert0(0);
125			}
126
127			s->scanline = av_calloc(s->nb_scanlines, sizeof(*s->scanline));
128			if (!s->scanline)
129			return AVERROR(ENOMEM);
130
131			return 0;
132			}
133
134			static int encode_close(AVCodecContext *avctx)
135			{
136			EXRContext *s = avctx->priv_data;
137
138			for (int y = 0; y < s->nb_scanlines && s->scanline; y++) {
139			EXRScanlineData *scanline = &s->scanline[y];
140
141			av_freep(&scanline->tmp);
142			av_freep(&scanline->compressed_data);
143			av_freep(&scanline->uncompressed_data);
144			}
145
146			av_freep(&s->scanline);
147
148			return 0;
149			}
150
151			static void reorder_pixels(uint8_t dst, const uint8_t src, ptrdiff_t size)
152			{
153			const ptrdiff_t half_size = (size + 1) / 2;
154			uint8_t *t1 = dst;
155			uint8_t *t2 = dst + half_size;
156
157			for (ptrdiff_t i = 0; i < half_size; i++) {
158			t1[i] = *(src++);
159			t2[i] = *(src++);
160			}
161			}
162
163			static void predictor(uint8_t *src, ptrdiff_t size)
164			{
165			int p = src[0];
166
167			for (ptrdiff_t i = 1; i < size; i++) {
168			int d = src[i] - p + 384;
169
170			p = src[i];
171			src[i] = d;
172			}
173			}
174
175			static int64_t rle_compress(uint8_t *out, int64_t out_size,
176			const uint8_t *in, int64_t in_size)
177			{
178			int64_t i = 0, o = 0, run = 1, copy = 0;
179
180			while (i < in_size) {
181			while (i + run < in_size && in[i] == in[i + run] && run < 128)
182			run++;
183
184			if (run >= 3) {
185			if (o + 2 >= out_size)
186			return -1;
187			out[o++] = run - 1;
188			out[o++] = in[i];
189			i += run;
190			} else {
191			if (i + run < in_size)
192			copy += run;
193			while (i + copy < in_size && copy < 127 && in[i + copy] != in[i + copy - 1])
194			copy++;
195
196			if (o + 1 + copy >= out_size)
197			return -1;
198			out[o++] = -copy;
199
200			for (int x = 0; x < copy; x++)
201			out[o + x] = in[i + x];
202
203			o += copy;
204			i += copy;
205			copy = 0;
206			}
207
208			run = 1;
209			}
210
211			return o;
212			}
213
214			static int encode_scanline_rle(EXRContext s, const AVFrame frame)
215			{
216			const int64_t element_size = s->pixel_type == EXR_HALF ? 2LL : 4LL;
217
218			for (int y = 0; y < frame->height; y++) {
219			EXRScanlineData *scanline = &s->scanline[y];
220			int64_t tmp_size = element_size * s->planes * frame->width;
221			int64_t max_compressed_size = tmp_size * 3 / 2;
222
223			av_fast_padded_malloc(&scanline->uncompressed_data, &scanline->uncompressed_size, tmp_size);
224			if (!scanline->uncompressed_data)
225			return AVERROR(ENOMEM);
226
227			av_fast_padded_malloc(&scanline->tmp, &scanline->tmp_size, tmp_size);
228			if (!scanline->tmp)
229			return AVERROR(ENOMEM);
230
231			av_fast_padded_malloc(&scanline->compressed_data, &scanline->compressed_size, max_compressed_size);
232			if (!scanline->compressed_data)
233			return AVERROR(ENOMEM);
234
235			switch (s->pixel_type) {
236			case EXR_FLOAT:
237			for (int p = 0; p < s->planes; p++) {
238			int ch = s->ch_order[p];
239
240			memcpy(scanline->uncompressed_data + frame->width * 4 * p,
241			frame->data[ch] + y * frame->linesize[ch], frame->width * 4);
242			}
243			break;
244			case EXR_HALF:
245			for (int p = 0; p < s->planes; p++) {
246			int ch = s->ch_order[p];
247			uint16_t dst = (uint16_t )(scanline->uncompressed_data + frame->width * 2 * p);
248			uint32_t src = (uint32_t )(frame->data[ch] + y * frame->linesize[ch]);
249
250			for (int x = 0; x < frame->width; x++)
251			dst[x] = float2half(src[x], s->basetable, s->shifttable);
252			}
253			break;
254			}
255
256			reorder_pixels(scanline->tmp, scanline->uncompressed_data, tmp_size);
257			predictor(scanline->tmp, tmp_size);
258			scanline->actual_size = rle_compress(scanline->compressed_data,
259			max_compressed_size,
260			scanline->tmp, tmp_size);
261
262			if (scanline->actual_size <= 0 \|\| scanline->actual_size >= tmp_size) {
263			FFSWAP(uint8_t *, scanline->uncompressed_data, scanline->compressed_data);
264			FFSWAP(int, scanline->uncompressed_size, scanline->compressed_size);
265			scanline->actual_size = tmp_size;
266			}
267			}
268
269			return 0;
270			}
271
272			static int encode_scanline_zip(EXRContext s, const AVFrame frame)
273			{
274			const int64_t element_size = s->pixel_type == EXR_HALF ? 2LL : 4LL;
275
276			for (int y = 0; y < s->nb_scanlines; y++) {
277			EXRScanlineData *scanline = &s->scanline[y];
278			const int scanline_height = FFMIN(s->scanline_height, frame->height - y * s->scanline_height);
279			int64_t tmp_size = element_size * s->planes * frame->width * scanline_height;
280			int64_t max_compressed_size = tmp_size * 3 / 2;
281			unsigned long actual_size, source_size;
282
283			av_fast_padded_malloc(&scanline->uncompressed_data, &scanline->uncompressed_size, tmp_size);
284			if (!scanline->uncompressed_data)
285			return AVERROR(ENOMEM);
286
287			av_fast_padded_malloc(&scanline->tmp, &scanline->tmp_size, tmp_size);
288			if (!scanline->tmp)
289			return AVERROR(ENOMEM);
290
291			av_fast_padded_malloc(&scanline->compressed_data, &scanline->compressed_size, max_compressed_size);
292			if (!scanline->compressed_data)
293			return AVERROR(ENOMEM);
294
295			switch (s->pixel_type) {
296			case EXR_FLOAT:
297			for (int l = 0; l < scanline_height; l++) {
298			const int scanline_size = frame->width * 4 * s->planes;
299
300			for (int p = 0; p < s->planes; p++) {
301			int ch = s->ch_order[p];
302
303			memcpy(scanline->uncompressed_data + scanline_size * l + p * frame->width * 4,
304			frame->data[ch] + (y * s->scanline_height + l) * frame->linesize[ch],
305			frame->width * 4);
306			}
307			}
308			break;
309			case EXR_HALF:
310			for (int l = 0; l < scanline_height; l++) {
311			const int scanline_size = frame->width * 2 * s->planes;
312
313			for (int p = 0; p < s->planes; p++) {
314			int ch = s->ch_order[p];
315			uint16_t dst = (uint16_t )(scanline->uncompressed_data + scanline_size * l + p * frame->width * 2);
316			uint32_t src = (uint32_t )(frame->data[ch] + (y * s->scanline_height + l) * frame->linesize[ch]);
317
318			for (int x = 0; x < frame->width; x++)
319			dst[x] = float2half(src[x], s->basetable, s->shifttable);
320			}
321			}
322			break;
323			}
324
325			reorder_pixels(scanline->tmp, scanline->uncompressed_data, tmp_size);
326			predictor(scanline->tmp, tmp_size);
327			source_size = tmp_size;
328			actual_size = max_compressed_size;
329			compress(scanline->compressed_data, &actual_size,
330			scanline->tmp, source_size);
331
332			scanline->actual_size = actual_size;
333			if (scanline->actual_size >= tmp_size) {
334			FFSWAP(uint8_t *, scanline->uncompressed_data, scanline->compressed_data);
335			FFSWAP(int, scanline->uncompressed_size, scanline->compressed_size);
336			scanline->actual_size = tmp_size;
337			}
338			}
339
340			return 0;
341			}
342
343			static int encode_frame(AVCodecContext avctx, AVPacket pkt,
344			const AVFrame frame, int got_packet)
345			{
346			EXRContext *s = avctx->priv_data;
347			PutByteContext *pb = &s->pb;
348			int64_t offset;
349			int ret;
350			int64_t out_size = 2048LL + avctx->height * 16LL +
351			av_image_get_buffer_size(avctx->pix_fmt,
352			avctx->width,
353			avctx->height, 64) * 3LL / 2;
354
355			if ((ret = ff_alloc_packet2(avctx, pkt, out_size, out_size)) < 0)
356			return ret;
357
358			bytestream2_init_writer(pb, pkt->data, pkt->size);
359
360			bytestream2_put_le32(pb, 20000630);
361			bytestream2_put_byte(pb, 2);
362			bytestream2_put_le24(pb, 0);
363			bytestream2_put_buffer(pb, "channels\0chlist\0", 16);
364			bytestream2_put_le32(pb, s->planes * 18 + 1);
365
366			for (int p = 0; p < s->planes; p++) {
367			bytestream2_put_byte(pb, s->ch_names[p]);
368			bytestream2_put_byte(pb, 0);
369			bytestream2_put_le32(pb, s->pixel_type);
370			bytestream2_put_le32(pb, 0);
371			bytestream2_put_le32(pb, 1);
372			bytestream2_put_le32(pb, 1);
373			}
374			bytestream2_put_byte(pb, 0);
375
376			bytestream2_put_buffer(pb, "compression\0compression\0", 24);
377			bytestream2_put_le32(pb, 1);
378			bytestream2_put_byte(pb, s->compression);
379
380			bytestream2_put_buffer(pb, "dataWindow\0box2i\0", 17);
381			bytestream2_put_le32(pb, 16);
382			bytestream2_put_le32(pb, 0);
383			bytestream2_put_le32(pb, 0);
384			bytestream2_put_le32(pb, avctx->width - 1);
385			bytestream2_put_le32(pb, avctx->height - 1);
386
387			bytestream2_put_buffer(pb, "displayWindow\0box2i\0", 20);
388			bytestream2_put_le32(pb, 16);
389			bytestream2_put_le32(pb, 0);
390			bytestream2_put_le32(pb, 0);
391			bytestream2_put_le32(pb, avctx->width - 1);
392			bytestream2_put_le32(pb, avctx->height - 1);
393
394			bytestream2_put_buffer(pb, "lineOrder\0lineOrder\0", 20);
395			bytestream2_put_le32(pb, 1);
396			bytestream2_put_byte(pb, 0);
397
398			bytestream2_put_buffer(pb, "screenWindowCenter\0v2f\0", 23);
399			bytestream2_put_le32(pb, 8);
400			bytestream2_put_le64(pb, 0);
401
402			bytestream2_put_buffer(pb, "screenWindowWidth\0float\0", 24);
403			bytestream2_put_le32(pb, 4);
404			bytestream2_put_le32(pb, av_float2int(1.f));
405
406			if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
407			bytestream2_put_buffer(pb, "pixelAspectRatio\0float\0", 23);
408			bytestream2_put_le32(pb, 4);
409			bytestream2_put_le32(pb, av_float2int(av_q2d(avctx->sample_aspect_ratio)));
410			}
411
412			if (avctx->framerate.num && avctx->framerate.den) {
413			bytestream2_put_buffer(pb, "framesPerSecond\0rational\0", 25);
414			bytestream2_put_le32(pb, 8);
415			bytestream2_put_le32(pb, avctx->framerate.num);
416			bytestream2_put_le32(pb, avctx->framerate.den);
417			}
418
419			bytestream2_put_buffer(pb, "gamma\0float\0", 12);
420			bytestream2_put_le32(pb, 4);
421			bytestream2_put_le32(pb, av_float2int(s->gamma));
422
423			bytestream2_put_buffer(pb, "writer\0string\0", 14);
424			bytestream2_put_le32(pb, 4);
425			bytestream2_put_buffer(pb, "lavc", 4);
426			bytestream2_put_byte(pb, 0);
427
428			switch (s->compression) {
429			case EXR_RAW:
430			/* nothing to do */
431			break;
432			case EXR_RLE:
433			encode_scanline_rle(s, frame);
434			break;
435			case EXR_ZIP16:
436			case EXR_ZIP1:
437			encode_scanline_zip(s, frame);
438			break;
439			default:
440			av_assert0(0);
441			}
442
443			switch (s->compression) {
444			case EXR_RAW:
445			offset = bytestream2_tell_p(pb) + avctx->height * 8LL;
446
447			if (s->pixel_type == EXR_FLOAT) {
448
449			for (int y = 0; y < avctx->height; y++) {
450			bytestream2_put_le64(pb, offset);
451			offset += avctx->width * s->planes * 4 + 8;
452			}
453
454			for (int y = 0; y < avctx->height; y++) {
455			bytestream2_put_le32(pb, y);
456			bytestream2_put_le32(pb, s->planes * avctx->width * 4);
457			for (int p = 0; p < s->planes; p++) {
458			int ch = s->ch_order[p];
459			bytestream2_put_buffer(pb, frame->data[ch] + y * frame->linesize[ch],
460			avctx->width * 4);
461			}
462			}
463			} else {
464			for (int y = 0; y < avctx->height; y++) {
465			bytestream2_put_le64(pb, offset);
466			offset += avctx->width * s->planes * 2 + 8;
467			}
468
469			for (int y = 0; y < avctx->height; y++) {
470			bytestream2_put_le32(pb, y);
471			bytestream2_put_le32(pb, s->planes * avctx->width * 2);
472			for (int p = 0; p < s->planes; p++) {
473			int ch = s->ch_order[p];
474			uint32_t src = (uint32_t )(frame->data[ch] + y * frame->linesize[ch]);
475
476			for (int x = 0; x < frame->width; x++)
477			bytestream2_put_le16(pb, float2half(src[x], s->basetable, s->shifttable));
478			}
479			}
480			}
481			break;
482			case EXR_ZIP16:
483			case EXR_ZIP1:
484			case EXR_RLE:
485			offset = bytestream2_tell_p(pb) + s->nb_scanlines * 8LL;
486
487			for (int y = 0; y < s->nb_scanlines; y++) {
488			EXRScanlineData *scanline = &s->scanline[y];
489
490			bytestream2_put_le64(pb, offset);
491			offset += scanline->actual_size + 8;
492			}
493
494			for (int y = 0; y < s->nb_scanlines; y++) {
495			EXRScanlineData *scanline = &s->scanline[y];
496
497			bytestream2_put_le32(pb, y * s->scanline_height);
498			bytestream2_put_le32(pb, scanline->actual_size);
499			bytestream2_put_buffer(pb, scanline->compressed_data,
500			scanline->actual_size);
501			}
502			break;
503			default:
504			av_assert0(0);
505			}
506
507			av_shrink_packet(pkt, bytestream2_tell_p(pb));
508
509			pkt->flags \|= AV_PKT_FLAG_KEY;
510			*got_packet = 1;
511
512			return 0;
513			}
514
515			#define OFFSET(x) offsetof(EXRContext, x)
516			#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM
517			static const AVOption options[] = {
518			{ "compression", "set compression type", OFFSET(compression), AV_OPT_TYPE_INT, {.i64=0}, 0, EXR_NBCOMPR-1, VE, "compr" },
519			{ "none", "none", 0, AV_OPT_TYPE_CONST, {.i64=EXR_RAW}, 0, 0, VE, "compr" },
520			{ "rle" , "RLE", 0, AV_OPT_TYPE_CONST, {.i64=EXR_RLE}, 0, 0, VE, "compr" },
521			{ "zip1", "ZIP1", 0, AV_OPT_TYPE_CONST, {.i64=EXR_ZIP1}, 0, 0, VE, "compr" },
522			{ "zip16", "ZIP16", 0, AV_OPT_TYPE_CONST, {.i64=EXR_ZIP16}, 0, 0, VE, "compr" },
523			{ "format", "set pixel type", OFFSET(pixel_type), AV_OPT_TYPE_INT, {.i64=EXR_FLOAT}, EXR_HALF, EXR_UNKNOWN-1, VE, "pixel" },
524			{ "half" , NULL, 0, AV_OPT_TYPE_CONST, {.i64=EXR_HALF}, 0, 0, VE, "pixel" },
525			{ "float", NULL, 0, AV_OPT_TYPE_CONST, {.i64=EXR_FLOAT}, 0, 0, VE, "pixel" },
526			{ "gamma", "set gamma", OFFSET(gamma), AV_OPT_TYPE_FLOAT, {.dbl=1.f}, 0.001, FLT_MAX, VE },
527			{ NULL},
528			};
529
530			static const AVClass exr_class = {
531			.class_name = "exr",
532			.item_name = av_default_item_name,
533			.option = options,
534			.version = LIBAVUTIL_VERSION_INT,
535			};
536
537			AVCodec ff_exr_encoder = {
538			.name = "exr",
539			.long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
540			.priv_data_size = sizeof(EXRContext),
541			.priv_class = &exr_class,
542			.type = AVMEDIA_TYPE_VIDEO,
543			.id = AV_CODEC_ID_EXR,
544			.init = encode_init,
545			.encode2 = encode_frame,
546			.close = encode_close,
547			.capabilities = AV_CODEC_CAP_FRAME_THREADS,
548			.pix_fmts = (const enum AVPixelFormat[]) {
549			AV_PIX_FMT_GBRPF32,
550			AV_PIX_FMT_GBRAPF32,
551			AV_PIX_FMT_NONE },
552			};