FFmpeg
libsvtav1.c
Go to the documentation of this file.
1 /*
2  * Scalable Video Technology for AV1 encoder library plugin
3  *
4  * Copyright (c) 2018 Intel Corporation
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 this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <stdint.h>
24 #include <EbSvtAv1ErrorCodes.h>
25 #include <EbSvtAv1Enc.h>
26 
27 #include "libavutil/common.h"
28 #include "libavutil/frame.h"
29 #include "libavutil/imgutils.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/avassert.h"
33 
34 #include "internal.h"
35 #include "encode.h"
36 #include "packet_internal.h"
37 #include "avcodec.h"
38 #include "profiles.h"
39 
40 typedef enum eos_status {
44 }EOS_STATUS;
45 
46 typedef struct SvtContext {
47  const AVClass *class;
48 
49  EbSvtAv1EncConfiguration enc_params;
50  EbComponentType *svt_handle;
51 
52  EbBufferHeaderType *in_buf;
53  int raw_size;
55 
57 
59 
60  EOS_STATUS eos_flag;
61 
62  // User options.
64  int la_depth;
65  int enc_mode;
66  int rc_mode;
67  int scd;
68  int qp;
69 
70  int tier;
71 
73  int tile_rows;
74 } SvtContext;
75 
76 static const struct {
77  EbErrorType eb_err;
78  int av_err;
79  const char *desc;
80 } svt_errors[] = {
81  { EB_ErrorNone, 0, "success" },
82  { EB_ErrorInsufficientResources, AVERROR(ENOMEM), "insufficient resources" },
83  { EB_ErrorUndefined, AVERROR(EINVAL), "undefined error" },
84  { EB_ErrorInvalidComponent, AVERROR(EINVAL), "invalid component" },
85  { EB_ErrorBadParameter, AVERROR(EINVAL), "bad parameter" },
86  { EB_ErrorDestroyThreadFailed, AVERROR_EXTERNAL, "failed to destroy thread" },
87  { EB_ErrorSemaphoreUnresponsive, AVERROR_EXTERNAL, "semaphore unresponsive" },
88  { EB_ErrorDestroySemaphoreFailed, AVERROR_EXTERNAL, "failed to destroy semaphore"},
89  { EB_ErrorCreateMutexFailed, AVERROR_EXTERNAL, "failed to create mutex" },
90  { EB_ErrorMutexUnresponsive, AVERROR_EXTERNAL, "mutex unresponsive" },
91  { EB_ErrorDestroyMutexFailed, AVERROR_EXTERNAL, "failed to destroy mutex" },
92  { EB_NoErrorEmptyQueue, AVERROR(EAGAIN), "empty queue" },
93 };
94 
95 static int svt_map_error(EbErrorType eb_err, const char **desc)
96 {
97  int i;
98 
100  for (i = 0; i < FF_ARRAY_ELEMS(svt_errors); i++) {
101  if (svt_errors[i].eb_err == eb_err) {
102  *desc = svt_errors[i].desc;
103  return svt_errors[i].av_err;
104  }
105  }
106  *desc = "unknown error";
107  return AVERROR_UNKNOWN;
108 }
109 
110 static int svt_print_error(void *log_ctx, EbErrorType err,
111  const char *error_string)
112 {
113  const char *desc;
114  int ret = svt_map_error(err, &desc);
115 
116  av_log(log_ctx, AV_LOG_ERROR, "%s: %s (0x%x)\n", error_string, desc, err);
117 
118  return ret;
119 }
120 
121 static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
122 {
123  const int pack_mode_10bit =
124  (config->encoder_bit_depth > 8) && (config->compressed_ten_bit_format == 0) ? 1 : 0;
125  const size_t luma_size_8bit =
126  config->source_width * config->source_height * (1 << pack_mode_10bit);
127  const size_t luma_size_10bit =
128  (config->encoder_bit_depth > 8 && pack_mode_10bit == 0) ? luma_size_8bit : 0;
129 
130  EbSvtIOFormat *in_data;
131 
132  svt_enc->raw_size = (luma_size_8bit + luma_size_10bit) * 3 / 2;
133 
134  // allocate buffer for in and out
135  svt_enc->in_buf = av_mallocz(sizeof(*svt_enc->in_buf));
136  if (!svt_enc->in_buf)
137  return AVERROR(ENOMEM);
138 
139  svt_enc->in_buf->p_buffer = av_mallocz(sizeof(*in_data));
140  if (!svt_enc->in_buf->p_buffer)
141  return AVERROR(ENOMEM);
142 
143  svt_enc->in_buf->size = sizeof(*svt_enc->in_buf);
144 
145  return 0;
146 
147 }
148 
149 static int config_enc_params(EbSvtAv1EncConfiguration *param,
150  AVCodecContext *avctx)
151 {
152  SvtContext *svt_enc = avctx->priv_data;
153  const AVPixFmtDescriptor *desc;
154 
155  param->source_width = avctx->width;
156  param->source_height = avctx->height;
157 
158  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
159  param->encoder_bit_depth = desc->comp[0].depth;
160 
161  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
162  param->encoder_color_format = EB_YUV420;
163  else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0)
164  param->encoder_color_format = EB_YUV422;
165  else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
166  param->encoder_color_format = EB_YUV444;
167  else {
168  av_log(avctx, AV_LOG_ERROR , "Unsupported pixel format\n");
169  return AVERROR(EINVAL);
170  }
171 
172  if (avctx->profile != FF_PROFILE_UNKNOWN)
173  param->profile = avctx->profile;
174 
175  if (avctx->level != FF_LEVEL_UNKNOWN)
176  param->level = avctx->level;
177 
178  if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
179  && param->profile != FF_PROFILE_AV1_PROFESSIONAL ) {
180  av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
181  param->profile = FF_PROFILE_AV1_PROFESSIONAL;
182  } else if (param->encoder_color_format == EB_YUV444 && param->profile != FF_PROFILE_AV1_HIGH) {
183  av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
184  param->profile = FF_PROFILE_AV1_HIGH;
185  }
186 
187  // Update param from options
188  param->hierarchical_levels = svt_enc->hierarchical_level;
189  param->enc_mode = svt_enc->enc_mode;
190  param->tier = svt_enc->tier;
191  param->rate_control_mode = svt_enc->rc_mode;
192  param->scene_change_detection = svt_enc->scd;
193  param->qp = svt_enc->qp;
194 
195  param->target_bit_rate = avctx->bit_rate;
196 
197  if (avctx->gop_size > 0)
198  param->intra_period_length = avctx->gop_size - 1;
199 
200  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
201  param->frame_rate_numerator = avctx->framerate.num;
202  param->frame_rate_denominator = avctx->framerate.den;
203  } else {
204  param->frame_rate_numerator = avctx->time_base.den;
205  param->frame_rate_denominator = avctx->time_base.num * avctx->ticks_per_frame;
206  }
207 
208  if (param->rate_control_mode) {
209  param->max_qp_allowed = avctx->qmax;
210  param->min_qp_allowed = avctx->qmin;
211  }
212 
213  param->intra_refresh_type = 2; /* Real keyframes only */
214 
215  if (svt_enc->la_depth >= 0)
216  param->look_ahead_distance = svt_enc->la_depth;
217 
218  param->tile_columns = svt_enc->tile_columns;
219  param->tile_rows = svt_enc->tile_rows;
220 
221  return 0;
222 }
223 
224 static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame,
225  EbBufferHeaderType *header_ptr)
226 {
227  EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
228  ptrdiff_t linesizes[4];
229  size_t sizes[4];
230  int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
231  int ret, frame_size;
232 
233  for (int i = 0; i < 4; i++)
234  linesizes[i] = frame->linesize[i];
235 
236  ret = av_image_fill_plane_sizes(sizes, frame->format, frame->height,
237  linesizes);
238  if (ret < 0)
239  return ret;
240 
241  frame_size = 0;
242  for (int i = 0; i < 4; i++) {
243  if (sizes[i] > INT_MAX - frame_size)
244  return AVERROR(EINVAL);
245  frame_size += sizes[i];
246  }
247 
248  in_data->luma = frame->data[0];
249  in_data->cb = frame->data[1];
250  in_data->cr = frame->data[2];
251 
252  in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
253  in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
254  in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
255 
256  header_ptr->n_filled_len = frame_size;
257 
258  return 0;
259 }
260 
262 {
263  SvtContext *svt_enc = avctx->priv_data;
264  EbErrorType svt_ret;
265  int ret;
266 
267  svt_enc->eos_flag = EOS_NOT_REACHED;
268 
269  svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
270  if (svt_ret != EB_ErrorNone) {
271  return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");
272  }
273 
274  ret = config_enc_params(&svt_enc->enc_params, avctx);
275  if (ret < 0) {
276  av_log(avctx, AV_LOG_ERROR, "Error configuring encoder parameters\n");
277  return ret;
278  }
279 
280  svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
281  if (svt_ret != EB_ErrorNone) {
282  return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
283  }
284 
285  svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
286  if (svt_ret != EB_ErrorNone) {
287  return svt_print_error(avctx, svt_ret, "Error initializing encoder");
288  }
289 
290  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
291  EbBufferHeaderType *headerPtr = NULL;
292 
293  svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
294  if (svt_ret != EB_ErrorNone) {
295  return svt_print_error(avctx, svt_ret, "Error building stream header");
296  }
297 
298  avctx->extradata_size = headerPtr->n_filled_len;
300  if (!avctx->extradata) {
301  av_log(avctx, AV_LOG_ERROR,
302  "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
303  return AVERROR(ENOMEM);
304  }
305 
306  memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
307 
308  svt_ret = svt_av1_enc_stream_header_release(headerPtr);
309  if (svt_ret != EB_ErrorNone) {
310  return svt_print_error(avctx, svt_ret, "Error freeing stream header");
311  }
312  }
313 
314  svt_enc->frame = av_frame_alloc();
315  if (!svt_enc->frame)
316  return AVERROR(ENOMEM);
317 
318  return alloc_buffer(&svt_enc->enc_params, svt_enc);
319 }
320 
321 static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
322 {
323  SvtContext *svt_enc = avctx->priv_data;
324  EbBufferHeaderType *headerPtr = svt_enc->in_buf;
325  int ret;
326 
327  if (!frame) {
328  EbBufferHeaderType headerPtrLast;
329 
330  if (svt_enc->eos_flag == EOS_SENT)
331  return 0;
332 
333  headerPtrLast.n_alloc_len = 0;
334  headerPtrLast.n_filled_len = 0;
335  headerPtrLast.n_tick_count = 0;
336  headerPtrLast.p_app_private = NULL;
337  headerPtrLast.p_buffer = NULL;
338  headerPtrLast.flags = EB_BUFFERFLAG_EOS;
339 
340  svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
341  svt_enc->eos_flag = EOS_SENT;
342  return 0;
343  }
344 
345  ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);
346  if (ret < 0)
347  return ret;
348 
349  headerPtr->flags = 0;
350  headerPtr->p_app_private = NULL;
351  headerPtr->pts = frame->pts;
352 
353  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
354 
355  return 0;
356 }
357 
358 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
359 {
360  if (filled_len > svt_enc->max_tu_size) {
361  const int max_frames = 8;
362  int max_tu_size;
363 
364  if (filled_len > svt_enc->raw_size * max_frames) {
365  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
366  return NULL;
367  }
368 
369  max_tu_size = 1 << av_ceil_log2(filled_len);
370  av_buffer_pool_uninit(&svt_enc->pool);
371  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
372  if (!svt_enc->pool)
373  return NULL;
374 
375  svt_enc->max_tu_size = max_tu_size;
376  }
377  av_assert0(svt_enc->pool);
378 
379  return av_buffer_pool_get(svt_enc->pool);
380 }
381 
383 {
384  SvtContext *svt_enc = avctx->priv_data;
385  EbBufferHeaderType *headerPtr;
386  AVFrame *frame = svt_enc->frame;
387  EbErrorType svt_ret;
388  AVBufferRef *ref;
389  int ret = 0, pict_type;
390 
391  if (svt_enc->eos_flag == EOS_RECEIVED)
392  return AVERROR_EOF;
393 
394  ret = ff_encode_get_frame(avctx, frame);
395  if (ret < 0 && ret != AVERROR_EOF)
396  return ret;
397  if (ret == AVERROR_EOF)
398  frame = NULL;
399 
400  ret = eb_send_frame(avctx, frame);
401  if (ret < 0)
402  return ret;
403  av_frame_unref(svt_enc->frame);
404 
405  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
406  if (svt_ret == EB_NoErrorEmptyQueue)
407  return AVERROR(EAGAIN);
408 
409  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
410  if (!ref) {
411  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
412  svt_av1_enc_release_out_buffer(&headerPtr);
413  return AVERROR(ENOMEM);
414  }
415  pkt->buf = ref;
416  pkt->data = ref->data;
417 
418  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
419  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
420 
421  pkt->size = headerPtr->n_filled_len;
422  pkt->pts = headerPtr->pts;
423  pkt->dts = headerPtr->dts;
424 
425  switch (headerPtr->pic_type) {
426  case EB_AV1_KEY_PICTURE:
428  // fall-through
429  case EB_AV1_INTRA_ONLY_PICTURE:
430  pict_type = AV_PICTURE_TYPE_I;
431  break;
432  case EB_AV1_INVALID_PICTURE:
433  pict_type = AV_PICTURE_TYPE_NONE;
434  break;
435  default:
436  pict_type = AV_PICTURE_TYPE_P;
437  break;
438  }
439 
440  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
442 
443  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
444  svt_enc->eos_flag = EOS_RECEIVED;
445 
446  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
447 
448  svt_av1_enc_release_out_buffer(&headerPtr);
449 
450  return 0;
451 }
452 
454 {
455  SvtContext *svt_enc = avctx->priv_data;
456 
457  if (svt_enc->svt_handle) {
458  svt_av1_enc_deinit(svt_enc->svt_handle);
459  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
460  }
461  if (svt_enc->in_buf) {
462  av_free(svt_enc->in_buf->p_buffer);
463  av_freep(&svt_enc->in_buf);
464  }
465 
466  av_buffer_pool_uninit(&svt_enc->pool);
467  av_frame_free(&svt_enc->frame);
468 
469  return 0;
470 }
471 
472 #define OFFSET(x) offsetof(SvtContext, x)
473 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
474 static const AVOption options[] = {
475  { "hielevel", "Hierarchical prediction levels setting", OFFSET(hierarchical_level),
476  AV_OPT_TYPE_INT, { .i64 = 4 }, 3, 4, VE , "hielevel"},
477  { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "hielevel" },
478  { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 }, INT_MIN, INT_MAX, VE, "hielevel" },
479 
480  { "la_depth", "Look ahead distance [0, 120]", OFFSET(la_depth),
481  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE },
482 
483  { "preset", "Encoding preset [0, 8]",
484  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = MAX_ENC_PRESET }, 0, MAX_ENC_PRESET, VE },
485 
486  { "tier", "Set operating point tier", OFFSET(tier),
487  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "tier" },
488  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
489  { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
490 
492 
493 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
494  { .i64 = value }, 0, 0, VE, "avctx.level"
495  { LEVEL("2.0", 20) },
496  { LEVEL("2.1", 21) },
497  { LEVEL("2.2", 22) },
498  { LEVEL("2.3", 23) },
499  { LEVEL("3.0", 30) },
500  { LEVEL("3.1", 31) },
501  { LEVEL("3.2", 32) },
502  { LEVEL("3.3", 33) },
503  { LEVEL("4.0", 40) },
504  { LEVEL("4.1", 41) },
505  { LEVEL("4.2", 42) },
506  { LEVEL("4.3", 43) },
507  { LEVEL("5.0", 50) },
508  { LEVEL("5.1", 51) },
509  { LEVEL("5.2", 52) },
510  { LEVEL("5.3", 53) },
511  { LEVEL("6.0", 60) },
512  { LEVEL("6.1", 61) },
513  { LEVEL("6.2", 62) },
514  { LEVEL("6.3", 63) },
515  { LEVEL("7.0", 70) },
516  { LEVEL("7.1", 71) },
517  { LEVEL("7.2", 72) },
518  { LEVEL("7.3", 73) },
519 #undef LEVEL
520 
521  { "rc", "Bit rate control mode", OFFSET(rc_mode),
522  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VE , "rc"},
523  { "cqp", "Constant quantizer", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "rc" },
524  { "vbr", "Variable Bit Rate, use a target bitrate for the entire stream", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "rc" },
525  { "cvbr", "Constrained Variable Bit Rate, use a target bitrate for each GOP", 0, AV_OPT_TYPE_CONST,{ .i64 = 2 }, INT_MIN, INT_MAX, VE, "rc" },
526 
527  { "qp", "Quantizer to use with cqp rate control mode", OFFSET(qp),
528  AV_OPT_TYPE_INT, { .i64 = 50 }, 0, 63, VE },
529 
530  { "sc_detection", "Scene change detection", OFFSET(scd),
531  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
532 
533  { "tile_columns", "Log2 of number of tile columns to use", OFFSET(tile_columns), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, VE},
534  { "tile_rows", "Log2 of number of tile rows to use", OFFSET(tile_rows), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 6, VE},
535 
536  {NULL},
537 };
538 
539 static const AVClass class = {
540  .class_name = "libsvtav1",
541  .item_name = av_default_item_name,
542  .option = options,
544 };
545 
546 static const AVCodecDefault eb_enc_defaults[] = {
547  { "b", "7M" },
548  { "g", "-1" },
549  { "qmin", "0" },
550  { "qmax", "63" },
551  { NULL },
552 };
553 
555  .name = "libsvtav1",
556  .long_name = NULL_IF_CONFIG_SMALL("SVT-AV1(Scalable Video Technology for AV1) encoder"),
557  .priv_data_size = sizeof(SvtContext),
559  .id = AV_CODEC_ID_AV1,
560  .init = eb_enc_init,
561  .receive_packet = eb_receive_packet,
562  .close = eb_enc_close,
564  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
565  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
567  AV_PIX_FMT_NONE },
568  .priv_class = &class,
569  .defaults = eb_enc_defaults,
570  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
571  .wrapper_name = "libsvtav1",
572 };
AVCodec
AVCodec.
Definition: codec.h:197
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:266
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
get_output_ref
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:358
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:78
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:601
SvtContext
Definition: libsvtav1.c:46
FF_AV1_PROFILE_OPTS
#define FF_AV1_PROFILE_OPTS
Definition: profiles.h:54
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
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:373
AVOption
AVOption.
Definition: opt.h:247
encode.h
SvtContext::frame
AVFrame * frame
Definition: libsvtav1.c:56
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
eb_receive_packet
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:382
eb_enc_init
static av_cold int eb_enc_init(AVCodecContext *avctx)
Definition: libsvtav1.c:261
FF_LEVEL_UNKNOWN
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1648
eb_enc_close
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:453
AV_PKT_FLAG_DISPOSABLE
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
Definition: packet.h:444
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:1161
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:264
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1706
eb_enc_defaults
static const AVCodecDefault eb_enc_defaults[]
Definition: libsvtav1.c:546
av_ceil_log2
#define av_ceil_log2
Definition: common.h:93
eb_err
EbErrorType eb_err
Definition: libsvtav1.c:77
eb_send_frame
static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Definition: libsvtav1.c:321
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:459
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
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
SvtContext::tile_rows
int tile_rows
Definition: libsvtav1.c:73
avassert.h
EOS_RECEIVED
@ EOS_RECEIVED
Definition: libsvtav1.c:43
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:373
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
frame_size
int frame_size
Definition: mxfenc.c:2206
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:511
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:122
tile_rows
int tile_rows
Definition: h265_levels.c:217
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1522
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
SvtContext::enc_mode
int enc_mode
Definition: libsvtav1.c:65
SvtContext::hierarchical_level
int hierarchical_level
Definition: libsvtav1.c:63
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:66
AVCodecDefault
Definition: internal.h:213
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:356
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
sizes
static const int sizes[][2]
Definition: img2dec.c:53
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
av_image_fill_plane_sizes
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:429
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
profiles.h
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:308
SvtContext::pool
AVBufferPool * pool
Definition: libsvtav1.c:58
AVCodecContext::level
int level
level
Definition: avcodec.h:1647
LEVEL
#define LEVEL(name, value)
SvtContext::tile_columns
int tile_columns
Definition: libsvtav1.c:72
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
SvtContext::scd
int scd
Definition: libsvtav1.c:67
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:502
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:81
AVPacket::size
int size
Definition: packet.h:374
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:116
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:574
EOS_NOT_REACHED
@ EOS_NOT_REACHED
Definition: libsvtav1.c:41
config_enc_params
static int config_enc_params(EbSvtAv1EncConfiguration *param, AVCodecContext *avctx)
Definition: libsvtav1.c:149
SvtContext::svt_handle
EbComponentType * svt_handle
Definition: libsvtav1.c:50
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:273
alloc_buffer
static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
Definition: libsvtav1.c:121
frame.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
options
static const AVOption options[]
Definition: libsvtav1.c:474
VE
#define VE
Definition: libsvtav1.c:473
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:379
svt_map_error
static int svt_map_error(EbErrorType eb_err, const char **desc)
Definition: libsvtav1.c:95
SvtContext::eos_flag
EOS_STATUS eos_flag
Definition: libsvtav1.c:60
i
int i
Definition: input.c:406
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
eos_status
eos_status
Definition: libsvtav1.c:40
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:480
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: internal.h:50
OFFSET
#define OFFSET(x)
Definition: libsvtav1.c:472
av_err
int av_err
Definition: libsvtav1.c:78
SvtContext::max_tu_size
int max_tu_size
Definition: libsvtav1.c:54
common.h
SvtContext::raw_size
int raw_size
Definition: libsvtav1.c:53
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
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:243
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:552
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
SvtContext::enc_params
EbSvtAv1EncConfiguration enc_params
Definition: libsvtav1.c:49
FF_PROFILE_AV1_PROFESSIONAL
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1619
avcodec.h
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
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
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
svt_print_error
static int svt_print_error(void *log_ctx, EbErrorType err, const char *error_string)
Definition: libsvtav1.c:110
AVCodecContext
main external API structure.
Definition: avcodec.h:379
SvtContext::la_depth
int la_depth
Definition: libsvtav1.c:64
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1154
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:224
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1521
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
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:77
SvtContext::in_buf
EbBufferHeaderType * in_buf
Definition: libsvtav1.c:52
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:157
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
SvtContext::tier
int tier
Definition: libsvtav1.c:70
SvtContext::rc_mode
int rc_mode
Definition: libsvtav1.c:66
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_libsvtav1_encoder
const AVCodec ff_libsvtav1_encoder
Definition: libsvtav1.c:554
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
svt_errors
static const struct @85 svt_errors[]
EOS_SENT
@ EOS_SENT
Definition: libsvtav1.c:42
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
SvtContext::qp
int qp
Definition: libsvtav1.c:68
FF_PROFILE_AV1_HIGH
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1618
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:84
read_in_data
static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame, EbBufferHeaderType *header_ptr)
Definition: libsvtav1.c:224
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233