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 "codec_internal.h"
35 #include "internal.h"
36 #include "encode.h"
37 #include "packet_internal.h"
38 #include "avcodec.h"
39 #include "profiles.h"
40 
41 typedef enum eos_status {
45 }EOS_STATUS;
46 
47 typedef struct SvtContext {
48  const AVClass *class;
49 
50  EbSvtAv1EncConfiguration enc_params;
51  EbComponentType *svt_handle;
52 
53  EbBufferHeaderType *in_buf;
54  int raw_size;
56 
58 
60 
61  EOS_STATUS eos_flag;
62 
63  // User options.
65 #if FF_API_SVTAV1_OPTS
67  int la_depth;
68  int scd;
69 
70  int tier;
71 
73  int tile_rows;
74 #endif
75  int enc_mode;
76  int crf;
77  int qp;
78 } SvtContext;
79 
80 static const struct {
81  EbErrorType eb_err;
82  int av_err;
83  const char *desc;
84 } svt_errors[] = {
85  { EB_ErrorNone, 0, "success" },
86  { EB_ErrorInsufficientResources, AVERROR(ENOMEM), "insufficient resources" },
87  { EB_ErrorUndefined, AVERROR(EINVAL), "undefined error" },
88  { EB_ErrorInvalidComponent, AVERROR(EINVAL), "invalid component" },
89  { EB_ErrorBadParameter, AVERROR(EINVAL), "bad parameter" },
90  { EB_ErrorDestroyThreadFailed, AVERROR_EXTERNAL, "failed to destroy thread" },
91  { EB_ErrorSemaphoreUnresponsive, AVERROR_EXTERNAL, "semaphore unresponsive" },
92  { EB_ErrorDestroySemaphoreFailed, AVERROR_EXTERNAL, "failed to destroy semaphore"},
93  { EB_ErrorCreateMutexFailed, AVERROR_EXTERNAL, "failed to create mutex" },
94  { EB_ErrorMutexUnresponsive, AVERROR_EXTERNAL, "mutex unresponsive" },
95  { EB_ErrorDestroyMutexFailed, AVERROR_EXTERNAL, "failed to destroy mutex" },
96  { EB_NoErrorEmptyQueue, AVERROR(EAGAIN), "empty queue" },
97 };
98 
99 static int svt_map_error(EbErrorType eb_err, const char **desc)
100 {
101  int i;
102 
103  av_assert0(desc);
104  for (i = 0; i < FF_ARRAY_ELEMS(svt_errors); i++) {
105  if (svt_errors[i].eb_err == eb_err) {
106  *desc = svt_errors[i].desc;
107  return svt_errors[i].av_err;
108  }
109  }
110  *desc = "unknown error";
111  return AVERROR_UNKNOWN;
112 }
113 
114 static int svt_print_error(void *log_ctx, EbErrorType err,
115  const char *error_string)
116 {
117  const char *desc;
118  int ret = svt_map_error(err, &desc);
119 
120  av_log(log_ctx, AV_LOG_ERROR, "%s: %s (0x%x)\n", error_string, desc, err);
121 
122  return ret;
123 }
124 
125 static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
126 {
127  const size_t luma_size = config->source_width * config->source_height *
128  (config->encoder_bit_depth > 8 ? 2 : 1);
129 
130  EbSvtIOFormat *in_data;
131 
132  svt_enc->raw_size = luma_size * 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  AVDictionaryEntry *en = NULL;
155 
156  // Update param from options
157 #if FF_API_SVTAV1_OPTS
158  if (svt_enc->hierarchical_level >= 0)
159  param->hierarchical_levels = svt_enc->hierarchical_level;
160  if (svt_enc->tier >= 0)
161  param->tier = svt_enc->tier;
162  if (svt_enc->scd >= 0)
163  param->scene_change_detection = svt_enc->scd;
164  if (svt_enc->tile_columns >= 0)
165  param->tile_columns = svt_enc->tile_columns;
166  if (svt_enc->tile_rows >= 0)
167  param->tile_rows = svt_enc->tile_rows;
168 
169  if (svt_enc->la_depth >= 0)
170  param->look_ahead_distance = svt_enc->la_depth;
171 #endif
172 
173  if (svt_enc->enc_mode >= -1)
174  param->enc_mode = svt_enc->enc_mode;
175 
176  if (avctx->bit_rate) {
177  param->target_bit_rate = avctx->bit_rate;
178  if (avctx->rc_max_rate != avctx->bit_rate)
179  param->rate_control_mode = 1;
180  else
181  param->rate_control_mode = 2;
182 
183  param->max_qp_allowed = avctx->qmax;
184  param->min_qp_allowed = avctx->qmin;
185  }
186  param->max_bit_rate = avctx->rc_max_rate;
187  if ((avctx->bit_rate > 0 || avctx->rc_max_rate > 0) && avctx->rc_buffer_size)
188  param->maximum_buffer_size_ms =
189  avctx->rc_buffer_size * 1000LL /
190  FFMAX(avctx->bit_rate, avctx->rc_max_rate);
191 
192  if (svt_enc->crf > 0) {
193  param->qp = svt_enc->crf;
194  param->rate_control_mode = 0;
195  } else if (svt_enc->qp > 0) {
196  param->qp = svt_enc->qp;
197  param->rate_control_mode = 0;
198  param->enable_adaptive_quantization = 0;
199  }
200 
201  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
202  param->color_primaries = avctx->color_primaries;
203  param->matrix_coefficients = (desc->flags & AV_PIX_FMT_FLAG_RGB) ?
204  AVCOL_SPC_RGB : avctx->colorspace;
205  param->transfer_characteristics = avctx->color_trc;
206 
208  param->color_range = avctx->color_range == AVCOL_RANGE_JPEG;
209  else
210  param->color_range = !!(desc->flags & AV_PIX_FMT_FLAG_RGB);
211 
212 #if SVT_AV1_CHECK_VERSION(1, 0, 0)
214  const char *name =
216 
217  switch (avctx->chroma_sample_location) {
218  case AVCHROMA_LOC_LEFT:
219  param->chroma_sample_position = EB_CSP_VERTICAL;
220  break;
222  param->chroma_sample_position = EB_CSP_COLOCATED;
223  break;
224  default:
225  if (!name)
226  break;
227 
228  av_log(avctx, AV_LOG_WARNING,
229  "Specified chroma sample location %s is unsupported "
230  "on the AV1 bit stream level. Usage of a container that "
231  "allows passing this information - such as Matroska - "
232  "is recommended.\n",
233  name);
234  break;
235  }
236  }
237 #endif
238 
239  if (avctx->profile != AV_PROFILE_UNKNOWN)
240  param->profile = avctx->profile;
241 
242  if (avctx->level != AV_LEVEL_UNKNOWN)
243  param->level = avctx->level;
244 
245  // gop_size == 1 case is handled when encoding each frame by setting
246  // pic_type to EB_AV1_KEY_PICTURE. For gop_size > 1, set the
247  // intra_period_length. Even though setting intra_period_length to 0 should
248  // work in this case, it does not.
249  // See: https://gitlab.com/AOMediaCodec/SVT-AV1/-/issues/2076
250  if (avctx->gop_size > 1)
251  param->intra_period_length = avctx->gop_size - 1;
252 
253 #if SVT_AV1_CHECK_VERSION(1, 1, 0)
254  // In order for SVT-AV1 to force keyframes by setting pic_type to
255  // EB_AV1_KEY_PICTURE on any frame, force_key_frames has to be set. Note
256  // that this does not force all frames to be keyframes (it only forces a
257  // keyframe with pic_type is set to EB_AV1_KEY_PICTURE). As of now, SVT-AV1
258  // does not support arbitrary keyframe requests by setting pic_type to
259  // EB_AV1_KEY_PICTURE, so it is done only when gop_size == 1.
260  // FIXME: When SVT-AV1 supports arbitrary keyframe requests, this code needs
261  // to be updated to set force_key_frames accordingly.
262  if (avctx->gop_size == 1)
263  param->force_key_frames = 1;
264 #endif
265 
266  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
267  param->frame_rate_numerator = avctx->framerate.num;
268  param->frame_rate_denominator = avctx->framerate.den;
269  } else {
270  param->frame_rate_numerator = avctx->time_base.den;
272  param->frame_rate_denominator = avctx->time_base.num
273 #if FF_API_TICKS_PER_FRAME
274  * avctx->ticks_per_frame
275 #endif
276  ;
278  }
279 
280  /* 2 = IDR, closed GOP, 1 = CRA, open GOP */
281  param->intra_refresh_type = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ? 2 : 1;
282 
283 #if SVT_AV1_CHECK_VERSION(0, 9, 1)
284  while ((en = av_dict_get(svt_enc->svtav1_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
285  EbErrorType ret = svt_av1_enc_parse_parameter(param, en->key, en->value);
286  if (ret != EB_ErrorNone) {
288  av_log(avctx, level, "Error parsing option %s: %s.\n", en->key, en->value);
289  if (avctx->err_recognition & AV_EF_EXPLODE)
290  return AVERROR(EINVAL);
291  }
292  }
293 #else
294  if ((en = av_dict_get(svt_enc->svtav1_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
296  av_log(avctx, level, "svt-params needs libavcodec to be compiled with SVT-AV1 "
297  "headers >= 0.9.1.\n");
298  if (avctx->err_recognition & AV_EF_EXPLODE)
299  return AVERROR(ENOSYS);
300  }
301 #endif
302 
303  param->source_width = avctx->width;
304  param->source_height = avctx->height;
305 
306  param->encoder_bit_depth = desc->comp[0].depth;
307 
308  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
309  param->encoder_color_format = EB_YUV420;
310  else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0)
311  param->encoder_color_format = EB_YUV422;
312  else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
313  param->encoder_color_format = EB_YUV444;
314  else {
315  av_log(avctx, AV_LOG_ERROR , "Unsupported pixel format\n");
316  return AVERROR(EINVAL);
317  }
318 
319  if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
320  && param->profile != AV_PROFILE_AV1_PROFESSIONAL ) {
321  av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
322  param->profile = AV_PROFILE_AV1_PROFESSIONAL;
323  } else if (param->encoder_color_format == EB_YUV444 && param->profile != AV_PROFILE_AV1_HIGH) {
324  av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
325  param->profile = AV_PROFILE_AV1_HIGH;
326  }
327 
328  avctx->bit_rate = param->rate_control_mode > 0 ?
329  param->target_bit_rate : 0;
330  avctx->rc_max_rate = param->max_bit_rate;
331  avctx->rc_buffer_size = param->maximum_buffer_size_ms *
332  FFMAX(avctx->bit_rate, avctx->rc_max_rate) / 1000LL;
333 
334  if (avctx->bit_rate || avctx->rc_max_rate || avctx->rc_buffer_size) {
335  AVCPBProperties *cpb_props = ff_encode_add_cpb_side_data(avctx);
336  if (!cpb_props)
337  return AVERROR(ENOMEM);
338 
339  cpb_props->buffer_size = avctx->rc_buffer_size;
340  cpb_props->max_bitrate = avctx->rc_max_rate;
341  cpb_props->avg_bitrate = avctx->bit_rate;
342  }
343 
344  return 0;
345 }
346 
347 static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame,
348  EbBufferHeaderType *header_ptr)
349 {
350  EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
351  ptrdiff_t linesizes[4];
352  size_t sizes[4];
353  int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
354  int ret, frame_size;
355 
356  for (int i = 0; i < 4; i++)
357  linesizes[i] = frame->linesize[i];
358 
360  linesizes);
361  if (ret < 0)
362  return ret;
363 
364  frame_size = 0;
365  for (int i = 0; i < 4; i++) {
366  if (sizes[i] > INT_MAX - frame_size)
367  return AVERROR(EINVAL);
368  frame_size += sizes[i];
369  }
370 
371  in_data->luma = frame->data[0];
372  in_data->cb = frame->data[1];
373  in_data->cr = frame->data[2];
374 
375  in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
376  in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
377  in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
378 
379  header_ptr->n_filled_len = frame_size;
380 
381  return 0;
382 }
383 
385 {
386  SvtContext *svt_enc = avctx->priv_data;
387  EbErrorType svt_ret;
388  int ret;
389 
390  svt_enc->eos_flag = EOS_NOT_REACHED;
391 
392  svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
393  if (svt_ret != EB_ErrorNone) {
394  return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");
395  }
396 
397  ret = config_enc_params(&svt_enc->enc_params, avctx);
398  if (ret < 0) {
399  av_log(avctx, AV_LOG_ERROR, "Error configuring encoder parameters\n");
400  return ret;
401  }
402 
403  svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
404  if (svt_ret != EB_ErrorNone) {
405  return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
406  }
407 
408  svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
409  if (svt_ret != EB_ErrorNone) {
410  return svt_print_error(avctx, svt_ret, "Error initializing encoder");
411  }
412 
413  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
414  EbBufferHeaderType *headerPtr = NULL;
415 
416  svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
417  if (svt_ret != EB_ErrorNone) {
418  return svt_print_error(avctx, svt_ret, "Error building stream header");
419  }
420 
421  avctx->extradata_size = headerPtr->n_filled_len;
423  if (!avctx->extradata) {
424  av_log(avctx, AV_LOG_ERROR,
425  "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
426  return AVERROR(ENOMEM);
427  }
428 
429  memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
430 
431  svt_ret = svt_av1_enc_stream_header_release(headerPtr);
432  if (svt_ret != EB_ErrorNone) {
433  return svt_print_error(avctx, svt_ret, "Error freeing stream header");
434  }
435  }
436 
437  svt_enc->frame = av_frame_alloc();
438  if (!svt_enc->frame)
439  return AVERROR(ENOMEM);
440 
441  return alloc_buffer(&svt_enc->enc_params, svt_enc);
442 }
443 
444 static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
445 {
446  SvtContext *svt_enc = avctx->priv_data;
447  EbBufferHeaderType *headerPtr = svt_enc->in_buf;
448  int ret;
449 
450  if (!frame) {
451  EbBufferHeaderType headerPtrLast;
452 
453  if (svt_enc->eos_flag == EOS_SENT)
454  return 0;
455 
456  memset(&headerPtrLast, 0, sizeof(headerPtrLast));
457  headerPtrLast.pic_type = EB_AV1_INVALID_PICTURE;
458  headerPtrLast.flags = EB_BUFFERFLAG_EOS;
459 
460  svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
461  svt_enc->eos_flag = EOS_SENT;
462  return 0;
463  }
464 
465  ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);
466  if (ret < 0)
467  return ret;
468 
469  headerPtr->flags = 0;
470  headerPtr->p_app_private = NULL;
471  headerPtr->pts = frame->pts;
472 
473  switch (frame->pict_type) {
474  case AV_PICTURE_TYPE_I:
475  headerPtr->pic_type = EB_AV1_KEY_PICTURE;
476  break;
477  default:
478  // Actually means auto, or default.
479  headerPtr->pic_type = EB_AV1_INVALID_PICTURE;
480  break;
481  }
482 
483  if (avctx->gop_size == 1)
484  headerPtr->pic_type = EB_AV1_KEY_PICTURE;
485 
486  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
487 
488  return 0;
489 }
490 
491 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
492 {
493  if (filled_len > svt_enc->max_tu_size) {
494  const int max_frames = 8;
495  int max_tu_size;
496 
497  if (filled_len > svt_enc->raw_size * max_frames) {
498  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
499  return NULL;
500  }
501 
502  max_tu_size = 1 << av_ceil_log2(filled_len);
503  av_buffer_pool_uninit(&svt_enc->pool);
504  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
505  if (!svt_enc->pool)
506  return NULL;
507 
508  svt_enc->max_tu_size = max_tu_size;
509  }
510  av_assert0(svt_enc->pool);
511 
512  return av_buffer_pool_get(svt_enc->pool);
513 }
514 
516 {
517  SvtContext *svt_enc = avctx->priv_data;
518  EbBufferHeaderType *headerPtr;
519  AVFrame *frame = svt_enc->frame;
520  EbErrorType svt_ret;
521  AVBufferRef *ref;
522  int ret = 0, pict_type;
523 
524  if (svt_enc->eos_flag == EOS_RECEIVED)
525  return AVERROR_EOF;
526 
527  ret = ff_encode_get_frame(avctx, frame);
528  if (ret < 0 && ret != AVERROR_EOF)
529  return ret;
530  if (ret == AVERROR_EOF)
531  frame = NULL;
532 
533  ret = eb_send_frame(avctx, frame);
534  if (ret < 0)
535  return ret;
536  av_frame_unref(svt_enc->frame);
537 
538  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
539  if (svt_ret == EB_NoErrorEmptyQueue)
540  return AVERROR(EAGAIN);
541 
542 #if SVT_AV1_CHECK_VERSION(2, 0, 0)
543  if (headerPtr->flags & EB_BUFFERFLAG_EOS) {
544  svt_enc->eos_flag = EOS_RECEIVED;
545  svt_av1_enc_release_out_buffer(&headerPtr);
546  return AVERROR_EOF;
547  }
548 #endif
549 
550  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
551  if (!ref) {
552  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
553  svt_av1_enc_release_out_buffer(&headerPtr);
554  return AVERROR(ENOMEM);
555  }
556  pkt->buf = ref;
557  pkt->data = ref->data;
558 
559  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
560  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
561 
562  pkt->size = headerPtr->n_filled_len;
563  pkt->pts = headerPtr->pts;
564  pkt->dts = headerPtr->dts;
565 
566  switch (headerPtr->pic_type) {
567  case EB_AV1_KEY_PICTURE:
569  // fall-through
570  case EB_AV1_INTRA_ONLY_PICTURE:
571  pict_type = AV_PICTURE_TYPE_I;
572  break;
573  case EB_AV1_INVALID_PICTURE:
574  pict_type = AV_PICTURE_TYPE_NONE;
575  break;
576  default:
577  pict_type = AV_PICTURE_TYPE_P;
578  break;
579  }
580 
581  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
583 
584 #if !(SVT_AV1_CHECK_VERSION(2, 0, 0))
585  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
586  svt_enc->eos_flag = EOS_RECEIVED;
587 #endif
588 
589  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
590 
591  svt_av1_enc_release_out_buffer(&headerPtr);
592 
593  return 0;
594 }
595 
597 {
598  SvtContext *svt_enc = avctx->priv_data;
599 
600  if (svt_enc->svt_handle) {
601  svt_av1_enc_deinit(svt_enc->svt_handle);
602  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
603  }
604  if (svt_enc->in_buf) {
605  av_free(svt_enc->in_buf->p_buffer);
606  av_freep(&svt_enc->in_buf);
607  }
608 
609  av_buffer_pool_uninit(&svt_enc->pool);
610  av_frame_free(&svt_enc->frame);
611 
612  return 0;
613 }
614 
615 #define OFFSET(x) offsetof(SvtContext, x)
616 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
617 static const AVOption options[] = {
618 #if FF_API_SVTAV1_OPTS
619  { "hielevel", "Hierarchical prediction levels setting (Deprecated, use svtav1-params)", OFFSET(hierarchical_level),
620  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 4, VE | AV_OPT_FLAG_DEPRECATED, .unit = "hielevel"},
621  { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, .unit = "hielevel" },
622  { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 }, INT_MIN, INT_MAX, VE, .unit = "hielevel" },
623 
624  { "la_depth", "Look ahead distance [0, 120] (Deprecated, use svtav1-params)", OFFSET(la_depth),
625  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE | AV_OPT_FLAG_DEPRECATED },
626 
627  { "tier", "Set operating point tier (Deprecated, use svtav1-params)", OFFSET(tier),
628  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE | AV_OPT_FLAG_DEPRECATED, .unit = "tier" },
629  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, .unit = "tier" },
630  { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, .unit = "tier" },
631 #endif
632  { "preset", "Encoding preset",
633  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = -2 }, -2, MAX_ENC_PRESET, VE },
634 
636 
637 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
638  { .i64 = value }, 0, 0, VE, .unit = "avctx.level"
639  { LEVEL("2.0", 20) },
640  { LEVEL("2.1", 21) },
641  { LEVEL("2.2", 22) },
642  { LEVEL("2.3", 23) },
643  { LEVEL("3.0", 30) },
644  { LEVEL("3.1", 31) },
645  { LEVEL("3.2", 32) },
646  { LEVEL("3.3", 33) },
647  { LEVEL("4.0", 40) },
648  { LEVEL("4.1", 41) },
649  { LEVEL("4.2", 42) },
650  { LEVEL("4.3", 43) },
651  { LEVEL("5.0", 50) },
652  { LEVEL("5.1", 51) },
653  { LEVEL("5.2", 52) },
654  { LEVEL("5.3", 53) },
655  { LEVEL("6.0", 60) },
656  { LEVEL("6.1", 61) },
657  { LEVEL("6.2", 62) },
658  { LEVEL("6.3", 63) },
659  { LEVEL("7.0", 70) },
660  { LEVEL("7.1", 71) },
661  { LEVEL("7.2", 72) },
662  { LEVEL("7.3", 73) },
663 #undef LEVEL
664 
665  { "crf", "Constant Rate Factor value", OFFSET(crf),
666  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
667  { "qp", "Initial Quantizer level value", OFFSET(qp),
668  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
669 #if FF_API_SVTAV1_OPTS
670  { "sc_detection", "Scene change detection (Deprecated, use svtav1-params)", OFFSET(scd),
671  AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE | AV_OPT_FLAG_DEPRECATED },
672 
673  { "tile_columns", "Log2 of number of tile columns to use (Deprecated, use svtav1-params)", OFFSET(tile_columns), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 4, VE | AV_OPT_FLAG_DEPRECATED },
674  { "tile_rows", "Log2 of number of tile rows to use (Deprecated, use svtav1-params)", OFFSET(tile_rows), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 6, VE | AV_OPT_FLAG_DEPRECATED },
675 #endif
676 
677  { "svtav1-params", "Set the SVT-AV1 configuration using a :-separated list of key=value parameters", OFFSET(svtav1_opts), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
678 
679  {NULL},
680 };
681 
682 static const AVClass class = {
683  .class_name = "libsvtav1",
684  .item_name = av_default_item_name,
685  .option = options,
687 };
688 
689 static const FFCodecDefault eb_enc_defaults[] = {
690  { "b", "0" },
691  { "flags", "+cgop" },
692  { "g", "-1" },
693  { "qmin", "1" },
694  { "qmax", "63" },
695  { NULL },
696 };
697 
699  .p.name = "libsvtav1",
700  CODEC_LONG_NAME("SVT-AV1(Scalable Video Technology for AV1) encoder"),
701  .priv_data_size = sizeof(SvtContext),
702  .p.type = AVMEDIA_TYPE_VIDEO,
703  .p.id = AV_CODEC_ID_AV1,
704  .init = eb_enc_init,
706  .close = eb_enc_close,
708  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
710  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
712  AV_PIX_FMT_NONE },
713  .p.priv_class = &class,
714  .defaults = eb_enc_defaults,
715  .p.wrapper_name = "libsvtav1",
716 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
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:280
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
name
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 default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
level
uint8_t level
Definition: svq3.c:204
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
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:1033
eb_enc_defaults
static const FFCodecDefault eb_enc_defaults[]
Definition: libsvtav1.c:689
get_output_ref
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:491
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
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:607
SvtContext
Definition: libsvtav1.c:47
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1416
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:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1026
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:687
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:251
encode.h
SvtContext::frame
AVFrame * frame
Definition: libsvtav1.c:57
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:482
eb_receive_packet
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:515
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
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
eb_enc_init
static av_cold int eb_enc_init(AVCodecContext *avctx)
Definition: libsvtav1.c:384
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:614
svt_errors
static const struct @107 svt_errors[]
AVDictionary
Definition: dict.c:34
eb_enc_close
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:596
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:596
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_PROFILE_AV1_PROFESSIONAL
#define AV_PROFILE_AV1_PROFESSIONAL
Definition: defs.h:169
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:1259
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:577
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3365
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:338
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1807
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
av_ceil_log2
#define av_ceil_log2
Definition: common.h:95
eb_err
EbErrorType eb_err
Definition: libsvtav1.c:81
eb_send_frame
static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Definition: libsvtav1.c:444
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:525
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:88
SvtContext::tile_rows
int tile_rows
Definition: libsvtav1.c:73
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1019
EOS_RECEIVED
@ EOS_RECEIVED
Definition: libsvtav1.c:44
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_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
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:384
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVDictionaryEntry::key
char * key
Definition: dict.h:90
frame_size
int frame_size
Definition: mxfenc.c:2422
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
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
SvtContext::enc_mode
int enc_mode
Definition: libsvtav1.c:75
SvtContext::hierarchical_level
int hierarchical_level
Definition: libsvtav1.c:66
tier
int tier
Definition: av1_levels.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
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1288
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1273
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:505
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:58
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1043
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:283
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:708
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:196
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
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:710
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:321
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:232
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
profiles.h
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
SvtContext::pool
AVBufferPool * pool
Definition: libsvtav1.c:59
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1744
ff_libsvtav1_encoder
const FFCodec ff_libsvtav1_encoder
Definition: libsvtav1.c:698
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:653
LEVEL
#define LEVEL(name, value)
SvtContext::tile_columns
int tile_columns
Definition: libsvtav1.c:72
SvtContext::scd
int scd
Definition: libsvtav1.c:68
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:567
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
AVPacket::size
int size
Definition: packet.h:523
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:647
codec_internal.h
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
EOS_NOT_REACHED
@ EOS_NOT_REACHED
Definition: libsvtav1.c:42
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
SvtContext::crf
int crf
Definition: libsvtav1.c:76
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:51
SvtContext::svtav1_opts
AVDictionary * svtav1_opts
Definition: libsvtav1.c:64
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:707
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
alloc_buffer
static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
Definition: libsvtav1.c:125
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:521
options
static const AVOption options[]
Definition: libsvtav1.c:617
VE
#define VE
Definition: libsvtav1.c:616
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_PROFILE_AV1_HIGH
#define AV_PROFILE_AV1_HIGH
Definition: defs.h:168
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
svt_map_error
static int svt_map_error(EbErrorType eb_err, const char **desc)
Definition: libsvtav1.c:99
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:284
SvtContext::eos_flag
EOS_STATUS eos_flag
Definition: libsvtav1.c:61
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
eos_status
eos_status
Definition: libsvtav1.c:41
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
OFFSET
#define OFFSET(x)
Definition: libsvtav1.c:615
av_err
int av_err
Definition: libsvtav1.c:82
SvtContext::max_tu_size
int max_tu_size
Definition: libsvtav1.c:55
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:274
SvtContext::raw_size
int raw_size
Definition: libsvtav1.c:54
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
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:1050
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
SvtContext::enc_params
EbSvtAv1EncConfiguration enc_params
Definition: libsvtav1.c:50
avcodec.h
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:352
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
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:290
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:114
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:412
SvtContext::la_depth
int la_depth
Definition: libsvtav1.c:67
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1252
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:225
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1600
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
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:583
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
SvtContext::in_buf
EbBufferHeaderType * in_buf
Definition: libsvtav1.c:53
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
desc
const char * desc
Definition: libsvtav1.c:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
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:209
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
packet_internal.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
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
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_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
EOS_SENT
@ EOS_SENT
Definition: libsvtav1.c:43
imgutils.h
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:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SvtContext::qp
int qp
Definition: libsvtav1.c:77
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:870
AVDictionaryEntry::value
char * value
Definition: dict.h:91
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
read_in_data
static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame, EbBufferHeaderType *header_ptr)
Definition: libsvtav1.c:347
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AV_OPT_FLAG_DEPRECATED
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information
Definition: opt.h:298