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 int pack_mode_10bit =
128  (config->encoder_bit_depth > 8) && (config->compressed_ten_bit_format == 0) ? 1 : 0;
129  const size_t luma_size_8bit =
130  config->source_width * config->source_height * (1 << pack_mode_10bit);
131  const size_t luma_size_10bit =
132  (config->encoder_bit_depth > 8 && pack_mode_10bit == 0) ? luma_size_8bit : 0;
133 
134  EbSvtIOFormat *in_data;
135 
136  svt_enc->raw_size = (luma_size_8bit + luma_size_10bit) * 3 / 2;
137 
138  // allocate buffer for in and out
139  svt_enc->in_buf = av_mallocz(sizeof(*svt_enc->in_buf));
140  if (!svt_enc->in_buf)
141  return AVERROR(ENOMEM);
142 
143  svt_enc->in_buf->p_buffer = av_mallocz(sizeof(*in_data));
144  if (!svt_enc->in_buf->p_buffer)
145  return AVERROR(ENOMEM);
146 
147  svt_enc->in_buf->size = sizeof(*svt_enc->in_buf);
148 
149  return 0;
150 
151 }
152 
153 static int config_enc_params(EbSvtAv1EncConfiguration *param,
154  AVCodecContext *avctx)
155 {
156  SvtContext *svt_enc = avctx->priv_data;
157  const AVPixFmtDescriptor *desc;
158  AVDictionaryEntry *en = NULL;
159 
160  // Update param from options
161 #if FF_API_SVTAV1_OPTS
162  param->hierarchical_levels = svt_enc->hierarchical_level;
163  param->tier = svt_enc->tier;
164  param->scene_change_detection = svt_enc->scd;
165  param->tile_columns = svt_enc->tile_columns;
166  param->tile_rows = svt_enc->tile_rows;
167 
168  if (svt_enc->la_depth >= 0)
169  param->look_ahead_distance = svt_enc->la_depth;
170 #endif
171 
172  if (svt_enc->enc_mode >= 0)
173  param->enc_mode = svt_enc->enc_mode;
174 
175  if (avctx->bit_rate) {
176  param->target_bit_rate = avctx->bit_rate;
177  if (avctx->rc_max_rate != avctx->bit_rate)
178  param->rate_control_mode = 1;
179  else
180  param->rate_control_mode = 2;
181 
182  param->max_qp_allowed = avctx->qmax;
183  param->min_qp_allowed = avctx->qmin;
184  }
185  param->max_bit_rate = avctx->rc_max_rate;
186  param->vbv_bufsize = avctx->rc_buffer_size;
187 
188  if (svt_enc->crf > 0) {
189  param->qp = svt_enc->crf;
190  param->rate_control_mode = 0;
191  } else if (svt_enc->qp > 0) {
192  param->qp = svt_enc->qp;
193  param->rate_control_mode = 0;
194  param->enable_adaptive_quantization = 0;
195  }
196 
197  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
198  param->color_primaries = avctx->color_primaries;
199  param->matrix_coefficients = (desc->flags & AV_PIX_FMT_FLAG_RGB) ?
200  AVCOL_SPC_RGB : avctx->colorspace;
201  param->transfer_characteristics = avctx->color_trc;
202 
204  param->color_range = avctx->color_range == AVCOL_RANGE_JPEG;
205  else
206  param->color_range = !!(desc->flags & AV_PIX_FMT_FLAG_RGB);
207 
208 #if SVT_AV1_CHECK_VERSION(1, 0, 0)
210  const char *name =
212 
213  switch (avctx->chroma_sample_location) {
214  case AVCHROMA_LOC_LEFT:
215  param->chroma_sample_position = EB_CSP_VERTICAL;
216  break;
218  param->chroma_sample_position = EB_CSP_COLOCATED;
219  break;
220  default:
221  if (!name)
222  break;
223 
224  av_log(avctx, AV_LOG_WARNING,
225  "Specified chroma sample location %s is unsupported "
226  "on the AV1 bit stream level. Usage of a container that "
227  "allows passing this information - such as Matroska - "
228  "is recommended.\n",
229  name);
230  break;
231  }
232  }
233 #endif
234 
235  if (avctx->profile != FF_PROFILE_UNKNOWN)
236  param->profile = avctx->profile;
237 
238  if (avctx->level != FF_LEVEL_UNKNOWN)
239  param->level = avctx->level;
240 
241  if (avctx->gop_size > 0)
242  param->intra_period_length = avctx->gop_size - 1;
243 
244  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
245  param->frame_rate_numerator = avctx->framerate.num;
246  param->frame_rate_denominator = avctx->framerate.den;
247  } else {
248  param->frame_rate_numerator = avctx->time_base.den;
249  param->frame_rate_denominator = avctx->time_base.num * avctx->ticks_per_frame;
250  }
251 
252  /* 2 = IDR, closed GOP, 1 = CRA, open GOP */
253  param->intra_refresh_type = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ? 2 : 1;
254 
255 #if SVT_AV1_CHECK_VERSION(0, 9, 1)
256  while ((en = av_dict_get(svt_enc->svtav1_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
257  EbErrorType ret = svt_av1_enc_parse_parameter(param, en->key, en->value);
258  if (ret != EB_ErrorNone) {
260  av_log(avctx, level, "Error parsing option %s: %s.\n", en->key, en->value);
261  if (avctx->err_recognition & AV_EF_EXPLODE)
262  return AVERROR(EINVAL);
263  }
264  }
265 #else
266  if ((en = av_dict_get(svt_enc->svtav1_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
268  av_log(avctx, level, "svt-params needs libavcodec to be compiled with SVT-AV1 "
269  "headers >= 0.9.1.\n");
270  if (avctx->err_recognition & AV_EF_EXPLODE)
271  return AVERROR(ENOSYS);
272  }
273 #endif
274 
275  param->source_width = avctx->width;
276  param->source_height = avctx->height;
277 
278  param->encoder_bit_depth = desc->comp[0].depth;
279 
280  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
281  param->encoder_color_format = EB_YUV420;
282  else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0)
283  param->encoder_color_format = EB_YUV422;
284  else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
285  param->encoder_color_format = EB_YUV444;
286  else {
287  av_log(avctx, AV_LOG_ERROR , "Unsupported pixel format\n");
288  return AVERROR(EINVAL);
289  }
290 
291  if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
292  && param->profile != FF_PROFILE_AV1_PROFESSIONAL ) {
293  av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
294  param->profile = FF_PROFILE_AV1_PROFESSIONAL;
295  } else if (param->encoder_color_format == EB_YUV444 && param->profile != FF_PROFILE_AV1_HIGH) {
296  av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
297  param->profile = FF_PROFILE_AV1_HIGH;
298  }
299 
300  avctx->bit_rate = param->rate_control_mode > 0 ?
301  param->target_bit_rate : 0;
302  avctx->rc_max_rate = param->max_bit_rate;
303  avctx->rc_buffer_size = param->vbv_bufsize;
304 
305  if (avctx->bit_rate || avctx->rc_max_rate || avctx->rc_buffer_size) {
306  AVCPBProperties *cpb_props = ff_add_cpb_side_data(avctx);
307  if (!cpb_props)
308  return AVERROR(ENOMEM);
309 
310  cpb_props->buffer_size = avctx->rc_buffer_size;
311  cpb_props->max_bitrate = avctx->rc_max_rate;
312  cpb_props->avg_bitrate = avctx->bit_rate;
313  }
314 
315  return 0;
316 }
317 
318 static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame,
319  EbBufferHeaderType *header_ptr)
320 {
321  EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
322  ptrdiff_t linesizes[4];
323  size_t sizes[4];
324  int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
325  int ret, frame_size;
326 
327  for (int i = 0; i < 4; i++)
328  linesizes[i] = frame->linesize[i];
329 
330  ret = av_image_fill_plane_sizes(sizes, frame->format, frame->height,
331  linesizes);
332  if (ret < 0)
333  return ret;
334 
335  frame_size = 0;
336  for (int i = 0; i < 4; i++) {
337  if (sizes[i] > INT_MAX - frame_size)
338  return AVERROR(EINVAL);
339  frame_size += sizes[i];
340  }
341 
342  in_data->luma = frame->data[0];
343  in_data->cb = frame->data[1];
344  in_data->cr = frame->data[2];
345 
346  in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
347  in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
348  in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
349 
350  header_ptr->n_filled_len = frame_size;
351 
352  return 0;
353 }
354 
356 {
357  SvtContext *svt_enc = avctx->priv_data;
358  EbErrorType svt_ret;
359  int ret;
360 
361  svt_enc->eos_flag = EOS_NOT_REACHED;
362 
363  svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
364  if (svt_ret != EB_ErrorNone) {
365  return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");
366  }
367 
368  ret = config_enc_params(&svt_enc->enc_params, avctx);
369  if (ret < 0) {
370  av_log(avctx, AV_LOG_ERROR, "Error configuring encoder parameters\n");
371  return ret;
372  }
373 
374  svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
375  if (svt_ret != EB_ErrorNone) {
376  return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
377  }
378 
379  svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
380  if (svt_ret != EB_ErrorNone) {
381  return svt_print_error(avctx, svt_ret, "Error initializing encoder");
382  }
383 
384  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
385  EbBufferHeaderType *headerPtr = NULL;
386 
387  svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
388  if (svt_ret != EB_ErrorNone) {
389  return svt_print_error(avctx, svt_ret, "Error building stream header");
390  }
391 
392  avctx->extradata_size = headerPtr->n_filled_len;
394  if (!avctx->extradata) {
395  av_log(avctx, AV_LOG_ERROR,
396  "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
397  return AVERROR(ENOMEM);
398  }
399 
400  memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
401 
402  svt_ret = svt_av1_enc_stream_header_release(headerPtr);
403  if (svt_ret != EB_ErrorNone) {
404  return svt_print_error(avctx, svt_ret, "Error freeing stream header");
405  }
406  }
407 
408  svt_enc->frame = av_frame_alloc();
409  if (!svt_enc->frame)
410  return AVERROR(ENOMEM);
411 
412  return alloc_buffer(&svt_enc->enc_params, svt_enc);
413 }
414 
415 static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
416 {
417  SvtContext *svt_enc = avctx->priv_data;
418  EbBufferHeaderType *headerPtr = svt_enc->in_buf;
419  int ret;
420 
421  if (!frame) {
422  EbBufferHeaderType headerPtrLast;
423 
424  if (svt_enc->eos_flag == EOS_SENT)
425  return 0;
426 
427  memset(&headerPtrLast, 0, sizeof(headerPtrLast));
428  headerPtrLast.pic_type = EB_AV1_INVALID_PICTURE;
429  headerPtrLast.flags = EB_BUFFERFLAG_EOS;
430 
431  svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
432  svt_enc->eos_flag = EOS_SENT;
433  return 0;
434  }
435 
436  ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);
437  if (ret < 0)
438  return ret;
439 
440  headerPtr->flags = 0;
441  headerPtr->p_app_private = NULL;
442  headerPtr->pts = frame->pts;
443 
444  switch (frame->pict_type) {
445  case AV_PICTURE_TYPE_I:
446  headerPtr->pic_type = EB_AV1_KEY_PICTURE;
447  break;
448  default:
449  // Actually means auto, or default.
450  headerPtr->pic_type = EB_AV1_INVALID_PICTURE;
451  break;
452  }
453 
454  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
455 
456  return 0;
457 }
458 
459 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
460 {
461  if (filled_len > svt_enc->max_tu_size) {
462  const int max_frames = 8;
463  int max_tu_size;
464 
465  if (filled_len > svt_enc->raw_size * max_frames) {
466  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
467  return NULL;
468  }
469 
470  max_tu_size = 1 << av_ceil_log2(filled_len);
471  av_buffer_pool_uninit(&svt_enc->pool);
472  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
473  if (!svt_enc->pool)
474  return NULL;
475 
476  svt_enc->max_tu_size = max_tu_size;
477  }
478  av_assert0(svt_enc->pool);
479 
480  return av_buffer_pool_get(svt_enc->pool);
481 }
482 
484 {
485  SvtContext *svt_enc = avctx->priv_data;
486  EbBufferHeaderType *headerPtr;
487  AVFrame *frame = svt_enc->frame;
488  EbErrorType svt_ret;
489  AVBufferRef *ref;
490  int ret = 0, pict_type;
491 
492  if (svt_enc->eos_flag == EOS_RECEIVED)
493  return AVERROR_EOF;
494 
495  ret = ff_encode_get_frame(avctx, frame);
496  if (ret < 0 && ret != AVERROR_EOF)
497  return ret;
498  if (ret == AVERROR_EOF)
499  frame = NULL;
500 
501  ret = eb_send_frame(avctx, frame);
502  if (ret < 0)
503  return ret;
504  av_frame_unref(svt_enc->frame);
505 
506  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
507  if (svt_ret == EB_NoErrorEmptyQueue)
508  return AVERROR(EAGAIN);
509 
510  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
511  if (!ref) {
512  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
513  svt_av1_enc_release_out_buffer(&headerPtr);
514  return AVERROR(ENOMEM);
515  }
516  pkt->buf = ref;
517  pkt->data = ref->data;
518 
519  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
520  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
521 
522  pkt->size = headerPtr->n_filled_len;
523  pkt->pts = headerPtr->pts;
524  pkt->dts = headerPtr->dts;
525 
526  switch (headerPtr->pic_type) {
527  case EB_AV1_KEY_PICTURE:
529  // fall-through
530  case EB_AV1_INTRA_ONLY_PICTURE:
531  pict_type = AV_PICTURE_TYPE_I;
532  break;
533  case EB_AV1_INVALID_PICTURE:
534  pict_type = AV_PICTURE_TYPE_NONE;
535  break;
536  default:
537  pict_type = AV_PICTURE_TYPE_P;
538  break;
539  }
540 
541  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
543 
544  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
545  svt_enc->eos_flag = EOS_RECEIVED;
546 
547  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
548 
549  svt_av1_enc_release_out_buffer(&headerPtr);
550 
551  return 0;
552 }
553 
555 {
556  SvtContext *svt_enc = avctx->priv_data;
557 
558  if (svt_enc->svt_handle) {
559  svt_av1_enc_deinit(svt_enc->svt_handle);
560  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
561  }
562  if (svt_enc->in_buf) {
563  av_free(svt_enc->in_buf->p_buffer);
564  av_freep(&svt_enc->in_buf);
565  }
566 
567  av_buffer_pool_uninit(&svt_enc->pool);
568  av_frame_free(&svt_enc->frame);
569 
570  return 0;
571 }
572 
573 #define OFFSET(x) offsetof(SvtContext, x)
574 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
575 static const AVOption options[] = {
576 #if FF_API_SVTAV1_OPTS
577  { "hielevel", "Hierarchical prediction levels setting (Deprecated, use svtav1-params)", OFFSET(hierarchical_level),
578  AV_OPT_TYPE_INT, { .i64 = 4 }, 3, 4, VE | AV_OPT_FLAG_DEPRECATED , "hielevel"},
579  { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "hielevel" },
580  { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 }, INT_MIN, INT_MAX, VE, "hielevel" },
581 
582  { "la_depth", "Look ahead distance [0, 120] (Deprecated, use svtav1-params)", OFFSET(la_depth),
583  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE | AV_OPT_FLAG_DEPRECATED },
584 
585  { "tier", "Set operating point tier (Deprecated, use svtav1-params)", OFFSET(tier),
586  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE | AV_OPT_FLAG_DEPRECATED, "tier" },
587  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
588  { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
589 #endif
590  { "preset", "Encoding preset",
591  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_ENC_PRESET, VE },
592 
594 
595 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
596  { .i64 = value }, 0, 0, VE, "avctx.level"
597  { LEVEL("2.0", 20) },
598  { LEVEL("2.1", 21) },
599  { LEVEL("2.2", 22) },
600  { LEVEL("2.3", 23) },
601  { LEVEL("3.0", 30) },
602  { LEVEL("3.1", 31) },
603  { LEVEL("3.2", 32) },
604  { LEVEL("3.3", 33) },
605  { LEVEL("4.0", 40) },
606  { LEVEL("4.1", 41) },
607  { LEVEL("4.2", 42) },
608  { LEVEL("4.3", 43) },
609  { LEVEL("5.0", 50) },
610  { LEVEL("5.1", 51) },
611  { LEVEL("5.2", 52) },
612  { LEVEL("5.3", 53) },
613  { LEVEL("6.0", 60) },
614  { LEVEL("6.1", 61) },
615  { LEVEL("6.2", 62) },
616  { LEVEL("6.3", 63) },
617  { LEVEL("7.0", 70) },
618  { LEVEL("7.1", 71) },
619  { LEVEL("7.2", 72) },
620  { LEVEL("7.3", 73) },
621 #undef LEVEL
622 
623  { "crf", "Constant Rate Factor value", OFFSET(crf),
624  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
625  { "qp", "Initial Quantizer level value", OFFSET(qp),
626  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
627 #if FF_API_SVTAV1_OPTS
628  { "sc_detection", "Scene change detection (Deprecated, use svtav1-params)", OFFSET(scd),
629  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE | AV_OPT_FLAG_DEPRECATED },
630 
631  { "tile_columns", "Log2 of number of tile columns to use (Deprecated, use svtav1-params)", OFFSET(tile_columns), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 4, VE | AV_OPT_FLAG_DEPRECATED },
632  { "tile_rows", "Log2 of number of tile rows to use (Deprecated, use svtav1-params)", OFFSET(tile_rows), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 6, VE | AV_OPT_FLAG_DEPRECATED },
633 #endif
634 
635  { "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 },
636 
637  {NULL},
638 };
639 
640 static const AVClass class = {
641  .class_name = "libsvtav1",
642  .item_name = av_default_item_name,
643  .option = options,
645 };
646 
647 static const FFCodecDefault eb_enc_defaults[] = {
648  { "b", "0" },
649  { "flags", "+cgop" },
650  { "g", "-1" },
651  { "qmin", "1" },
652  { "qmax", "63" },
653  { NULL },
654 };
655 
657  .p.name = "libsvtav1",
658  CODEC_LONG_NAME("SVT-AV1(Scalable Video Technology for AV1) encoder"),
659  .priv_data_size = sizeof(SvtContext),
660  .p.type = AVMEDIA_TYPE_VIDEO,
661  .p.id = AV_CODEC_ID_AV1,
662  .init = eb_enc_init,
664  .close = eb_enc_close,
666  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
668  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
670  AV_PIX_FMT_NONE },
671  .p.priv_class = &class,
672  .defaults = eb_enc_defaults,
673  .p.wrapper_name = "libsvtav1",
674 };
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:64
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:975
eb_enc_defaults
static const FFCodecDefault eb_enc_defaults[]
Definition: libsvtav1.c:647
get_output_ref
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:459
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:2860
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:602
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:1351
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:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:968
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:630
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
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:431
eb_receive_packet
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:483
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:68
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:119
eb_enc_init
static av_cold int eb_enc_init(AVCodecContext *avctx)
Definition: libsvtav1.c:355
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:557
FF_LEVEL_UNKNOWN
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1677
AVDictionary
Definition: dict.c:31
eb_enc_close
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:554
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:448
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1022
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1194
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:429
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3298
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:284
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1735
FFCodecDefault
Definition: codec_internal.h:89
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
av_ceil_log2
#define av_ceil_log2
Definition: common.h:92
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:415
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
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:104
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:961
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_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:41
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:500
svt_errors
static const struct @95 svt_errors[]
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
AVDictionaryEntry::key
char * key
Definition: dict.h:80
frame_size
int frame_size
Definition: mxfenc.c:2202
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:530
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:127
tile_rows
int tile_rows
Definition: h265_levels.c:217
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1551
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
SvtContext::enc_mode
int enc_mode
Definition: libsvtav1.c:75
SvtContext::hierarchical_level
int hierarchical_level
Definition: libsvtav1.c:66
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
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1223
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:126
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1208
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:357
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:57
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:982
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:651
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:653
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:313
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
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: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:322
SvtContext::pool
AVBufferPool * pool
Definition: libsvtav1.c:59
AVCodecContext::level
int level
level
Definition: avcodec.h:1676
ff_libsvtav1_encoder
const FFCodec ff_libsvtav1_encoder
Definition: libsvtav1.c:656
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:596
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:521
AVPacket::size
int size
Definition: packet.h:375
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:593
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:153
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:650
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: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:373
options
static const AVOption options[]
Definition: libsvtav1.c:575
VE
#define VE
Definition: libsvtav1.c:574
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:380
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:141
SvtContext::eos_flag
EOS_STATUS eos_flag
Definition: libsvtav1.c:61
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
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:499
OFFSET
#define OFFSET(x)
Definition: libsvtav1.c:573
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:131
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:487
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:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:989
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
SvtContext::enc_params
EbSvtAv1EncConfiguration enc_params
Definition: libsvtav1.c:50
FF_PROFILE_AV1_PROFESSIONAL
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1648
avcodec.h
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:298
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
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:147
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:398
SvtContext::la_depth
int la_depth
Definition: libsvtav1.c:67
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1187
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1550
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
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:82
SvtContext::in_buf
EbBufferHeaderType * in_buf
Definition: libsvtav1.c:53
desc
const char * desc
Definition: libsvtav1.c:83
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:178
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:79
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:571
EOS_SENT
@ EOS_SENT
Definition: libsvtav1.c:43
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SvtContext::qp
int qp
Definition: libsvtav1.c:77
FF_PROFILE_AV1_HIGH
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1647
AVDictionaryEntry::value
char * value
Definition: dict.h:81
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:318
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