FFmpeg
exrenc.c
Go to the documentation of this file.
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 "encode.h"
37 #include "internal.h"
38 #include "float2half.h"
39 
40 enum ExrCompr {
46 };
47 
53 };
54 
55 static const char abgr_chlist[4] = { 'A', 'B', 'G', 'R' };
56 static const char bgr_chlist[4] = { 'B', 'G', 'R', 'A' };
57 static const uint8_t gbra_order[4] = { 3, 1, 0, 2 };
58 static const uint8_t gbr_order[4] = { 1, 0, 2, 0 };
59 
60 typedef struct EXRScanlineData {
61  uint8_t *compressed_data;
62  unsigned int compressed_size;
63 
65  unsigned int uncompressed_size;
66 
67  uint8_t *tmp;
68  unsigned int tmp_size;
69 
70  int64_t actual_size;
72 
73 typedef struct EXRContext {
74  const AVClass *class;
75 
78  int planes;
81  float gamma;
82  const char *ch_names;
83  const uint8_t *ch_order;
85 
87 
88  uint16_t basetable[512];
89  uint8_t shifttable[512];
90 } EXRContext;
91 
92 static int encode_init(AVCodecContext *avctx)
93 {
94  EXRContext *s = avctx->priv_data;
95 
96  float2half_tables(s->basetable, s->shifttable);
97 
98  switch (avctx->pix_fmt) {
99  case AV_PIX_FMT_GBRPF32:
100  s->planes = 3;
101  s->ch_names = bgr_chlist;
102  s->ch_order = gbr_order;
103  break;
104  case AV_PIX_FMT_GBRAPF32:
105  s->planes = 4;
106  s->ch_names = abgr_chlist;
107  s->ch_order = gbra_order;
108  break;
109  default:
110  av_assert0(0);
111  }
112 
113  switch (s->compression) {
114  case EXR_RAW:
115  case EXR_RLE:
116  case EXR_ZIP1:
117  s->scanline_height = 1;
118  s->nb_scanlines = avctx->height;
119  break;
120  case EXR_ZIP16:
121  s->scanline_height = 16;
122  s->nb_scanlines = (avctx->height + s->scanline_height - 1) / s->scanline_height;
123  break;
124  default:
125  av_assert0(0);
126  }
127 
128  s->scanline = av_calloc(s->nb_scanlines, sizeof(*s->scanline));
129  if (!s->scanline)
130  return AVERROR(ENOMEM);
131 
132  return 0;
133 }
134 
135 static int encode_close(AVCodecContext *avctx)
136 {
137  EXRContext *s = avctx->priv_data;
138 
139  for (int y = 0; y < s->nb_scanlines && s->scanline; y++) {
140  EXRScanlineData *scanline = &s->scanline[y];
141 
142  av_freep(&scanline->tmp);
143  av_freep(&scanline->compressed_data);
144  av_freep(&scanline->uncompressed_data);
145  }
146 
147  av_freep(&s->scanline);
148 
149  return 0;
150 }
151 
152 static void reorder_pixels(uint8_t *dst, const uint8_t *src, ptrdiff_t size)
153 {
154  const ptrdiff_t half_size = (size + 1) / 2;
155  uint8_t *t1 = dst;
156  uint8_t *t2 = dst + half_size;
157 
158  for (ptrdiff_t i = 0; i < half_size; i++) {
159  t1[i] = *(src++);
160  t2[i] = *(src++);
161  }
162 }
163 
164 static void predictor(uint8_t *src, ptrdiff_t size)
165 {
166  int p = src[0];
167 
168  for (ptrdiff_t i = 1; i < size; i++) {
169  int d = src[i] - p + 384;
170 
171  p = src[i];
172  src[i] = d;
173  }
174 }
175 
176 static int64_t rle_compress(uint8_t *out, int64_t out_size,
177  const uint8_t *in, int64_t in_size)
178 {
179  int64_t i = 0, o = 0, run = 1, copy = 0;
180 
181  while (i < in_size) {
182  while (i + run < in_size && in[i] == in[i + run] && run < 128)
183  run++;
184 
185  if (run >= 3) {
186  if (o + 2 >= out_size)
187  return -1;
188  out[o++] = run - 1;
189  out[o++] = in[i];
190  i += run;
191  } else {
192  if (i + run < in_size)
193  copy += run;
194  while (i + copy < in_size && copy < 127 && in[i + copy] != in[i + copy - 1])
195  copy++;
196 
197  if (o + 1 + copy >= out_size)
198  return -1;
199  out[o++] = -copy;
200 
201  for (int x = 0; x < copy; x++)
202  out[o + x] = in[i + x];
203 
204  o += copy;
205  i += copy;
206  copy = 0;
207  }
208 
209  run = 1;
210  }
211 
212  return o;
213 }
214 
216 {
217  const int64_t element_size = s->pixel_type == EXR_HALF ? 2LL : 4LL;
218 
219  for (int y = 0; y < frame->height; y++) {
220  EXRScanlineData *scanline = &s->scanline[y];
221  int64_t tmp_size = element_size * s->planes * frame->width;
222  int64_t max_compressed_size = tmp_size * 3 / 2;
223 
224  av_fast_padded_malloc(&scanline->uncompressed_data, &scanline->uncompressed_size, tmp_size);
225  if (!scanline->uncompressed_data)
226  return AVERROR(ENOMEM);
227 
228  av_fast_padded_malloc(&scanline->tmp, &scanline->tmp_size, tmp_size);
229  if (!scanline->tmp)
230  return AVERROR(ENOMEM);
231 
232  av_fast_padded_malloc(&scanline->compressed_data, &scanline->compressed_size, max_compressed_size);
233  if (!scanline->compressed_data)
234  return AVERROR(ENOMEM);
235 
236  switch (s->pixel_type) {
237  case EXR_FLOAT:
238  for (int p = 0; p < s->planes; p++) {
239  int ch = s->ch_order[p];
240 
241  memcpy(scanline->uncompressed_data + frame->width * 4 * p,
242  frame->data[ch] + y * frame->linesize[ch], frame->width * 4);
243  }
244  break;
245  case EXR_HALF:
246  for (int p = 0; p < s->planes; p++) {
247  int ch = s->ch_order[p];
248  uint16_t *dst = (uint16_t *)(scanline->uncompressed_data + frame->width * 2 * p);
249  uint32_t *src = (uint32_t *)(frame->data[ch] + y * frame->linesize[ch]);
250 
251  for (int x = 0; x < frame->width; x++)
252  dst[x] = float2half(src[x], s->basetable, s->shifttable);
253  }
254  break;
255  }
256 
257  reorder_pixels(scanline->tmp, scanline->uncompressed_data, tmp_size);
258  predictor(scanline->tmp, tmp_size);
259  scanline->actual_size = rle_compress(scanline->compressed_data,
260  max_compressed_size,
261  scanline->tmp, tmp_size);
262 
263  if (scanline->actual_size <= 0 || scanline->actual_size >= tmp_size) {
264  FFSWAP(uint8_t *, scanline->uncompressed_data, scanline->compressed_data);
265  FFSWAP(int, scanline->uncompressed_size, scanline->compressed_size);
266  scanline->actual_size = tmp_size;
267  }
268  }
269 
270  return 0;
271 }
272 
274 {
275  const int64_t element_size = s->pixel_type == EXR_HALF ? 2LL : 4LL;
276 
277  for (int y = 0; y < s->nb_scanlines; y++) {
278  EXRScanlineData *scanline = &s->scanline[y];
279  const int scanline_height = FFMIN(s->scanline_height, frame->height - y * s->scanline_height);
280  int64_t tmp_size = element_size * s->planes * frame->width * scanline_height;
281  int64_t max_compressed_size = tmp_size * 3 / 2;
282  unsigned long actual_size, source_size;
283 
284  av_fast_padded_malloc(&scanline->uncompressed_data, &scanline->uncompressed_size, tmp_size);
285  if (!scanline->uncompressed_data)
286  return AVERROR(ENOMEM);
287 
288  av_fast_padded_malloc(&scanline->tmp, &scanline->tmp_size, tmp_size);
289  if (!scanline->tmp)
290  return AVERROR(ENOMEM);
291 
292  av_fast_padded_malloc(&scanline->compressed_data, &scanline->compressed_size, max_compressed_size);
293  if (!scanline->compressed_data)
294  return AVERROR(ENOMEM);
295 
296  switch (s->pixel_type) {
297  case EXR_FLOAT:
298  for (int l = 0; l < scanline_height; l++) {
299  const int scanline_size = frame->width * 4 * s->planes;
300 
301  for (int p = 0; p < s->planes; p++) {
302  int ch = s->ch_order[p];
303 
304  memcpy(scanline->uncompressed_data + scanline_size * l + p * frame->width * 4,
305  frame->data[ch] + (y * s->scanline_height + l) * frame->linesize[ch],
306  frame->width * 4);
307  }
308  }
309  break;
310  case EXR_HALF:
311  for (int l = 0; l < scanline_height; l++) {
312  const int scanline_size = frame->width * 2 * s->planes;
313 
314  for (int p = 0; p < s->planes; p++) {
315  int ch = s->ch_order[p];
316  uint16_t *dst = (uint16_t *)(scanline->uncompressed_data + scanline_size * l + p * frame->width * 2);
317  uint32_t *src = (uint32_t *)(frame->data[ch] + (y * s->scanline_height + l) * frame->linesize[ch]);
318 
319  for (int x = 0; x < frame->width; x++)
320  dst[x] = float2half(src[x], s->basetable, s->shifttable);
321  }
322  }
323  break;
324  }
325 
326  reorder_pixels(scanline->tmp, scanline->uncompressed_data, tmp_size);
327  predictor(scanline->tmp, tmp_size);
328  source_size = tmp_size;
329  actual_size = max_compressed_size;
330  compress(scanline->compressed_data, &actual_size,
331  scanline->tmp, source_size);
332 
333  scanline->actual_size = actual_size;
334  if (scanline->actual_size >= tmp_size) {
335  FFSWAP(uint8_t *, scanline->uncompressed_data, scanline->compressed_data);
336  FFSWAP(int, scanline->uncompressed_size, scanline->compressed_size);
337  scanline->actual_size = tmp_size;
338  }
339  }
340 
341  return 0;
342 }
343 
345  const AVFrame *frame, int *got_packet)
346 {
347  EXRContext *s = avctx->priv_data;
348  PutByteContext *pb = &s->pb;
349  int64_t offset;
350  int ret;
351  int64_t out_size = 2048LL + avctx->height * 16LL +
353  avctx->width,
354  avctx->height, 64) * 3LL / 2;
355 
356  if ((ret = ff_get_encode_buffer(avctx, pkt, out_size, 0)) < 0)
357  return ret;
358 
360 
361  bytestream2_put_le32(pb, 20000630);
362  bytestream2_put_byte(pb, 2);
363  bytestream2_put_le24(pb, 0);
364  bytestream2_put_buffer(pb, "channels\0chlist\0", 16);
365  bytestream2_put_le32(pb, s->planes * 18 + 1);
366 
367  for (int p = 0; p < s->planes; p++) {
368  bytestream2_put_byte(pb, s->ch_names[p]);
369  bytestream2_put_byte(pb, 0);
370  bytestream2_put_le32(pb, s->pixel_type);
371  bytestream2_put_le32(pb, 0);
372  bytestream2_put_le32(pb, 1);
373  bytestream2_put_le32(pb, 1);
374  }
375  bytestream2_put_byte(pb, 0);
376 
377  bytestream2_put_buffer(pb, "compression\0compression\0", 24);
378  bytestream2_put_le32(pb, 1);
379  bytestream2_put_byte(pb, s->compression);
380 
381  bytestream2_put_buffer(pb, "dataWindow\0box2i\0", 17);
382  bytestream2_put_le32(pb, 16);
383  bytestream2_put_le32(pb, 0);
384  bytestream2_put_le32(pb, 0);
385  bytestream2_put_le32(pb, avctx->width - 1);
386  bytestream2_put_le32(pb, avctx->height - 1);
387 
388  bytestream2_put_buffer(pb, "displayWindow\0box2i\0", 20);
389  bytestream2_put_le32(pb, 16);
390  bytestream2_put_le32(pb, 0);
391  bytestream2_put_le32(pb, 0);
392  bytestream2_put_le32(pb, avctx->width - 1);
393  bytestream2_put_le32(pb, avctx->height - 1);
394 
395  bytestream2_put_buffer(pb, "lineOrder\0lineOrder\0", 20);
396  bytestream2_put_le32(pb, 1);
397  bytestream2_put_byte(pb, 0);
398 
399  bytestream2_put_buffer(pb, "screenWindowCenter\0v2f\0", 23);
400  bytestream2_put_le32(pb, 8);
401  bytestream2_put_le64(pb, 0);
402 
403  bytestream2_put_buffer(pb, "screenWindowWidth\0float\0", 24);
404  bytestream2_put_le32(pb, 4);
405  bytestream2_put_le32(pb, av_float2int(1.f));
406 
407  if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den) {
408  bytestream2_put_buffer(pb, "pixelAspectRatio\0float\0", 23);
409  bytestream2_put_le32(pb, 4);
410  bytestream2_put_le32(pb, av_float2int(av_q2d(avctx->sample_aspect_ratio)));
411  }
412 
413  if (avctx->framerate.num && avctx->framerate.den) {
414  bytestream2_put_buffer(pb, "framesPerSecond\0rational\0", 25);
415  bytestream2_put_le32(pb, 8);
416  bytestream2_put_le32(pb, avctx->framerate.num);
417  bytestream2_put_le32(pb, avctx->framerate.den);
418  }
419 
420  bytestream2_put_buffer(pb, "gamma\0float\0", 12);
421  bytestream2_put_le32(pb, 4);
422  bytestream2_put_le32(pb, av_float2int(s->gamma));
423 
424  bytestream2_put_buffer(pb, "writer\0string\0", 14);
425  bytestream2_put_le32(pb, 4);
426  bytestream2_put_buffer(pb, "lavc", 4);
427  bytestream2_put_byte(pb, 0);
428 
429  switch (s->compression) {
430  case EXR_RAW:
431  /* nothing to do */
432  break;
433  case EXR_RLE:
435  break;
436  case EXR_ZIP16:
437  case EXR_ZIP1:
439  break;
440  default:
441  av_assert0(0);
442  }
443 
444  switch (s->compression) {
445  case EXR_RAW:
446  offset = bytestream2_tell_p(pb) + avctx->height * 8LL;
447 
448  if (s->pixel_type == EXR_FLOAT) {
449 
450  for (int y = 0; y < avctx->height; y++) {
451  bytestream2_put_le64(pb, offset);
452  offset += avctx->width * s->planes * 4 + 8;
453  }
454 
455  for (int y = 0; y < avctx->height; y++) {
456  bytestream2_put_le32(pb, y);
457  bytestream2_put_le32(pb, s->planes * avctx->width * 4);
458  for (int p = 0; p < s->planes; p++) {
459  int ch = s->ch_order[p];
460  bytestream2_put_buffer(pb, frame->data[ch] + y * frame->linesize[ch],
461  avctx->width * 4);
462  }
463  }
464  } else {
465  for (int y = 0; y < avctx->height; y++) {
466  bytestream2_put_le64(pb, offset);
467  offset += avctx->width * s->planes * 2 + 8;
468  }
469 
470  for (int y = 0; y < avctx->height; y++) {
471  bytestream2_put_le32(pb, y);
472  bytestream2_put_le32(pb, s->planes * avctx->width * 2);
473  for (int p = 0; p < s->planes; p++) {
474  int ch = s->ch_order[p];
475  uint32_t *src = (uint32_t *)(frame->data[ch] + y * frame->linesize[ch]);
476 
477  for (int x = 0; x < frame->width; x++)
478  bytestream2_put_le16(pb, float2half(src[x], s->basetable, s->shifttable));
479  }
480  }
481  }
482  break;
483  case EXR_ZIP16:
484  case EXR_ZIP1:
485  case EXR_RLE:
486  offset = bytestream2_tell_p(pb) + s->nb_scanlines * 8LL;
487 
488  for (int y = 0; y < s->nb_scanlines; y++) {
489  EXRScanlineData *scanline = &s->scanline[y];
490 
491  bytestream2_put_le64(pb, offset);
492  offset += scanline->actual_size + 8;
493  }
494 
495  for (int y = 0; y < s->nb_scanlines; y++) {
496  EXRScanlineData *scanline = &s->scanline[y];
497 
498  bytestream2_put_le32(pb, y * s->scanline_height);
499  bytestream2_put_le32(pb, scanline->actual_size);
501  scanline->actual_size);
502  }
503  break;
504  default:
505  av_assert0(0);
506  }
507 
509 
511  *got_packet = 1;
512 
513  return 0;
514 }
515 
516 #define OFFSET(x) offsetof(EXRContext, x)
517 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
518 static const AVOption options[] = {
519  { "compression", "set compression type", OFFSET(compression), AV_OPT_TYPE_INT, {.i64=0}, 0, EXR_NBCOMPR-1, VE, "compr" },
520  { "none", "none", 0, AV_OPT_TYPE_CONST, {.i64=EXR_RAW}, 0, 0, VE, "compr" },
521  { "rle" , "RLE", 0, AV_OPT_TYPE_CONST, {.i64=EXR_RLE}, 0, 0, VE, "compr" },
522  { "zip1", "ZIP1", 0, AV_OPT_TYPE_CONST, {.i64=EXR_ZIP1}, 0, 0, VE, "compr" },
523  { "zip16", "ZIP16", 0, AV_OPT_TYPE_CONST, {.i64=EXR_ZIP16}, 0, 0, VE, "compr" },
524  { "format", "set pixel type", OFFSET(pixel_type), AV_OPT_TYPE_INT, {.i64=EXR_FLOAT}, EXR_HALF, EXR_UNKNOWN-1, VE, "pixel" },
525  { "half" , NULL, 0, AV_OPT_TYPE_CONST, {.i64=EXR_HALF}, 0, 0, VE, "pixel" },
526  { "float", NULL, 0, AV_OPT_TYPE_CONST, {.i64=EXR_FLOAT}, 0, 0, VE, "pixel" },
527  { "gamma", "set gamma", OFFSET(gamma), AV_OPT_TYPE_FLOAT, {.dbl=1.f}, 0.001, FLT_MAX, VE },
528  { NULL},
529 };
530 
531 static const AVClass exr_class = {
532  .class_name = "exr",
533  .item_name = av_default_item_name,
534  .option = options,
535  .version = LIBAVUTIL_VERSION_INT,
536 };
537 
539  .name = "exr",
540  .long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
541  .priv_data_size = sizeof(EXRContext),
542  .priv_class = &exr_class,
544  .id = AV_CODEC_ID_EXR,
546  .init = encode_init,
547  .encode2 = encode_frame,
548  .close = encode_close,
549  .pix_fmts = (const enum AVPixelFormat[]) {
552  AV_PIX_FMT_NONE },
553  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
554 };
AVCodec
AVCodec.
Definition: codec.h:197
EXR_NBCOMPR
@ EXR_NBCOMPR
Definition: exrenc.c:45
EXR_ZIP16
@ EXR_ZIP16
Definition: exrenc.c:44
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
EXRContext::ch_names
const char * ch_names
Definition: exrenc.c:82
AVERROR
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
opt.h
out
FILE * out
Definition: movenc.c:54
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
EXR_FLOAT
@ EXR_FLOAT
Definition: exrenc.c:51
out_size
int out_size
Definition: movenc.c:55
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
ExrPixelType
ExrPixelType
Definition: exr.c:73
AVOption
AVOption.
Definition: opt.h:248
encode.h
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
gbra_order
static const uint8_t gbra_order[4]
Definition: exrenc.c:57
EXRContext::planes
int planes
Definition: exrenc.c:78
float.h
t1
#define t1
Definition: regdef.h:29
av_float2int
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:396
exr_class
static const AVClass exr_class
Definition: exrenc.c:531
EXRContext::scanline_height
int scanline_height
Definition: exrenc.c:80
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1699
EXR_RAW
@ EXR_RAW
Definition: exrenc.c:41
EXRScanlineData::uncompressed_data
uint8_t * uncompressed_data
Definition: exrenc.c:64
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:109
abgr_chlist
static const char abgr_chlist[4]
Definition: exrenc.c:55
type
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 type
Definition: writing_filters.txt:86
AVRational::num
int num
Numerator.
Definition: rational.h:59
EXRScanlineData::actual_size
int64_t actual_size
Definition: exrenc.c:70
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
EXRScanlineData::tmp
uint8_t * tmp
Definition: exrenc.c:67
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
bytestream2_put_buffer
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
Definition: bytestream.h:286
gbr_order
static const uint8_t gbr_order[4]
Definition: exrenc.c:58
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
EXRContext::scanline
EXRScanlineData * scanline
Definition: exrenc.c:86
f
#define f(width, name)
Definition: cbs_vp9.c:255
EXRContext::ch_order
const uint8_t * ch_order
Definition: exrenc.c:83
OFFSET
#define OFFSET(x)
Definition: exrenc.c:516
bgr_chlist
static const char bgr_chlist[4]
Definition: exrenc.c:56
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
AV_CODEC_ID_EXR
@ AV_CODEC_ID_EXR
Definition: codec_id.h:230
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
rle_compress
static int64_t rle_compress(uint8_t *out, int64_t out_size, const uint8_t *in, int64_t in_size)
Definition: exrenc.c:176
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:203
EXRContext::compression
int compression
Definition: exrenc.c:76
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
src
#define src
Definition: vp8dsp.c:255
float2half
static uint16_t float2half(uint32_t f, uint16_t *basetable, uint8_t *shifttable)
Definition: float2half.h:58
ff_exr_encoder
const AVCodec ff_exr_encoder
Definition: exrenc.c:538
EXRScanlineData::tmp_size
unsigned int tmp_size
Definition: exrenc.c:68
encode_scanline_zip
static int encode_scanline_zip(EXRContext *s, const AVFrame *frame)
Definition: exrenc.c:273
PutByteContext
Definition: bytestream.h:37
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:194
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:418
EXRContext::nb_scanlines
int nb_scanlines
Definition: exrenc.c:79
size
int size
Definition: twinvq_data.h:10344
EXRContext::gamma
float gamma
Definition: exr.c:190
EXRContext::pb
PutByteContext pb
Definition: exrenc.c:84
av_image_get_buffer_size
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.
Definition: imgutils.c:466
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
offset
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
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:371
predictor
static void predictor(uint8_t *src, ptrdiff_t size)
Definition: exrenc.c:164
EXRScanlineData::compressed_data
uint8_t * compressed_data
Definition: exrenc.c:61
EXRScanlineData::compressed_size
unsigned int compressed_size
Definition: exrenc.c:62
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
EXR_UNKNOWN
@ EXR_UNKNOWN
Definition: exrenc.c:52
EXRScanlineData::uncompressed_size
unsigned int uncompressed_size
Definition: exrenc.c:65
i
int i
Definition: input.c:407
av_fast_padded_malloc
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...
Definition: utils.c:50
EXR_UINT
@ EXR_UINT
Definition: exrenc.c:49
EXRScanlineData
Definition: exrenc.c:60
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
EXR_HALF
@ EXR_HALF
Definition: exrenc.c:50
AVCodecContext::height
int height
Definition: avcodec.h:557
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:594
float2half_tables
static void float2half_tables(uint16_t *basetable, uint8_t *shifttable)
Definition: float2half.h:24
avcodec.h
options
static const AVOption options[]
Definition: exrenc.c:518
encode_scanline_rle
static int encode_scanline_rle(EXRContext *s, const AVFrame *frame)
Definition: exrenc.c:215
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
frame
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
Definition: filter_design.txt:264
EXRContext::basetable
uint16_t basetable[512]
Definition: exrenc.c:88
EXRContext::shifttable
uint8_t shifttable[512]
Definition: exrenc.c:89
reorder_pixels
static void reorder_pixels(uint8_t *dst, const uint8_t *src, ptrdiff_t size)
Definition: exrenc.c:152
AVCodecContext
main external API structure.
Definition: avcodec.h:384
EXRContext::pixel_type
int pixel_type
Definition: exrenc.c:77
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:252
t2
#define t2
Definition: regdef.h:30
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:77
encode_init
static int encode_init(AVCodecContext *avctx)
Definition: exrenc.c:92
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:419
EXR_RLE
@ EXR_RLE
Definition: exrenc.c:42
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ExrCompr
ExrCompr
Definition: exr.c:59
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
d
d
Definition: ffmpeg_filter.c:156
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:557
bytestream.h
VE
#define VE
Definition: exrenc.c:517
imgutils.h
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: exrenc.c:344
EXR_ZIP1
@ EXR_ZIP1
Definition: exrenc.c:43
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
encode_close
static int encode_close(AVCodecContext *avctx)
Definition: exrenc.c:135
float2half.h
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:742
EXRContext
Definition: exr.c:145