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  headerPtrLast.n_alloc_len = 0;
428  headerPtrLast.n_filled_len = 0;
429  headerPtrLast.n_tick_count = 0;
430  headerPtrLast.p_app_private = NULL;
431  headerPtrLast.p_buffer = NULL;
432  headerPtrLast.flags = EB_BUFFERFLAG_EOS;
433 
434  svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
435  svt_enc->eos_flag = EOS_SENT;
436  return 0;
437  }
438 
439  ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);
440  if (ret < 0)
441  return ret;
442 
443  headerPtr->flags = 0;
444  headerPtr->p_app_private = NULL;
445  headerPtr->pts = frame->pts;
446 
447  switch (frame->pict_type) {
448  case AV_PICTURE_TYPE_I:
449  headerPtr->pic_type = EB_AV1_KEY_PICTURE;
450  break;
451  default:
452  // Actually means auto, or default.
453  headerPtr->pic_type = EB_AV1_INVALID_PICTURE;
454  break;
455  }
456 
457  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
458 
459  return 0;
460 }
461 
462 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
463 {
464  if (filled_len > svt_enc->max_tu_size) {
465  const int max_frames = 8;
466  int max_tu_size;
467 
468  if (filled_len > svt_enc->raw_size * max_frames) {
469  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
470  return NULL;
471  }
472 
473  max_tu_size = 1 << av_ceil_log2(filled_len);
474  av_buffer_pool_uninit(&svt_enc->pool);
475  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
476  if (!svt_enc->pool)
477  return NULL;
478 
479  svt_enc->max_tu_size = max_tu_size;
480  }
481  av_assert0(svt_enc->pool);
482 
483  return av_buffer_pool_get(svt_enc->pool);
484 }
485 
487 {
488  SvtContext *svt_enc = avctx->priv_data;
489  EbBufferHeaderType *headerPtr;
490  AVFrame *frame = svt_enc->frame;
491  EbErrorType svt_ret;
492  AVBufferRef *ref;
493  int ret = 0, pict_type;
494 
495  if (svt_enc->eos_flag == EOS_RECEIVED)
496  return AVERROR_EOF;
497 
498  ret = ff_encode_get_frame(avctx, frame);
499  if (ret < 0 && ret != AVERROR_EOF)
500  return ret;
501  if (ret == AVERROR_EOF)
502  frame = NULL;
503 
504  ret = eb_send_frame(avctx, frame);
505  if (ret < 0)
506  return ret;
507  av_frame_unref(svt_enc->frame);
508 
509  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
510  if (svt_ret == EB_NoErrorEmptyQueue)
511  return AVERROR(EAGAIN);
512 
513  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
514  if (!ref) {
515  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
516  svt_av1_enc_release_out_buffer(&headerPtr);
517  return AVERROR(ENOMEM);
518  }
519  pkt->buf = ref;
520  pkt->data = ref->data;
521 
522  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
523  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
524 
525  pkt->size = headerPtr->n_filled_len;
526  pkt->pts = headerPtr->pts;
527  pkt->dts = headerPtr->dts;
528 
529  switch (headerPtr->pic_type) {
530  case EB_AV1_KEY_PICTURE:
532  // fall-through
533  case EB_AV1_INTRA_ONLY_PICTURE:
534  pict_type = AV_PICTURE_TYPE_I;
535  break;
536  case EB_AV1_INVALID_PICTURE:
537  pict_type = AV_PICTURE_TYPE_NONE;
538  break;
539  default:
540  pict_type = AV_PICTURE_TYPE_P;
541  break;
542  }
543 
544  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
546 
547  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
548  svt_enc->eos_flag = EOS_RECEIVED;
549 
550  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
551 
552  svt_av1_enc_release_out_buffer(&headerPtr);
553 
554  return 0;
555 }
556 
558 {
559  SvtContext *svt_enc = avctx->priv_data;
560 
561  if (svt_enc->svt_handle) {
562  svt_av1_enc_deinit(svt_enc->svt_handle);
563  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
564  }
565  if (svt_enc->in_buf) {
566  av_free(svt_enc->in_buf->p_buffer);
567  av_freep(&svt_enc->in_buf);
568  }
569 
570  av_buffer_pool_uninit(&svt_enc->pool);
571  av_frame_free(&svt_enc->frame);
572 
573  return 0;
574 }
575 
576 #define OFFSET(x) offsetof(SvtContext, x)
577 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
578 static const AVOption options[] = {
579 #if FF_API_SVTAV1_OPTS
580  { "hielevel", "Hierarchical prediction levels setting (Deprecated, use svtav1-params)", OFFSET(hierarchical_level),
581  AV_OPT_TYPE_INT, { .i64 = 4 }, 3, 4, VE | AV_OPT_FLAG_DEPRECATED , "hielevel"},
582  { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "hielevel" },
583  { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 }, INT_MIN, INT_MAX, VE, "hielevel" },
584 
585  { "la_depth", "Look ahead distance [0, 120] (Deprecated, use svtav1-params)", OFFSET(la_depth),
586  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE | AV_OPT_FLAG_DEPRECATED },
587 
588  { "tier", "Set operating point tier (Deprecated, use svtav1-params)", OFFSET(tier),
589  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE | AV_OPT_FLAG_DEPRECATED, "tier" },
590  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
591  { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
592 #endif
593  { "preset", "Encoding preset",
594  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_ENC_PRESET, VE },
595 
597 
598 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
599  { .i64 = value }, 0, 0, VE, "avctx.level"
600  { LEVEL("2.0", 20) },
601  { LEVEL("2.1", 21) },
602  { LEVEL("2.2", 22) },
603  { LEVEL("2.3", 23) },
604  { LEVEL("3.0", 30) },
605  { LEVEL("3.1", 31) },
606  { LEVEL("3.2", 32) },
607  { LEVEL("3.3", 33) },
608  { LEVEL("4.0", 40) },
609  { LEVEL("4.1", 41) },
610  { LEVEL("4.2", 42) },
611  { LEVEL("4.3", 43) },
612  { LEVEL("5.0", 50) },
613  { LEVEL("5.1", 51) },
614  { LEVEL("5.2", 52) },
615  { LEVEL("5.3", 53) },
616  { LEVEL("6.0", 60) },
617  { LEVEL("6.1", 61) },
618  { LEVEL("6.2", 62) },
619  { LEVEL("6.3", 63) },
620  { LEVEL("7.0", 70) },
621  { LEVEL("7.1", 71) },
622  { LEVEL("7.2", 72) },
623  { LEVEL("7.3", 73) },
624 #undef LEVEL
625 
626  { "crf", "Constant Rate Factor value", OFFSET(crf),
627  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
628  { "qp", "Initial Quantizer level value", OFFSET(qp),
629  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
630 #if FF_API_SVTAV1_OPTS
631  { "sc_detection", "Scene change detection (Deprecated, use svtav1-params)", OFFSET(scd),
632  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE | AV_OPT_FLAG_DEPRECATED },
633 
634  { "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 },
635  { "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 },
636 #endif
637 
638  { "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 },
639 
640  {NULL},
641 };
642 
643 static const AVClass class = {
644  .class_name = "libsvtav1",
645  .item_name = av_default_item_name,
646  .option = options,
648 };
649 
650 static const FFCodecDefault eb_enc_defaults[] = {
651  { "b", "0" },
652  { "flags", "+cgop" },
653  { "g", "-1" },
654  { "qmin", "1" },
655  { "qmax", "63" },
656  { NULL },
657 };
658 
660  .p.name = "libsvtav1",
661  .p.long_name = NULL_IF_CONFIG_SMALL("SVT-AV1(Scalable Video Technology for AV1) encoder"),
662  .priv_data_size = sizeof(SvtContext),
663  .p.type = AVMEDIA_TYPE_VIDEO,
664  .p.id = AV_CODEC_ID_AV1,
665  .init = eb_enc_init,
667  .close = eb_enc_close,
670  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
672  AV_PIX_FMT_NONE },
673  .p.priv_class = &class,
674  .defaults = eb_enc_defaults,
675  .p.wrapper_name = "libsvtav1",
676 };
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:206
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:39
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:966
eb_enc_defaults
static const FFCodecDefault eb_enc_defaults[]
Definition: libsvtav1.c:650
get_output_ref
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:462
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:2662
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:1344
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:111
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:959
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:599
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:406
eb_receive_packet
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:486
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
FFCodec
Definition: codec_internal.h:112
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:526
FF_LEVEL_UNKNOWN
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1675
AVDictionary
Definition: dict.c:30
eb_enc_close
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:557
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:1025
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1185
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:3071
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:274
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1733
FFCodecDefault
Definition: codec_internal.h:82
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
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:469
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
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:952
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:40
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:387
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
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:2201
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:521
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:1549
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:1214
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1199
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:973
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:620
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:622
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:269
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:439
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
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1355
AVCodecContext::level
int level
level
Definition: avcodec.h:1674
ff_libsvtav1_encoder
const FFCodec ff_libsvtav1_encoder
Definition: libsvtav1.c:659
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:565
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:512
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:584
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:619
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:578
VE
#define VE
Definition: libsvtav1.c:577
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:119
SvtContext::eos_flag
EOS_STATUS eos_flag
Definition: libsvtav1.c:61
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:490
OFFSET
#define OFFSET(x)
Definition: libsvtav1.c:576
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:109
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:477
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:203
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:980
svt_errors
static const struct @87 svt_errors[]
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
SvtContext::enc_params
EbSvtAv1EncConfiguration enc_params
Definition: libsvtav1.c:50
FF_PROFILE_AV1_PROFESSIONAL
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1646
avcodec.h
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:288
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:125
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:389
SvtContext::la_depth
int la_depth
Definition: libsvtav1.c:67
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1178
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:1548
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:160
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:70
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:416
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:562
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:1645
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