FFmpeg
librav1e.c
Go to the documentation of this file.
1 /*
2  * librav1e encoder
3  *
4  * Copyright (c) 2019 Derek Buitenhuis
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <rav1e.h>
24 
25 #include "libavutil/buffer.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/avassert.h"
28 #include "libavutil/base64.h"
29 #include "libavutil/common.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/pixdesc.h"
33 #include "avcodec.h"
34 #include "codec_internal.h"
35 #include "encode.h"
36 #include "internal.h"
37 
38 typedef struct librav1eContext {
39  const AVClass *class;
40 
41  RaContext *ctx;
43  RaFrame *rframe;
44 
45  uint8_t *pass_data;
46  size_t pass_pos;
47  int pass_size;
48 
50  int quantizer;
51  int speed;
52  int tiles;
53  int tile_rows;
54  int tile_cols;
56 
57 typedef struct FrameData {
58  int64_t pts;
59  int64_t duration;
60 
61  void *frame_opaque;
63 } FrameData;
64 
65 static inline RaPixelRange range_map(enum AVPixelFormat pix_fmt, enum AVColorRange range)
66 {
67  switch (pix_fmt) {
71  return RA_PIXEL_RANGE_FULL;
72  }
73 
74  switch (range) {
75  case AVCOL_RANGE_JPEG:
76  return RA_PIXEL_RANGE_FULL;
77  case AVCOL_RANGE_MPEG:
78  default:
79  return RA_PIXEL_RANGE_LIMITED;
80  }
81 }
82 
83 static inline RaChromaSampling pix_fmt_map(enum AVPixelFormat pix_fmt)
84 {
85  switch (pix_fmt) {
86  case AV_PIX_FMT_YUV420P:
90  return RA_CHROMA_SAMPLING_CS420;
91  case AV_PIX_FMT_YUV422P:
95  return RA_CHROMA_SAMPLING_CS422;
96  case AV_PIX_FMT_YUV444P:
100  return RA_CHROMA_SAMPLING_CS444;
101  default:
102  av_assert0(0);
103  }
104 }
105 
106 static inline RaChromaSamplePosition chroma_loc_map(enum AVChromaLocation chroma_loc)
107 {
108  switch (chroma_loc) {
109  case AVCHROMA_LOC_LEFT:
110  return RA_CHROMA_SAMPLE_POSITION_VERTICAL;
112  return RA_CHROMA_SAMPLE_POSITION_COLOCATED;
113  default:
114  return RA_CHROMA_SAMPLE_POSITION_UNKNOWN;
115  }
116 }
117 
118 static int get_stats(AVCodecContext *avctx, int eos)
119 {
120  librav1eContext *ctx = avctx->priv_data;
121  RaData* buf = rav1e_twopass_out(ctx->ctx);
122  if (!buf)
123  return 0;
124 
125  if (!eos) {
126  uint8_t *tmp = av_fast_realloc(ctx->pass_data, &ctx->pass_size,
127  ctx->pass_pos + buf->len);
128  if (!tmp) {
129  rav1e_data_unref(buf);
130  return AVERROR(ENOMEM);
131  }
132 
133  ctx->pass_data = tmp;
134  memcpy(ctx->pass_data + ctx->pass_pos, buf->data, buf->len);
135  ctx->pass_pos += buf->len;
136  } else {
137  size_t b64_size = AV_BASE64_SIZE(ctx->pass_pos);
138 
139  memcpy(ctx->pass_data, buf->data, buf->len);
140 
141  avctx->stats_out = av_malloc(b64_size);
142  if (!avctx->stats_out) {
143  rav1e_data_unref(buf);
144  return AVERROR(ENOMEM);
145  }
146 
147  av_base64_encode(avctx->stats_out, b64_size, ctx->pass_data, ctx->pass_pos);
148 
149  av_freep(&ctx->pass_data);
150  }
151 
152  rav1e_data_unref(buf);
153 
154  return 0;
155 }
156 
157 static int set_stats(AVCodecContext *avctx)
158 {
159  librav1eContext *ctx = avctx->priv_data;
160  int ret = 1;
161 
162  while (ret > 0 && ctx->pass_size - ctx->pass_pos > 0) {
163  ret = rav1e_twopass_in(ctx->ctx, ctx->pass_data + ctx->pass_pos, ctx->pass_size);
164  if (ret < 0)
165  return AVERROR_EXTERNAL;
166  ctx->pass_pos += ret;
167  }
168 
169  return 0;
170 }
171 
173 {
174  librav1eContext *ctx = avctx->priv_data;
175 
176  if (ctx->ctx) {
177  rav1e_context_unref(ctx->ctx);
178  ctx->ctx = NULL;
179  }
180  if (ctx->rframe) {
181  rav1e_frame_unref(ctx->rframe);
182  ctx->rframe = NULL;
183  }
184 
185  av_frame_free(&ctx->frame);
186  av_freep(&ctx->pass_data);
187 
188  return 0;
189 }
190 
192 {
193  librav1eContext *ctx = avctx->priv_data;
195  RaConfig *cfg = NULL;
196  int rret;
197  int ret = 0;
198 
199  ctx->frame = av_frame_alloc();
200  if (!ctx->frame)
201  return AVERROR(ENOMEM);
202 
203  cfg = rav1e_config_default();
204  if (!cfg) {
205  av_log(avctx, AV_LOG_ERROR, "Could not allocate rav1e config.\n");
206  return AVERROR_EXTERNAL;
207  }
208 
209  /*
210  * Rav1e currently uses the time base given to it only for ratecontrol... where
211  * the inverse is taken and used as a framerate. So, do what we do in other wrappers
212  * and use the framerate if we can.
213  */
214  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
215  rav1e_config_set_time_base(cfg, (RaRational) {
216  avctx->framerate.den, avctx->framerate.num
217  });
218  } else {
220  rav1e_config_set_time_base(cfg, (RaRational) {
221  avctx->time_base.num
222 #if FF_API_TICKS_PER_FRAME
223  * avctx->ticks_per_frame
224 #endif
225  , avctx->time_base.den
226  });
228  }
229 
230  if ((avctx->flags & AV_CODEC_FLAG_PASS1 || avctx->flags & AV_CODEC_FLAG_PASS2) && !avctx->bit_rate) {
231  av_log(avctx, AV_LOG_ERROR, "A bitrate must be set to use two pass mode.\n");
233  goto end;
234  }
235 
236  if (avctx->flags & AV_CODEC_FLAG_PASS2) {
237  if (!avctx->stats_in) {
238  av_log(avctx, AV_LOG_ERROR, "No stats file provided for second pass.\n");
239  ret = AVERROR(EINVAL);
240  goto end;
241  }
242 
243  ctx->pass_size = (strlen(avctx->stats_in) * 3) / 4;
244  ctx->pass_data = av_malloc(ctx->pass_size);
245  if (!ctx->pass_data) {
246  av_log(avctx, AV_LOG_ERROR, "Could not allocate stats buffer.\n");
247  ret = AVERROR(ENOMEM);
248  goto end;
249  }
250 
251  ctx->pass_size = av_base64_decode(ctx->pass_data, avctx->stats_in, ctx->pass_size);
252  if (ctx->pass_size < 0) {
253  av_log(avctx, AV_LOG_ERROR, "Invalid pass file.\n");
254  ret = AVERROR(EINVAL);
255  goto end;
256  }
257  }
258 
259  {
260  const AVDictionaryEntry *en = NULL;
261  while ((en = av_dict_iterate(ctx->rav1e_opts, en))) {
262  if (rav1e_config_parse(cfg, en->key, en->value) < 0)
263  av_log(avctx, AV_LOG_WARNING, "Invalid value for %s: %s.\n", en->key, en->value);
264  }
265  }
266 
267  rret = rav1e_config_parse_int(cfg, "width", avctx->width);
268  if (rret < 0) {
269  av_log(avctx, AV_LOG_ERROR, "Invalid width passed to rav1e.\n");
271  goto end;
272  }
273 
274  rret = rav1e_config_parse_int(cfg, "height", avctx->height);
275  if (rret < 0) {
276  av_log(avctx, AV_LOG_ERROR, "Invalid height passed to rav1e.\n");
278  goto end;
279  }
280 
281  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
282  rav1e_config_set_sample_aspect_ratio(cfg, (RaRational) {
283  avctx->sample_aspect_ratio.num,
284  avctx->sample_aspect_ratio.den
285  });
286 
287  rret = rav1e_config_parse_int(cfg, "threads", avctx->thread_count);
288  if (rret < 0)
289  av_log(avctx, AV_LOG_WARNING, "Invalid number of threads, defaulting to auto.\n");
290 
291  if (ctx->speed >= 0) {
292  rret = rav1e_config_parse_int(cfg, "speed", ctx->speed);
293  if (rret < 0) {
294  av_log(avctx, AV_LOG_ERROR, "Could not set speed preset.\n");
296  goto end;
297  }
298  }
299 
300  /* rav1e handles precedence between 'tiles' and cols/rows for us. */
301  if (ctx->tiles > 0) {
302  rret = rav1e_config_parse_int(cfg, "tiles", ctx->tiles);
303  if (rret < 0) {
304  av_log(avctx, AV_LOG_ERROR, "Could not set number of tiles to encode with.\n");
306  goto end;
307  }
308  }
309  if (ctx->tile_rows > 0) {
310  rret = rav1e_config_parse_int(cfg, "tile_rows", ctx->tile_rows);
311  if (rret < 0) {
312  av_log(avctx, AV_LOG_ERROR, "Could not set number of tile rows to encode with.\n");
314  goto end;
315  }
316  }
317  if (ctx->tile_cols > 0) {
318  rret = rav1e_config_parse_int(cfg, "tile_cols", ctx->tile_cols);
319  if (rret < 0) {
320  av_log(avctx, AV_LOG_ERROR, "Could not set number of tile cols to encode with.\n");
322  goto end;
323  }
324  }
325 
326  if (avctx->gop_size > 0) {
327  rret = rav1e_config_parse_int(cfg, "key_frame_interval", avctx->gop_size);
328  if (rret < 0) {
329  av_log(avctx, AV_LOG_ERROR, "Could not set max keyint.\n");
331  goto end;
332  }
333  }
334 
335  if (avctx->keyint_min > 0) {
336  rret = rav1e_config_parse_int(cfg, "min_key_frame_interval", avctx->keyint_min);
337  if (rret < 0) {
338  av_log(avctx, AV_LOG_ERROR, "Could not set min keyint.\n");
340  goto end;
341  }
342  }
343 
344  if (avctx->bit_rate && ctx->quantizer < 0) {
345  int max_quantizer = avctx->qmax >= 0 ? avctx->qmax : 255;
346 
347  rret = rav1e_config_parse_int(cfg, "quantizer", max_quantizer);
348  if (rret < 0) {
349  av_log(avctx, AV_LOG_ERROR, "Could not set max quantizer.\n");
351  goto end;
352  }
353 
354  if (avctx->qmin >= 0) {
355  rret = rav1e_config_parse_int(cfg, "min_quantizer", avctx->qmin);
356  if (rret < 0) {
357  av_log(avctx, AV_LOG_ERROR, "Could not set min quantizer.\n");
359  goto end;
360  }
361  }
362 
363  rret = rav1e_config_parse_int(cfg, "bitrate", avctx->bit_rate);
364  if (rret < 0) {
365  av_log(avctx, AV_LOG_ERROR, "Could not set bitrate.\n");
367  goto end;
368  }
369  } else if (ctx->quantizer >= 0) {
370  if (avctx->bit_rate)
371  av_log(avctx, AV_LOG_WARNING, "Both bitrate and quantizer specified. Using quantizer mode.");
372 
373  rret = rav1e_config_parse_int(cfg, "quantizer", ctx->quantizer);
374  if (rret < 0) {
375  av_log(avctx, AV_LOG_ERROR, "Could not set quantizer.\n");
377  goto end;
378  }
379  }
380 
381  rret = rav1e_config_set_pixel_format(cfg, desc->comp[0].depth,
382  pix_fmt_map(avctx->pix_fmt),
384  range_map(avctx->pix_fmt, avctx->color_range));
385  if (rret < 0) {
386  av_log(avctx, AV_LOG_ERROR, "Failed to set pixel format properties.\n");
388  goto end;
389  }
390 
391  /* rav1e's colorspace enums match standard values. */
392  rret = rav1e_config_set_color_description(cfg, (RaMatrixCoefficients) avctx->colorspace,
393  (RaColorPrimaries) avctx->color_primaries,
394  (RaTransferCharacteristics) avctx->color_trc);
395  if (rret < 0) {
396  av_log(avctx, AV_LOG_WARNING, "Failed to set color properties.\n");
397  if (avctx->err_recognition & AV_EF_EXPLODE) {
399  goto end;
400  }
401  }
402 
403  ctx->ctx = rav1e_context_new(cfg);
404  if (!ctx->ctx) {
405  av_log(avctx, AV_LOG_ERROR, "Failed to create rav1e encode context.\n");
407  goto end;
408  }
409 
410  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
411  RaData *seq_hdr = rav1e_container_sequence_header(ctx->ctx);
412 
413  if (seq_hdr)
414  avctx->extradata = av_mallocz(seq_hdr->len + AV_INPUT_BUFFER_PADDING_SIZE);
415  if (!seq_hdr || !avctx->extradata) {
416  rav1e_data_unref(seq_hdr);
417  av_log(avctx, AV_LOG_ERROR, "Failed to get extradata.\n");
418  ret = seq_hdr ? AVERROR(ENOMEM) : AVERROR_EXTERNAL;
419  goto end;
420  }
421 
422  memcpy(avctx->extradata, seq_hdr->data, seq_hdr->len);
423  avctx->extradata_size = seq_hdr->len;
424  rav1e_data_unref(seq_hdr);
425  }
426 
427  ret = 0;
428 
429 end:
430 
431  rav1e_config_unref(cfg);
432 
433  return ret;
434 }
435 
436 static void frame_data_free(void *data)
437 {
438  FrameData *fd = data;
439 
440  if (!fd)
441  return;
442 
444  av_free(data);
445 }
446 
448 {
449  librav1eContext *ctx = avctx->priv_data;
450  RaFrame *rframe = ctx->rframe;
451  RaPacket *rpkt = NULL;
452  FrameData *fd;
453  int ret;
454 
455  if (!rframe) {
456  AVFrame *frame = ctx->frame;
457 
458  ret = ff_encode_get_frame(avctx, frame);
459  if (ret < 0 && ret != AVERROR_EOF)
460  return ret;
461 
462  if (frame->buf[0]) {
464 
465  fd = av_mallocz(sizeof(*fd));
466  if (!fd) {
467  av_log(avctx, AV_LOG_ERROR, "Could not allocate PTS buffer.\n");
468  return AVERROR(ENOMEM);
469  }
470  fd->pts = frame->pts;
471  fd->duration = frame->duration;
472 
473  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
474  fd->frame_opaque = frame->opaque;
476  frame->opaque_ref = NULL;
477  }
478 
479  rframe = rav1e_frame_new(ctx->ctx);
480  if (!rframe) {
481  av_log(avctx, AV_LOG_ERROR, "Could not allocate new rav1e frame.\n");
483  frame_data_free(fd);
484  return AVERROR(ENOMEM);
485  }
486 
487  for (int i = 0; i < desc->nb_components; i++) {
488  int shift = i ? desc->log2_chroma_h : 0;
489  int bytes = desc->comp[0].depth == 8 ? 1 : 2;
490  rav1e_frame_fill_plane(rframe, i, frame->data[i],
491  (frame->height >> shift) * frame->linesize[i],
492  frame->linesize[i], bytes);
493  }
495  rav1e_frame_set_opaque(rframe, fd, frame_data_free);
496  }
497  }
498 
499  ret = rav1e_send_frame(ctx->ctx, rframe);
500  if (rframe)
501  if (ret == RA_ENCODER_STATUS_ENOUGH_DATA) {
502  ctx->rframe = rframe; /* Queue is full. Store the RaFrame to retry next call */
503  } else {
504  rav1e_frame_unref(rframe); /* No need to unref if flushing. */
505  ctx->rframe = NULL;
506  }
507 
508  switch (ret) {
509  case RA_ENCODER_STATUS_SUCCESS:
510  case RA_ENCODER_STATUS_ENOUGH_DATA:
511  break;
512  case RA_ENCODER_STATUS_FAILURE:
513  av_log(avctx, AV_LOG_ERROR, "Could not send frame: %s\n", rav1e_status_to_str(ret));
514  return AVERROR_EXTERNAL;
515  default:
516  av_log(avctx, AV_LOG_ERROR, "Unknown return code %d from rav1e_send_frame: %s\n", ret, rav1e_status_to_str(ret));
517  return AVERROR_UNKNOWN;
518  }
519 
520 retry:
521 
522  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
523  int sret = get_stats(avctx, 0);
524  if (sret < 0)
525  return sret;
526  } else if (avctx->flags & AV_CODEC_FLAG_PASS2) {
527  int sret = set_stats(avctx);
528  if (sret < 0)
529  return sret;
530  }
531 
532  ret = rav1e_receive_packet(ctx->ctx, &rpkt);
533  switch (ret) {
534  case RA_ENCODER_STATUS_SUCCESS:
535  break;
536  case RA_ENCODER_STATUS_LIMIT_REACHED:
537  if (avctx->flags & AV_CODEC_FLAG_PASS1) {
538  int sret = get_stats(avctx, 1);
539  if (sret < 0)
540  return sret;
541  }
542  return AVERROR_EOF;
543  case RA_ENCODER_STATUS_ENCODED:
544  goto retry;
545  case RA_ENCODER_STATUS_NEED_MORE_DATA:
546  if (avctx->internal->draining) {
547  av_log(avctx, AV_LOG_ERROR, "Unexpected error when receiving packet after EOF.\n");
548  return AVERROR_EXTERNAL;
549  }
550  return AVERROR(EAGAIN);
551  case RA_ENCODER_STATUS_FAILURE:
552  av_log(avctx, AV_LOG_ERROR, "Could not encode frame: %s\n", rav1e_status_to_str(ret));
553  return AVERROR_EXTERNAL;
554  default:
555  av_log(avctx, AV_LOG_ERROR, "Unknown return code %d from rav1e_receive_packet: %s\n", ret, rav1e_status_to_str(ret));
556  return AVERROR_UNKNOWN;
557  }
558 
559  ret = ff_get_encode_buffer(avctx, pkt, rpkt->len, 0);
560  if (ret < 0) {
561  av_log(avctx, AV_LOG_ERROR, "Could not allocate packet.\n");
562  rav1e_packet_unref(rpkt);
563  return ret;
564  }
565 
566  memcpy(pkt->data, rpkt->data, rpkt->len);
567 
568  if (rpkt->frame_type == RA_FRAME_TYPE_KEY)
570 
571  fd = rpkt->opaque;
572  pkt->pts = pkt->dts = fd->pts;
573  pkt->duration = fd->duration;
574 
575  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
576  pkt->opaque = fd->frame_opaque;
578  fd->frame_opaque_ref = NULL;
579  }
580 
581  frame_data_free(fd);
582 
583  if (avctx->flags & AV_CODEC_FLAG_RECON_FRAME) {
584  AVCodecInternal *avci = avctx->internal;
585  AVFrame *frame = avci->recon_frame;
587 
589 
590  frame->format = avctx->pix_fmt;
591  frame->width = avctx->width;
592  frame->height = avctx->height;
593 
594  ret = ff_encode_alloc_frame(avctx, frame);
595  if (ret < 0) {
596  rav1e_packet_unref(rpkt);
597  return ret;
598  }
599 
600  for (int i = 0; i < desc->nb_components; i++) {
601  int shift = i ? desc->log2_chroma_h : 0;
602  rav1e_frame_extract_plane(rpkt->rec, i, frame->data[i],
603  (frame->height >> shift) * frame->linesize[i],
604  frame->linesize[i], desc->comp[i].step);
605  }
606  }
607 
608  rav1e_packet_unref(rpkt);
609 
610  return 0;
611 }
612 
613 #define OFFSET(x) offsetof(librav1eContext, x)
614 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
615 
616 static const AVOption options[] = {
617  { "qp", "use constant quantizer mode", OFFSET(quantizer), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 255, VE },
618  { "speed", "what speed preset to use", OFFSET(speed), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 10, VE },
619  { "tiles", "number of tiles encode with", OFFSET(tiles), AV_OPT_TYPE_INT, { .i64 = 0 }, -1, INT64_MAX, VE },
620  { "tile-rows", "number of tiles rows to encode with", OFFSET(tile_rows), AV_OPT_TYPE_INT, { .i64 = 0 }, -1, INT64_MAX, VE },
621  { "tile-columns", "number of tiles columns to encode with", OFFSET(tile_cols), AV_OPT_TYPE_INT, { .i64 = 0 }, -1, INT64_MAX, VE },
622  { "rav1e-params", "set the rav1e configuration using a :-separated list of key=value parameters", OFFSET(rav1e_opts), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
623  { NULL }
624 };
625 
627  { "b", "0" },
628  { "g", "0" },
629  { "keyint_min", "0" },
630  { "qmax", "-1" },
631  { "qmin", "-1" },
632  { NULL }
633 };
634 
649 };
650 
651 static const AVClass class = {
652  .class_name = "librav1e",
653  .item_name = av_default_item_name,
654  .option = options,
656 };
657 
659  .p.name = "librav1e",
660  CODEC_LONG_NAME("librav1e AV1"),
661  .p.type = AVMEDIA_TYPE_VIDEO,
662  .p.id = AV_CODEC_ID_AV1,
663  .init = librav1e_encode_init,
665  .close = librav1e_encode_close,
666  .priv_data_size = sizeof(librav1eContext),
667  .p.priv_class = &class,
668  .defaults = librav1e_defaults,
669  .p.pix_fmts = librav1e_pix_fmts,
670  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
673  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
675  .p.wrapper_name = "librav1e",
676 };
OFFSET
#define OFFSET(x)
Definition: librav1e.c:613
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:1024
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
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
FrameData
Definition: ffmpeg.h:593
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:781
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
AV_CODEC_CAP_ENCODER_RECON_FRAME
#define AV_CODEC_CAP_ENCODER_RECON_FRAME
The encoder is able to output reconstructed frame data, i.e.
Definition: codec.h:174
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame::opaque
void * opaque
Frame owner's private data.
Definition: frame.h:523
librav1eContext::rframe
RaFrame * rframe
Definition: librav1e.c:43
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:487
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVFrame::width
int width
Definition: frame.h:447
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
set_stats
static int set_stats(AVCodecContext *avctx)
Definition: librav1e.c:157
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:346
encode.h
librav1eContext::frame
AVFrame * frame
Definition: librav1e.c:42
data
const char data[16]
Definition: mxf.c:148
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:127
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
mathematics.h
AVDictionary
Definition: dict.c:34
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1263
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:588
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
ff_librav1e_encoder
const FFCodec ff_librav1e_encoder
Definition: librav1e.c:658
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:396
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:338
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:742
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
librav1eContext::tiles
int tiles
Definition: librav1e.c:52
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
librav1eContext::ctx
RaContext * ctx
Definition: librav1e.c:41
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:558
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
tiles
int tiles
Definition: av1_levels.c:72
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:495
librav1eContext
Definition: librav1e.c:38
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1342
librav1e_encode_init
static av_cold int librav1e_encode_init(AVCodecContext *avctx)
Definition: librav1e.c:191
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
librav1eContext::pass_pos
size_t pass_pos
Definition: librav1e.c:46
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:124
librav1eContext::pass_size
int pass_size
Definition: librav1e.c:47
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
tile_rows
int tile_rows
Definition: h265_levels.c:217
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
tile_cols
int tile_cols
Definition: av1_levels.c:73
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:547
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
frame
static AVFrame * frame
Definition: demux_decode.c:54
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:704
librav1eContext::rav1e_opts
AVDictionary * rav1e_opts
Definition: librav1e.c:49
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:706
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:302
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:242
FrameData::duration
int64_t duration
Definition: librav1e.c:59
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
FrameData::frame_opaque
void * frame_opaque
Definition: librav1e.c:61
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
librav1eContext::tile_rows
int tile_rows
Definition: librav1e.c:53
av_base64_decode
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:81
base64.h
librav1e_receive_packet
static int librav1e_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: librav1e.c:447
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:544
ff_encode_alloc_frame
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
Allocate buffers for a frame.
Definition: encode.c:794
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1334
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
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:262
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:462
librav1eContext::pass_data
uint8_t * pass_data
Definition: librav1e.c:45
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2557
range_map
static RaPixelRange range_map(enum AVPixelFormat pix_fmt, enum AVColorRange range)
Definition: librav1e.c:65
buffer.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
FrameData::pts
int64_t pts
Definition: ffmpeg.h:602
pix_fmt_map
static RaChromaSampling pix_fmt_map(enum AVPixelFormat pix_fmt)
Definition: librav1e.c:83
librav1eContext::tile_cols
int tile_cols
Definition: librav1e.c:54
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
AVCodecInternal
Definition: internal.h:49
FrameData::frame_opaque_ref
AVBufferRef * frame_opaque_ref
Definition: librav1e.c:62
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:702
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
AV_CODEC_FLAG_RECON_FRAME
#define AV_CODEC_FLAG_RECON_FRAME
Request the encoder to output reconstructed frames, i.e. frames that would be produced by decoding th...
Definition: avcodec.h:264
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
librav1eContext::speed
int speed
Definition: librav1e.c:51
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
internal.h
VE
#define VE
Definition: librav1e.c:614
common.h
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:666
librav1eContext::quantizer
int quantizer
Definition: librav1e.c:50
avcodec.h
options
static const AVOption options[]
Definition: librav1e.c:616
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:71
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:105
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
frame_data_free
static void frame_data_free(void *data)
Definition: librav1e.c:436
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:447
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:105
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1256
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
librav1e_defaults
static const FFCodecDefault librav1e_defaults[]
Definition: librav1e.c:626
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
av_base64_encode
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:145
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
chroma_loc_map
static RaChromaSamplePosition chroma_loc_map(enum AVChromaLocation chroma_loc)
Definition: librav1e.c:106
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:126
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
ff_encode_get_frame
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition: encode.c:204
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
librav1e_pix_fmts
enum AVPixelFormat librav1e_pix_fmts[]
Definition: librav1e.c:635
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:420
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:648
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:642
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
librav1e_encode_close
static av_cold int librav1e_encode_close(AVCodecContext *avctx)
Definition: librav1e.c:172
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310
get_stats
static int get_stats(AVCodecContext *avctx, int eos)
Definition: librav1e.c:118