Go to the documentation of this file.
56 static const char bgr_chlist[4] = {
'B',
'G',
'R',
'A' };
119 switch (
s->compression) {
123 s->scanline_height = 1;
124 s->nb_scanlines = avctx->
height;
127 s->scanline_height = 16;
128 s->nb_scanlines = (avctx->
height +
s->scanline_height - 1) /
s->scanline_height;
134 s->scanline =
av_calloc(
s->nb_scanlines,
sizeof(*
s->scanline));
145 for (
int y = 0; y <
s->nb_scanlines &&
s->scanline; y++) {
160 const ptrdiff_t half_size = (
size + 1) / 2;
162 uint8_t *
t2 = dst + half_size;
164 for (ptrdiff_t
i = 0;
i < half_size;
i++) {
174 for (ptrdiff_t
i = 1;
i <
size;
i++) {
175 int d =
src[
i] - p + 384;
183 const uint8_t *in, int64_t in_size)
185 int64_t
i = 0, o = 0,
run = 1,
copy = 0;
187 while (
i < in_size) {
188 while (
i +
run < in_size && in[
i] == in[
i +
run] &&
run < 128)
198 if (
i +
run < in_size)
207 for (
int x = 0; x <
copy; x++)
208 out[o + x] = in[
i + x];
223 const int64_t element_size =
s->pixel_type ==
EXR_HALF ? 2LL : 4LL;
225 for (
int y = 0; y <
frame->height; y++) {
227 int64_t tmp_size = element_size *
s->planes *
frame->width;
228 int64_t max_compressed_size = tmp_size * 3 / 2;
242 switch (
s->pixel_type) {
244 for (
int p = 0; p <
s->planes; p++) {
245 int ch =
s->ch_order[p];
252 for (
int p = 0; p <
s->planes; p++) {
253 int ch =
s->ch_order[p];
255 const uint32_t *
src = (
const uint32_t *)(
frame->data[ch] + y *
frame->linesize[ch]);
257 for (
int x = 0; x <
frame->width; x++)
267 scanline->
tmp, tmp_size);
281 const int64_t element_size =
s->pixel_type ==
EXR_HALF ? 2LL : 4LL;
283 for (
int y = 0; y <
s->nb_scanlines; y++) {
285 const int scanline_height =
FFMIN(
s->scanline_height,
frame->height - y *
s->scanline_height);
286 int64_t tmp_size = element_size *
s->planes *
frame->width * scanline_height;
287 int64_t max_compressed_size = tmp_size * 3 / 2;
288 unsigned long actual_size, source_size;
302 switch (
s->pixel_type) {
304 for (
int l = 0; l < scanline_height; l++) {
305 const int scanline_size =
frame->width * 4 *
s->planes;
307 for (
int p = 0; p <
s->planes; p++) {
308 int ch =
s->ch_order[p];
311 frame->data[ch] + (y *
s->scanline_height + l) *
frame->linesize[ch],
317 for (
int l = 0; l < scanline_height; l++) {
318 const int scanline_size =
frame->width * 2 *
s->planes;
320 for (
int p = 0; p <
s->planes; p++) {
321 int ch =
s->ch_order[p];
323 const uint32_t *
src = (
const uint32_t *)(
frame->data[ch] + (y *
s->scanline_height + l) *
frame->linesize[ch]);
325 for (
int x = 0; x <
frame->width; x++)
334 source_size = tmp_size;
335 actual_size = max_compressed_size;
337 scanline->
tmp, source_size);
360 avctx->
height, 64) * 3LL / 2;
367 bytestream2_put_le32(pb, 20000630);
368 bytestream2_put_byte(pb, 2);
369 bytestream2_put_le24(pb, 0);
371 bytestream2_put_le32(pb,
s->planes * 18 + 1);
373 for (
int p = 0; p <
s->planes; p++) {
374 bytestream2_put_byte(pb,
s->ch_names[p]);
375 bytestream2_put_byte(pb, 0);
376 bytestream2_put_le32(pb,
s->pixel_type);
377 bytestream2_put_le32(pb, 0);
378 bytestream2_put_le32(pb, 1);
379 bytestream2_put_le32(pb, 1);
381 bytestream2_put_byte(pb, 0);
384 bytestream2_put_le32(pb, 1);
385 bytestream2_put_byte(pb,
s->compression);
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);
395 bytestream2_put_le32(pb, 16);
396 bytestream2_put_le32(pb, 0);
397 bytestream2_put_le32(pb, 0);
398 bytestream2_put_le32(pb, avctx->
width - 1);
399 bytestream2_put_le32(pb, avctx->
height - 1);
402 bytestream2_put_le32(pb, 1);
403 bytestream2_put_byte(pb, 0);
406 bytestream2_put_le32(pb, 8);
407 bytestream2_put_le64(pb, 0);
410 bytestream2_put_le32(pb, 4);
415 bytestream2_put_le32(pb, 4);
421 bytestream2_put_le32(pb, 8);
427 bytestream2_put_le32(pb, 4);
431 bytestream2_put_le32(pb, 4);
433 bytestream2_put_byte(pb, 0);
435 switch (
s->compression) {
450 switch (
s->compression) {
456 for (
int y = 0; y < avctx->
height; y++) {
457 bytestream2_put_le64(pb,
offset);
461 for (
int y = 0; y < avctx->
height; y++) {
462 bytestream2_put_le32(pb, y);
463 bytestream2_put_le32(pb,
s->planes * avctx->
width * 4);
464 for (
int p = 0; p <
s->planes; p++) {
465 int ch =
s->ch_order[p];
471 for (
int y = 0; y < avctx->
height; y++) {
472 bytestream2_put_le64(pb,
offset);
476 for (
int y = 0; y < avctx->
height; y++) {
477 bytestream2_put_le32(pb, y);
478 bytestream2_put_le32(pb,
s->planes * avctx->
width * 2);
479 for (
int p = 0; p <
s->planes; p++) {
480 int ch =
s->ch_order[p];
481 const uint32_t *
src = (
const uint32_t *)(
frame->data[ch] + y *
frame->linesize[ch]);
483 for (
int x = 0; x <
frame->width; x++)
494 for (
int y = 0; y <
s->nb_scanlines; y++) {
497 bytestream2_put_le64(pb,
offset);
501 for (
int y = 0; y <
s->nb_scanlines; y++) {
504 bytestream2_put_le32(pb, y *
s->scanline_height);
521 #define OFFSET(x) offsetof(EXRContext, x)
522 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
AVPixelFormat
Pixel format.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
void ff_init_float2half_tables(Float2HalfTables *t)
This structure describes decoded (raw) audio or video data.
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
static const uint8_t gbra_order[4]
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
static const AVClass exr_class
AVCodec p
The public AVCodec.
uint8_t * uncompressed_data
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
static const char abgr_chlist[4]
#define FF_CODEC_ENCODE_CB(func)
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
static const uint8_t gbr_order[4]
static double av_q2d(AVRational a)
Convert an AVRational to a double.
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
EXRScanlineData * scanline
#define AV_PIX_FMT_GRAYF32
#define CODEC_LONG_NAME(str)
static const char bgr_chlist[4]
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define LIBAVUTIL_VERSION_INT
static int64_t rle_compress(uint8_t *out, int64_t out_size, const uint8_t *in, int64_t in_size)
Describe the class of an AVClass context structure.
const char * av_default_item_name(void *ptr)
Return the context name.
Float2HalfTables f2h_tables
static int encode_scanline_zip(EXRContext *s, const AVFrame *frame)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
static void copy(const float *p1, float *p2, const int length)
#define AV_PIX_FMT_GBRPF32
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
const FFCodec ff_exr_encoder
static av_cold int encode_init(AVCodecContext *avctx)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static void predictor(uint8_t *src, ptrdiff_t size)
static const uint8_t y_order[4]
uint8_t * compressed_data
static av_cold int encode_close(AVCodecContext *avctx)
unsigned int compressed_size
unsigned int uncompressed_size
#define i(width, name, range_min, range_max)
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
const char * name
Name of the codec implementation.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void * av_calloc(size_t nmemb, size_t size)
static const AVOption options[]
static int encode_scanline_rle(EXRContext *s, const AVFrame *frame)
#define FFSWAP(type, a, b)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static uint16_t float2half(uint32_t f, const Float2HalfTables *t)
static void reorder_pixels(uint8_t *dst, const uint8_t *src, ptrdiff_t size)
main external API structure.
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
#define AV_PIX_FMT_GBRAPF32
static const char y_chlist[4]
This structure stores compressed data.
int width
picture width / height.
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.