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  int enc_mode;
66  int crf;
67  int qp;
68 } SvtContext;
69 
70 static const struct {
71  EbErrorType eb_err;
72  int av_err;
73  const char *desc;
74 } svt_errors[] = {
75  { EB_ErrorNone, 0, "success" },
76  { EB_ErrorInsufficientResources, AVERROR(ENOMEM), "insufficient resources" },
77  { EB_ErrorUndefined, AVERROR(EINVAL), "undefined error" },
78  { EB_ErrorInvalidComponent, AVERROR(EINVAL), "invalid component" },
79  { EB_ErrorBadParameter, AVERROR(EINVAL), "bad parameter" },
80  { EB_ErrorDestroyThreadFailed, AVERROR_EXTERNAL, "failed to destroy thread" },
81  { EB_ErrorSemaphoreUnresponsive, AVERROR_EXTERNAL, "semaphore unresponsive" },
82  { EB_ErrorDestroySemaphoreFailed, AVERROR_EXTERNAL, "failed to destroy semaphore"},
83  { EB_ErrorCreateMutexFailed, AVERROR_EXTERNAL, "failed to create mutex" },
84  { EB_ErrorMutexUnresponsive, AVERROR_EXTERNAL, "mutex unresponsive" },
85  { EB_ErrorDestroyMutexFailed, AVERROR_EXTERNAL, "failed to destroy mutex" },
86  { EB_NoErrorEmptyQueue, AVERROR(EAGAIN), "empty queue" },
87 };
88 
89 static int svt_map_error(EbErrorType eb_err, const char **desc)
90 {
91  int i;
92 
94  for (i = 0; i < FF_ARRAY_ELEMS(svt_errors); i++) {
95  if (svt_errors[i].eb_err == eb_err) {
96  *desc = svt_errors[i].desc;
97  return svt_errors[i].av_err;
98  }
99  }
100  *desc = "unknown error";
101  return AVERROR_UNKNOWN;
102 }
103 
104 static int svt_print_error(void *log_ctx, EbErrorType err,
105  const char *error_string)
106 {
107  const char *desc;
108  int ret = svt_map_error(err, &desc);
109 
110  av_log(log_ctx, AV_LOG_ERROR, "%s: %s (0x%x)\n", error_string, desc, err);
111 
112  return ret;
113 }
114 
115 static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
116 {
117  const size_t luma_size = config->source_width * config->source_height *
118  (config->encoder_bit_depth > 8 ? 2 : 1);
119 
120  EbSvtIOFormat *in_data;
121 
122  svt_enc->raw_size = luma_size * 3 / 2;
123 
124  // allocate buffer for in and out
125  svt_enc->in_buf = av_mallocz(sizeof(*svt_enc->in_buf));
126  if (!svt_enc->in_buf)
127  return AVERROR(ENOMEM);
128 
129  svt_enc->in_buf->p_buffer = av_mallocz(sizeof(*in_data));
130  if (!svt_enc->in_buf->p_buffer)
131  return AVERROR(ENOMEM);
132 
133  svt_enc->in_buf->size = sizeof(*svt_enc->in_buf);
134 
135  return 0;
136 
137 }
138 
139 static int config_enc_params(EbSvtAv1EncConfiguration *param,
140  AVCodecContext *avctx)
141 {
142  SvtContext *svt_enc = avctx->priv_data;
143  const AVPixFmtDescriptor *desc;
144  AVDictionaryEntry *en = NULL;
145 
146  // Update param from options
147  if (svt_enc->enc_mode >= -1)
148  param->enc_mode = svt_enc->enc_mode;
149 
150  if (avctx->bit_rate) {
151  param->target_bit_rate = avctx->bit_rate;
152  if (avctx->rc_max_rate != avctx->bit_rate)
153  param->rate_control_mode = 1;
154  else
155  param->rate_control_mode = 2;
156 
157  param->max_qp_allowed = avctx->qmax;
158  param->min_qp_allowed = avctx->qmin;
159  }
160  param->max_bit_rate = avctx->rc_max_rate;
161  if ((avctx->bit_rate > 0 || avctx->rc_max_rate > 0) && avctx->rc_buffer_size)
162  param->maximum_buffer_size_ms =
163  avctx->rc_buffer_size * 1000LL /
164  FFMAX(avctx->bit_rate, avctx->rc_max_rate);
165 
166  if (svt_enc->crf > 0) {
167  param->qp = svt_enc->crf;
168  param->rate_control_mode = 0;
169  } else if (svt_enc->qp > 0) {
170  param->qp = svt_enc->qp;
171  param->rate_control_mode = 0;
172  param->enable_adaptive_quantization = 0;
173  }
174 
175  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
176  param->color_primaries = avctx->color_primaries;
177  param->matrix_coefficients = (desc->flags & AV_PIX_FMT_FLAG_RGB) ?
178  AVCOL_SPC_RGB : avctx->colorspace;
179  param->transfer_characteristics = avctx->color_trc;
180 
182  param->color_range = avctx->color_range == AVCOL_RANGE_JPEG;
183  else
184  param->color_range = !!(desc->flags & AV_PIX_FMT_FLAG_RGB);
185 
186 #if SVT_AV1_CHECK_VERSION(1, 0, 0)
188  const char *name =
190 
191  switch (avctx->chroma_sample_location) {
192  case AVCHROMA_LOC_LEFT:
193  param->chroma_sample_position = EB_CSP_VERTICAL;
194  break;
196  param->chroma_sample_position = EB_CSP_COLOCATED;
197  break;
198  default:
199  if (!name)
200  break;
201 
202  av_log(avctx, AV_LOG_WARNING,
203  "Specified chroma sample location %s is unsupported "
204  "on the AV1 bit stream level. Usage of a container that "
205  "allows passing this information - such as Matroska - "
206  "is recommended.\n",
207  name);
208  break;
209  }
210  }
211 #endif
212 
213  if (avctx->profile != AV_PROFILE_UNKNOWN)
214  param->profile = avctx->profile;
215 
216  if (avctx->level != AV_LEVEL_UNKNOWN)
217  param->level = avctx->level;
218 
219  // gop_size == 1 case is handled when encoding each frame by setting
220  // pic_type to EB_AV1_KEY_PICTURE. For gop_size > 1, set the
221  // intra_period_length. Even though setting intra_period_length to 0 should
222  // work in this case, it does not.
223  // See: https://gitlab.com/AOMediaCodec/SVT-AV1/-/issues/2076
224  if (avctx->gop_size > 1)
225  param->intra_period_length = avctx->gop_size - 1;
226 
227 #if SVT_AV1_CHECK_VERSION(1, 1, 0)
228  // In order for SVT-AV1 to force keyframes by setting pic_type to
229  // EB_AV1_KEY_PICTURE on any frame, force_key_frames has to be set. Note
230  // that this does not force all frames to be keyframes (it only forces a
231  // keyframe with pic_type is set to EB_AV1_KEY_PICTURE). As of now, SVT-AV1
232  // does not support arbitrary keyframe requests by setting pic_type to
233  // EB_AV1_KEY_PICTURE, so it is done only when gop_size == 1.
234  // FIXME: When SVT-AV1 supports arbitrary keyframe requests, this code needs
235  // to be updated to set force_key_frames accordingly.
236  if (avctx->gop_size == 1)
237  param->force_key_frames = 1;
238 #endif
239 
240  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
241  param->frame_rate_numerator = avctx->framerate.num;
242  param->frame_rate_denominator = avctx->framerate.den;
243  } else {
244  param->frame_rate_numerator = avctx->time_base.den;
246  param->frame_rate_denominator = avctx->time_base.num
247 #if FF_API_TICKS_PER_FRAME
248  * avctx->ticks_per_frame
249 #endif
250  ;
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 != AV_PROFILE_AV1_PROFESSIONAL ) {
295  av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
296  param->profile = AV_PROFILE_AV1_PROFESSIONAL;
297  } else if (param->encoder_color_format == EB_YUV444 && param->profile != AV_PROFILE_AV1_HIGH) {
298  av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
299  param->profile = AV_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 *
306  FFMAX(avctx->bit_rate, avctx->rc_max_rate) / 1000LL;
307 
308  if (avctx->bit_rate || avctx->rc_max_rate || avctx->rc_buffer_size) {
309  AVCPBProperties *cpb_props = ff_encode_add_cpb_side_data(avctx);
310  if (!cpb_props)
311  return AVERROR(ENOMEM);
312 
313  cpb_props->buffer_size = avctx->rc_buffer_size;
314  cpb_props->max_bitrate = avctx->rc_max_rate;
315  cpb_props->avg_bitrate = avctx->bit_rate;
316  }
317 
318  return 0;
319 }
320 
321 static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame,
322  EbBufferHeaderType *header_ptr)
323 {
324  EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
325  ptrdiff_t linesizes[4];
326  size_t sizes[4];
327  int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
328  int ret, frame_size;
329 
330  for (int i = 0; i < 4; i++)
331  linesizes[i] = frame->linesize[i];
332 
334  linesizes);
335  if (ret < 0)
336  return ret;
337 
338  frame_size = 0;
339  for (int i = 0; i < 4; i++) {
340  if (sizes[i] > INT_MAX - frame_size)
341  return AVERROR(EINVAL);
342  frame_size += sizes[i];
343  }
344 
345  in_data->luma = frame->data[0];
346  in_data->cb = frame->data[1];
347  in_data->cr = frame->data[2];
348 
349  in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
350  in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
351  in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
352 
353  header_ptr->n_filled_len = frame_size;
354 
355  return 0;
356 }
357 
359 {
360  SvtContext *svt_enc = avctx->priv_data;
361  EbErrorType svt_ret;
362  int ret;
363 
364  svt_enc->eos_flag = EOS_NOT_REACHED;
365 
366  svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
367  if (svt_ret != EB_ErrorNone) {
368  return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");
369  }
370 
371  ret = config_enc_params(&svt_enc->enc_params, avctx);
372  if (ret < 0) {
373  av_log(avctx, AV_LOG_ERROR, "Error configuring encoder parameters\n");
374  return ret;
375  }
376 
377  svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
378  if (svt_ret != EB_ErrorNone) {
379  return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
380  }
381 
382  svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
383  if (svt_ret != EB_ErrorNone) {
384  return svt_print_error(avctx, svt_ret, "Error initializing encoder");
385  }
386 
387  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
388  EbBufferHeaderType *headerPtr = NULL;
389 
390  svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
391  if (svt_ret != EB_ErrorNone) {
392  return svt_print_error(avctx, svt_ret, "Error building stream header");
393  }
394 
395  avctx->extradata_size = headerPtr->n_filled_len;
397  if (!avctx->extradata) {
398  av_log(avctx, AV_LOG_ERROR,
399  "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
400  return AVERROR(ENOMEM);
401  }
402 
403  memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
404 
405  svt_ret = svt_av1_enc_stream_header_release(headerPtr);
406  if (svt_ret != EB_ErrorNone) {
407  return svt_print_error(avctx, svt_ret, "Error freeing stream header");
408  }
409  }
410 
411  svt_enc->frame = av_frame_alloc();
412  if (!svt_enc->frame)
413  return AVERROR(ENOMEM);
414 
415  return alloc_buffer(&svt_enc->enc_params, svt_enc);
416 }
417 
418 static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
419 {
420  SvtContext *svt_enc = avctx->priv_data;
421  EbBufferHeaderType *headerPtr = svt_enc->in_buf;
422  int ret;
423 
424  if (!frame) {
425  EbBufferHeaderType headerPtrLast;
426 
427  if (svt_enc->eos_flag == EOS_SENT)
428  return 0;
429 
430  memset(&headerPtrLast, 0, sizeof(headerPtrLast));
431  headerPtrLast.pic_type = EB_AV1_INVALID_PICTURE;
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  if (avctx->gop_size == 1)
458  headerPtr->pic_type = EB_AV1_KEY_PICTURE;
459 
460  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
461 
462  return 0;
463 }
464 
465 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
466 {
467  if (filled_len > svt_enc->max_tu_size) {
468  const int max_frames = 8;
469  int max_tu_size;
470 
471  if (filled_len > svt_enc->raw_size * max_frames) {
472  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
473  return NULL;
474  }
475 
476  max_tu_size = 1 << av_ceil_log2(filled_len);
477  av_buffer_pool_uninit(&svt_enc->pool);
478  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
479  if (!svt_enc->pool)
480  return NULL;
481 
482  svt_enc->max_tu_size = max_tu_size;
483  }
484  av_assert0(svt_enc->pool);
485 
486  return av_buffer_pool_get(svt_enc->pool);
487 }
488 
490 {
491  SvtContext *svt_enc = avctx->priv_data;
492  EbBufferHeaderType *headerPtr;
493  AVFrame *frame = svt_enc->frame;
494  EbErrorType svt_ret;
495  AVBufferRef *ref;
496  int ret = 0, pict_type;
497 
498  if (svt_enc->eos_flag == EOS_RECEIVED)
499  return AVERROR_EOF;
500 
501  ret = ff_encode_get_frame(avctx, frame);
502  if (ret < 0 && ret != AVERROR_EOF)
503  return ret;
504  if (ret == AVERROR_EOF)
505  frame = NULL;
506 
507  ret = eb_send_frame(avctx, frame);
508  if (ret < 0)
509  return ret;
510  av_frame_unref(svt_enc->frame);
511 
512  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
513  if (svt_ret == EB_NoErrorEmptyQueue)
514  return AVERROR(EAGAIN);
515 
516 #if SVT_AV1_CHECK_VERSION(2, 0, 0)
517  if (headerPtr->flags & EB_BUFFERFLAG_EOS) {
518  svt_enc->eos_flag = EOS_RECEIVED;
519  svt_av1_enc_release_out_buffer(&headerPtr);
520  return AVERROR_EOF;
521  }
522 #endif
523 
524  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
525  if (!ref) {
526  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
527  svt_av1_enc_release_out_buffer(&headerPtr);
528  return AVERROR(ENOMEM);
529  }
530  pkt->buf = ref;
531  pkt->data = ref->data;
532 
533  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
534  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
535 
536  pkt->size = headerPtr->n_filled_len;
537  pkt->pts = headerPtr->pts;
538  pkt->dts = headerPtr->dts;
539 
540  switch (headerPtr->pic_type) {
541  case EB_AV1_KEY_PICTURE:
543  // fall-through
544  case EB_AV1_INTRA_ONLY_PICTURE:
545  pict_type = AV_PICTURE_TYPE_I;
546  break;
547  case EB_AV1_INVALID_PICTURE:
548  pict_type = AV_PICTURE_TYPE_NONE;
549  break;
550  default:
551  pict_type = AV_PICTURE_TYPE_P;
552  break;
553  }
554 
555  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
557 
558 #if !(SVT_AV1_CHECK_VERSION(2, 0, 0))
559  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
560  svt_enc->eos_flag = EOS_RECEIVED;
561 #endif
562 
563  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
564 
565  svt_av1_enc_release_out_buffer(&headerPtr);
566 
567  return 0;
568 }
569 
571 {
572  SvtContext *svt_enc = avctx->priv_data;
573 
574  if (svt_enc->svt_handle) {
575  svt_av1_enc_deinit(svt_enc->svt_handle);
576  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
577  }
578  if (svt_enc->in_buf) {
579  av_free(svt_enc->in_buf->p_buffer);
580  av_freep(&svt_enc->in_buf);
581  }
582 
583  av_buffer_pool_uninit(&svt_enc->pool);
584  av_frame_free(&svt_enc->frame);
585 
586  return 0;
587 }
588 
589 #define OFFSET(x) offsetof(SvtContext, x)
590 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
591 static const AVOption options[] = {
592  { "preset", "Encoding preset",
593  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = -2 }, -2, MAX_ENC_PRESET, VE },
594 
596 
597 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
598  { .i64 = value }, 0, 0, VE, .unit = "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  { "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 },
630 
631  {NULL},
632 };
633 
634 static const AVClass class = {
635  .class_name = "libsvtav1",
636  .item_name = av_default_item_name,
637  .option = options,
639 };
640 
641 static const FFCodecDefault eb_enc_defaults[] = {
642  { "b", "0" },
643  { "flags", "+cgop" },
644  { "g", "-1" },
645  { "qmin", "1" },
646  { "qmax", "63" },
647  { NULL },
648 };
649 
651  .p.name = "libsvtav1",
652  CODEC_LONG_NAME("SVT-AV1(Scalable Video Technology for AV1) encoder"),
653  .priv_data_size = sizeof(SvtContext),
654  .p.type = AVMEDIA_TYPE_VIDEO,
655  .p.id = AV_CODEC_ID_AV1,
656  .init = eb_enc_init,
658  .close = eb_enc_close,
660  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
662  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
664  AV_PIX_FMT_NONE },
665  .p.priv_class = &class,
666  .defaults = eb_enc_defaults,
667  .p.wrapper_name = "libsvtav1",
668 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:280
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
level
uint8_t level
Definition: svq3.c:204
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
eb_enc_defaults
static const FFCodecDefault eb_enc_defaults[]
Definition: libsvtav1.c:641
get_output_ref
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:465
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:2962
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:607
SvtContext
Definition: libsvtav1.c:47
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
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:88
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:346
encode.h
SvtContext::frame
AVFrame * frame
Definition: libsvtav1.c:57
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
eb_receive_packet
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:489
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:127
eb_enc_init
static av_cold int eb_enc_init(AVCodecContext *avctx)
Definition: libsvtav1.c:358
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:610
AVDictionary
Definition: dict.c:34
eb_enc_close
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:570
AV_PKT_FLAG_DISPOSABLE
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
Definition: packet.h:596
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_PROFILE_AV1_PROFESSIONAL
#define AV_PROFILE_AV1_PROFESSIONAL
Definition: defs.h:169
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1263
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3359
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:338
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
FFCodecDefault
Definition: codec_internal.h:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
av_ceil_log2
#define av_ceil_log2
Definition: common.h:95
eb_err
EbErrorType eb_err
Definition: libsvtav1.c:71
eb_send_frame
static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Definition: libsvtav1.c:418
svt_errors
static const struct @110 svt_errors[]
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
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:76
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
EOS_RECEIVED
@ EOS_RECEIVED
Definition: libsvtav1.c:44
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVDictionaryEntry::key
char * key
Definition: dict.h:90
frame_size
int frame_size
Definition: mxfenc.c:2422
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:124
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
SvtContext::enc_mode
int enc_mode
Definition: libsvtav1.c:65
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1292
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1277
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:505
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:59
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:704
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:196
av_image_fill_plane_sizes
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:706
FF_CODEC_RECEIVE_PACKET_CB
#define FF_CODEC_RECEIVE_PACKET_CB(func)
Definition: codec_internal.h:302
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:242
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
profiles.h
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
SvtContext::pool
AVBufferPool * pool
Definition: libsvtav1.c:59
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1783
ff_libsvtav1_encoder
const FFCodec ff_libsvtav1_encoder
Definition: libsvtav1.c:650
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:649
LEVEL
#define LEVEL(name, value)
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:544
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
AVPacket::size
int size
Definition: packet.h:523
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
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:66
config_enc_params
static int config_enc_params(EbSvtAv1EncConfiguration *param, AVCodecContext *avctx)
Definition: libsvtav1.c:139
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:703
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
alloc_buffer
static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
Definition: libsvtav1.c:115
frame.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
options
static const AVOption options[]
Definition: libsvtav1.c:591
VE
#define VE
Definition: libsvtav1.c:590
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_PROFILE_AV1_HIGH
#define AV_PROFILE_AV1_HIGH
Definition: defs.h:168
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
svt_map_error
static int svt_map_error(EbErrorType eb_err, const char **desc)
Definition: libsvtav1.c:89
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:284
SvtContext::eos_flag
EOS_STATUS eos_flag
Definition: libsvtav1.c:61
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
eos_status
eos_status
Definition: libsvtav1.c:41
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
OFFSET
#define OFFSET(x)
Definition: libsvtav1.c:589
av_err
int av_err
Definition: libsvtav1.c:72
SvtContext::max_tu_size
int max_tu_size
Definition: libsvtav1.c:55
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:274
SvtContext::raw_size
int raw_size
Definition: libsvtav1.c:54
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:534
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
SvtContext::enc_params
EbSvtAv1EncConfiguration enc_params
Definition: libsvtav1.c:50
avcodec.h
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:352
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:290
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
svt_print_error
static int svt_print_error(void *log_ctx, EbErrorType err, const char *error_string)
Definition: libsvtav1.c:104
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:412
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1256
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
SvtContext::in_buf
EbBufferHeaderType * in_buf
Definition: libsvtav1.c:53
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
desc
const char * desc
Definition: libsvtav1.c:73
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_encode_get_frame
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition: encode.c:204
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
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
EOS_SENT
@ EOS_SENT
Definition: libsvtav1.c:43
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SvtContext::qp
int qp
Definition: libsvtav1.c:67
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:856
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:321