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 >= 0)
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 && avctx->rc_buffer_size)
188  param->maximum_buffer_size_ms = avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
189 
190  if (svt_enc->crf > 0) {
191  param->qp = svt_enc->crf;
192  param->rate_control_mode = 0;
193  } else if (svt_enc->qp > 0) {
194  param->qp = svt_enc->qp;
195  param->rate_control_mode = 0;
196  param->enable_adaptive_quantization = 0;
197  }
198 
199  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
200  param->color_primaries = avctx->color_primaries;
201  param->matrix_coefficients = (desc->flags & AV_PIX_FMT_FLAG_RGB) ?
202  AVCOL_SPC_RGB : avctx->colorspace;
203  param->transfer_characteristics = avctx->color_trc;
204 
206  param->color_range = avctx->color_range == AVCOL_RANGE_JPEG;
207  else
208  param->color_range = !!(desc->flags & AV_PIX_FMT_FLAG_RGB);
209 
210 #if SVT_AV1_CHECK_VERSION(1, 0, 0)
212  const char *name =
214 
215  switch (avctx->chroma_sample_location) {
216  case AVCHROMA_LOC_LEFT:
217  param->chroma_sample_position = EB_CSP_VERTICAL;
218  break;
220  param->chroma_sample_position = EB_CSP_COLOCATED;
221  break;
222  default:
223  if (!name)
224  break;
225 
226  av_log(avctx, AV_LOG_WARNING,
227  "Specified chroma sample location %s is unsupported "
228  "on the AV1 bit stream level. Usage of a container that "
229  "allows passing this information - such as Matroska - "
230  "is recommended.\n",
231  name);
232  break;
233  }
234  }
235 #endif
236 
237  if (avctx->profile != FF_PROFILE_UNKNOWN)
238  param->profile = avctx->profile;
239 
240  if (avctx->level != FF_LEVEL_UNKNOWN)
241  param->level = avctx->level;
242 
243  if (avctx->gop_size > 0)
244  param->intra_period_length = avctx->gop_size - 1;
245 
246  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
247  param->frame_rate_numerator = avctx->framerate.num;
248  param->frame_rate_denominator = avctx->framerate.den;
249  } else {
250  param->frame_rate_numerator = avctx->time_base.den;
251  param->frame_rate_denominator = avctx->time_base.num * avctx->ticks_per_frame;
252  }
253 
254  /* 2 = IDR, closed GOP, 1 = CRA, open GOP */
255  param->intra_refresh_type = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ? 2 : 1;
256 
257 #if SVT_AV1_CHECK_VERSION(0, 9, 1)
258  while ((en = av_dict_get(svt_enc->svtav1_opts, "", en, AV_DICT_IGNORE_SUFFIX))) {
259  EbErrorType ret = svt_av1_enc_parse_parameter(param, en->key, en->value);
260  if (ret != EB_ErrorNone) {
262  av_log(avctx, level, "Error parsing option %s: %s.\n", en->key, en->value);
263  if (avctx->err_recognition & AV_EF_EXPLODE)
264  return AVERROR(EINVAL);
265  }
266  }
267 #else
268  if ((en = av_dict_get(svt_enc->svtav1_opts, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
270  av_log(avctx, level, "svt-params needs libavcodec to be compiled with SVT-AV1 "
271  "headers >= 0.9.1.\n");
272  if (avctx->err_recognition & AV_EF_EXPLODE)
273  return AVERROR(ENOSYS);
274  }
275 #endif
276 
277  param->source_width = avctx->width;
278  param->source_height = avctx->height;
279 
280  param->encoder_bit_depth = desc->comp[0].depth;
281 
282  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
283  param->encoder_color_format = EB_YUV420;
284  else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0)
285  param->encoder_color_format = EB_YUV422;
286  else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
287  param->encoder_color_format = EB_YUV444;
288  else {
289  av_log(avctx, AV_LOG_ERROR , "Unsupported pixel format\n");
290  return AVERROR(EINVAL);
291  }
292 
293  if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
294  && param->profile != FF_PROFILE_AV1_PROFESSIONAL ) {
295  av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
296  param->profile = FF_PROFILE_AV1_PROFESSIONAL;
297  } else if (param->encoder_color_format == EB_YUV444 && param->profile != FF_PROFILE_AV1_HIGH) {
298  av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
299  param->profile = FF_PROFILE_AV1_HIGH;
300  }
301 
302  avctx->bit_rate = param->rate_control_mode > 0 ?
303  param->target_bit_rate : 0;
304  avctx->rc_max_rate = param->max_bit_rate;
305  avctx->rc_buffer_size = param->maximum_buffer_size_ms * avctx->bit_rate / 1000LL;
306 
307  if (avctx->bit_rate || avctx->rc_max_rate || avctx->rc_buffer_size) {
308  AVCPBProperties *cpb_props = ff_add_cpb_side_data(avctx);
309  if (!cpb_props)
310  return AVERROR(ENOMEM);
311 
312  cpb_props->buffer_size = avctx->rc_buffer_size;
313  cpb_props->max_bitrate = avctx->rc_max_rate;
314  cpb_props->avg_bitrate = avctx->bit_rate;
315  }
316 
317  return 0;
318 }
319 
320 static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame,
321  EbBufferHeaderType *header_ptr)
322 {
323  EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
324  ptrdiff_t linesizes[4];
325  size_t sizes[4];
326  int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
327  int ret, frame_size;
328 
329  for (int i = 0; i < 4; i++)
330  linesizes[i] = frame->linesize[i];
331 
332  ret = av_image_fill_plane_sizes(sizes, frame->format, frame->height,
333  linesizes);
334  if (ret < 0)
335  return ret;
336 
337  frame_size = 0;
338  for (int i = 0; i < 4; i++) {
339  if (sizes[i] > INT_MAX - frame_size)
340  return AVERROR(EINVAL);
341  frame_size += sizes[i];
342  }
343 
344  in_data->luma = frame->data[0];
345  in_data->cb = frame->data[1];
346  in_data->cr = frame->data[2];
347 
348  in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
349  in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
350  in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
351 
352  header_ptr->n_filled_len = frame_size;
353 
354  return 0;
355 }
356 
358 {
359  SvtContext *svt_enc = avctx->priv_data;
360  EbErrorType svt_ret;
361  int ret;
362 
363  svt_enc->eos_flag = EOS_NOT_REACHED;
364 
365  svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
366  if (svt_ret != EB_ErrorNone) {
367  return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");
368  }
369 
370  ret = config_enc_params(&svt_enc->enc_params, avctx);
371  if (ret < 0) {
372  av_log(avctx, AV_LOG_ERROR, "Error configuring encoder parameters\n");
373  return ret;
374  }
375 
376  svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
377  if (svt_ret != EB_ErrorNone) {
378  return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
379  }
380 
381  svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
382  if (svt_ret != EB_ErrorNone) {
383  return svt_print_error(avctx, svt_ret, "Error initializing encoder");
384  }
385 
386  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
387  EbBufferHeaderType *headerPtr = NULL;
388 
389  svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
390  if (svt_ret != EB_ErrorNone) {
391  return svt_print_error(avctx, svt_ret, "Error building stream header");
392  }
393 
394  avctx->extradata_size = headerPtr->n_filled_len;
396  if (!avctx->extradata) {
397  av_log(avctx, AV_LOG_ERROR,
398  "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
399  return AVERROR(ENOMEM);
400  }
401 
402  memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
403 
404  svt_ret = svt_av1_enc_stream_header_release(headerPtr);
405  if (svt_ret != EB_ErrorNone) {
406  return svt_print_error(avctx, svt_ret, "Error freeing stream header");
407  }
408  }
409 
410  svt_enc->frame = av_frame_alloc();
411  if (!svt_enc->frame)
412  return AVERROR(ENOMEM);
413 
414  return alloc_buffer(&svt_enc->enc_params, svt_enc);
415 }
416 
417 static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
418 {
419  SvtContext *svt_enc = avctx->priv_data;
420  EbBufferHeaderType *headerPtr = svt_enc->in_buf;
421  int ret;
422 
423  if (!frame) {
424  EbBufferHeaderType headerPtrLast;
425 
426  if (svt_enc->eos_flag == EOS_SENT)
427  return 0;
428 
429  memset(&headerPtrLast, 0, sizeof(headerPtrLast));
430  headerPtrLast.pic_type = EB_AV1_INVALID_PICTURE;
431  headerPtrLast.flags = EB_BUFFERFLAG_EOS;
432 
433  svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
434  svt_enc->eos_flag = EOS_SENT;
435  return 0;
436  }
437 
438  ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);
439  if (ret < 0)
440  return ret;
441 
442  headerPtr->flags = 0;
443  headerPtr->p_app_private = NULL;
444  headerPtr->pts = frame->pts;
445 
446  switch (frame->pict_type) {
447  case AV_PICTURE_TYPE_I:
448  headerPtr->pic_type = EB_AV1_KEY_PICTURE;
449  break;
450  default:
451  // Actually means auto, or default.
452  headerPtr->pic_type = EB_AV1_INVALID_PICTURE;
453  break;
454  }
455 
456  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
457 
458  return 0;
459 }
460 
461 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
462 {
463  if (filled_len > svt_enc->max_tu_size) {
464  const int max_frames = 8;
465  int max_tu_size;
466 
467  if (filled_len > svt_enc->raw_size * max_frames) {
468  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
469  return NULL;
470  }
471 
472  max_tu_size = 1 << av_ceil_log2(filled_len);
473  av_buffer_pool_uninit(&svt_enc->pool);
474  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
475  if (!svt_enc->pool)
476  return NULL;
477 
478  svt_enc->max_tu_size = max_tu_size;
479  }
480  av_assert0(svt_enc->pool);
481 
482  return av_buffer_pool_get(svt_enc->pool);
483 }
484 
486 {
487  SvtContext *svt_enc = avctx->priv_data;
488  EbBufferHeaderType *headerPtr;
489  AVFrame *frame = svt_enc->frame;
490  EbErrorType svt_ret;
491  AVBufferRef *ref;
492  int ret = 0, pict_type;
493 
494  if (svt_enc->eos_flag == EOS_RECEIVED)
495  return AVERROR_EOF;
496 
497  ret = ff_encode_get_frame(avctx, frame);
498  if (ret < 0 && ret != AVERROR_EOF)
499  return ret;
500  if (ret == AVERROR_EOF)
501  frame = NULL;
502 
503  ret = eb_send_frame(avctx, frame);
504  if (ret < 0)
505  return ret;
506  av_frame_unref(svt_enc->frame);
507 
508  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
509  if (svt_ret == EB_NoErrorEmptyQueue)
510  return AVERROR(EAGAIN);
511 
512  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
513  if (!ref) {
514  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
515  svt_av1_enc_release_out_buffer(&headerPtr);
516  return AVERROR(ENOMEM);
517  }
518  pkt->buf = ref;
519  pkt->data = ref->data;
520 
521  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
522  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
523 
524  pkt->size = headerPtr->n_filled_len;
525  pkt->pts = headerPtr->pts;
526  pkt->dts = headerPtr->dts;
527 
528  switch (headerPtr->pic_type) {
529  case EB_AV1_KEY_PICTURE:
531  // fall-through
532  case EB_AV1_INTRA_ONLY_PICTURE:
533  pict_type = AV_PICTURE_TYPE_I;
534  break;
535  case EB_AV1_INVALID_PICTURE:
536  pict_type = AV_PICTURE_TYPE_NONE;
537  break;
538  default:
539  pict_type = AV_PICTURE_TYPE_P;
540  break;
541  }
542 
543  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
545 
546  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
547  svt_enc->eos_flag = EOS_RECEIVED;
548 
549  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
550 
551  svt_av1_enc_release_out_buffer(&headerPtr);
552 
553  return 0;
554 }
555 
557 {
558  SvtContext *svt_enc = avctx->priv_data;
559 
560  if (svt_enc->svt_handle) {
561  svt_av1_enc_deinit(svt_enc->svt_handle);
562  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
563  }
564  if (svt_enc->in_buf) {
565  av_free(svt_enc->in_buf->p_buffer);
566  av_freep(&svt_enc->in_buf);
567  }
568 
569  av_buffer_pool_uninit(&svt_enc->pool);
570  av_frame_free(&svt_enc->frame);
571 
572  return 0;
573 }
574 
575 #define OFFSET(x) offsetof(SvtContext, x)
576 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
577 static const AVOption options[] = {
578 #if FF_API_SVTAV1_OPTS
579  { "hielevel", "Hierarchical prediction levels setting (Deprecated, use svtav1-params)", OFFSET(hierarchical_level),
580  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 4, VE | AV_OPT_FLAG_DEPRECATED , "hielevel"},
581  { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "hielevel" },
582  { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 }, INT_MIN, INT_MAX, VE, "hielevel" },
583 
584  { "la_depth", "Look ahead distance [0, 120] (Deprecated, use svtav1-params)", OFFSET(la_depth),
585  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE | AV_OPT_FLAG_DEPRECATED },
586 
587  { "tier", "Set operating point tier (Deprecated, use svtav1-params)", OFFSET(tier),
588  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE | AV_OPT_FLAG_DEPRECATED, "tier" },
589  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
590  { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
591 #endif
592  { "preset", "Encoding preset",
593  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_ENC_PRESET, VE },
594 
596 
597 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
598  { .i64 = value }, 0, 0, VE, "avctx.level"
599  { LEVEL("2.0", 20) },
600  { LEVEL("2.1", 21) },
601  { LEVEL("2.2", 22) },
602  { LEVEL("2.3", 23) },
603  { LEVEL("3.0", 30) },
604  { LEVEL("3.1", 31) },
605  { LEVEL("3.2", 32) },
606  { LEVEL("3.3", 33) },
607  { LEVEL("4.0", 40) },
608  { LEVEL("4.1", 41) },
609  { LEVEL("4.2", 42) },
610  { LEVEL("4.3", 43) },
611  { LEVEL("5.0", 50) },
612  { LEVEL("5.1", 51) },
613  { LEVEL("5.2", 52) },
614  { LEVEL("5.3", 53) },
615  { LEVEL("6.0", 60) },
616  { LEVEL("6.1", 61) },
617  { LEVEL("6.2", 62) },
618  { LEVEL("6.3", 63) },
619  { LEVEL("7.0", 70) },
620  { LEVEL("7.1", 71) },
621  { LEVEL("7.2", 72) },
622  { LEVEL("7.3", 73) },
623 #undef LEVEL
624 
625  { "crf", "Constant Rate Factor value", OFFSET(crf),
626  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
627  { "qp", "Initial Quantizer level value", OFFSET(qp),
628  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 63, VE },
629 #if FF_API_SVTAV1_OPTS
630  { "sc_detection", "Scene change detection (Deprecated, use svtav1-params)", OFFSET(scd),
631  AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VE | AV_OPT_FLAG_DEPRECATED },
632 
633  { "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 },
634  { "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 },
635 #endif
636 
637  { "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 },
638 
639  {NULL},
640 };
641 
642 static const AVClass class = {
643  .class_name = "libsvtav1",
644  .item_name = av_default_item_name,
645  .option = options,
647 };
648 
649 static const FFCodecDefault eb_enc_defaults[] = {
650  { "b", "0" },
651  { "flags", "+cgop" },
652  { "g", "-1" },
653  { "qmin", "1" },
654  { "qmax", "63" },
655  { NULL },
656 };
657 
659  .p.name = "libsvtav1",
660  CODEC_LONG_NAME("SVT-AV1(Scalable Video Technology for AV1) encoder"),
661  .priv_data_size = sizeof(SvtContext),
662  .p.type = AVMEDIA_TYPE_VIDEO,
663  .p.id = AV_CODEC_ID_AV1,
664  .init = eb_enc_init,
666  .close = eb_enc_close,
668  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
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 };
svt_errors
static const struct @99 svt_errors[]
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:649
get_output_ref
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:461
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:2858
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:661
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:459
eb_receive_packet
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:485
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:119
eb_enc_init
static av_cold int eb_enc_init(AVCodecContext *avctx)
Definition: libsvtav1.c:357
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:588
FF_LEVEL_UNKNOWN
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1677
AVDictionary
Definition: dict.c:32
eb_enc_close
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:556
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:3255
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:417
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:60
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
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
AVDictionaryEntry::key
char * key
Definition: dict.h:90
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:682
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:684
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:658
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:627
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: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:681
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:577
VE
#define VE
Definition: libsvtav1.c:576
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:575
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:89
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: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:320
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