FFmpeg  4.4.5
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 "internal.h"
35 #include "encode.h"
36 #include "packet_internal.h"
37 #include "avcodec.h"
38 #include "profiles.h"
39 
40 typedef enum eos_status {
45 
46 typedef struct SvtContext {
47  const AVClass *class;
48 
49  EbSvtAv1EncConfiguration enc_params;
50  EbComponentType *svt_handle;
51 
52  EbBufferHeaderType *in_buf;
53  int raw_size;
55 
57 
59 
61 
62  // User options.
64  int la_depth;
65  int enc_mode;
66  int rc_mode;
67  int scd;
68  int qp;
69 
70  int tier;
71 
73  int tile_rows;
74 } SvtContext;
75 
76 static const struct {
77  EbErrorType eb_err;
78  int av_err;
79  const char *desc;
80 } svt_errors[] = {
81  { EB_ErrorNone, 0, "success" },
82  { EB_ErrorInsufficientResources, AVERROR(ENOMEM), "insufficient resources" },
83  { EB_ErrorUndefined, AVERROR(EINVAL), "undefined error" },
84  { EB_ErrorInvalidComponent, AVERROR(EINVAL), "invalid component" },
85  { EB_ErrorBadParameter, AVERROR(EINVAL), "bad parameter" },
86  { EB_ErrorDestroyThreadFailed, AVERROR_EXTERNAL, "failed to destroy thread" },
87  { EB_ErrorSemaphoreUnresponsive, AVERROR_EXTERNAL, "semaphore unresponsive" },
88  { EB_ErrorDestroySemaphoreFailed, AVERROR_EXTERNAL, "failed to destroy semaphore"},
89  { EB_ErrorCreateMutexFailed, AVERROR_EXTERNAL, "failed to create mutex" },
90  { EB_ErrorMutexUnresponsive, AVERROR_EXTERNAL, "mutex unresponsive" },
91  { EB_ErrorDestroyMutexFailed, AVERROR_EXTERNAL, "failed to destroy mutex" },
92  { EB_NoErrorEmptyQueue, AVERROR(EAGAIN), "empty queue" },
93 };
94 
95 static int svt_map_error(EbErrorType eb_err, const char **desc)
96 {
97  int i;
98 
100  for (i = 0; i < FF_ARRAY_ELEMS(svt_errors); i++) {
101  if (svt_errors[i].eb_err == eb_err) {
102  *desc = svt_errors[i].desc;
103  return svt_errors[i].av_err;
104  }
105  }
106  *desc = "unknown error";
107  return AVERROR_UNKNOWN;
108 }
109 
110 static int svt_print_error(void *log_ctx, EbErrorType err,
111  const char *error_string)
112 {
113  const char *desc;
114  int ret = svt_map_error(err, &desc);
115 
116  av_log(log_ctx, AV_LOG_ERROR, "%s: %s (0x%x)\n", error_string, desc, err);
117 
118  return ret;
119 }
120 
121 static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
122 {
123  const size_t luma_size = config->source_width * config->source_height *
124  (config->encoder_bit_depth > 8 ? 2 : 1);
125 
126  EbSvtIOFormat *in_data;
127 
128  svt_enc->raw_size = luma_size * 3 / 2;
129 
130  // allocate buffer for in and out
131  svt_enc->in_buf = av_mallocz(sizeof(*svt_enc->in_buf));
132  if (!svt_enc->in_buf)
133  return AVERROR(ENOMEM);
134 
135  svt_enc->in_buf->p_buffer = av_mallocz(sizeof(*in_data));
136  if (!svt_enc->in_buf->p_buffer)
137  return AVERROR(ENOMEM);
138 
139  svt_enc->in_buf->size = sizeof(*svt_enc->in_buf);
140 
141  return 0;
142 
143 }
144 
145 static int config_enc_params(EbSvtAv1EncConfiguration *param,
146  AVCodecContext *avctx)
147 {
148  SvtContext *svt_enc = avctx->priv_data;
149  const AVPixFmtDescriptor *desc;
150 
151  param->source_width = avctx->width;
152  param->source_height = avctx->height;
153 
154  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
155  param->encoder_bit_depth = desc->comp[0].depth;
156 
157  if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1)
158  param->encoder_color_format = EB_YUV420;
159  else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0)
160  param->encoder_color_format = EB_YUV422;
161  else if (!desc->log2_chroma_w && !desc->log2_chroma_h)
162  param->encoder_color_format = EB_YUV444;
163  else {
164  av_log(avctx, AV_LOG_ERROR , "Unsupported pixel format\n");
165  return AVERROR(EINVAL);
166  }
167 
168  if (avctx->profile != FF_PROFILE_UNKNOWN)
169  param->profile = avctx->profile;
170 
171  if (avctx->level != FF_LEVEL_UNKNOWN)
172  param->level = avctx->level;
173 
174  if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
175  && param->profile != FF_PROFILE_AV1_PROFESSIONAL ) {
176  av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
177  param->profile = FF_PROFILE_AV1_PROFESSIONAL;
178  } else if (param->encoder_color_format == EB_YUV444 && param->profile != FF_PROFILE_AV1_HIGH) {
179  av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
180  param->profile = FF_PROFILE_AV1_HIGH;
181  }
182 
183  // Update param from options
184  param->hierarchical_levels = svt_enc->hierarchical_level;
185  param->enc_mode = svt_enc->enc_mode;
186  param->tier = svt_enc->tier;
187  param->rate_control_mode = svt_enc->rc_mode;
188  param->scene_change_detection = svt_enc->scd;
189  param->qp = svt_enc->qp;
190 
191  param->target_bit_rate = avctx->bit_rate;
192 
193  if (avctx->gop_size > 0)
194  param->intra_period_length = avctx->gop_size - 1;
195 
196  if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
197  param->frame_rate_numerator = avctx->framerate.num;
198  param->frame_rate_denominator = avctx->framerate.den;
199  } else {
200  param->frame_rate_numerator = avctx->time_base.den;
201  param->frame_rate_denominator = avctx->time_base.num * avctx->ticks_per_frame;
202  }
203 
204  if (param->rate_control_mode) {
205  param->max_qp_allowed = avctx->qmax;
206  param->min_qp_allowed = avctx->qmin;
207  }
208 
209  param->intra_refresh_type = 2; /* Real keyframes only */
210 
211  if (svt_enc->la_depth >= 0)
212  param->look_ahead_distance = svt_enc->la_depth;
213 
214  param->tile_columns = svt_enc->tile_columns;
215  param->tile_rows = svt_enc->tile_rows;
216 
217  return 0;
218 }
219 
220 static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame,
221  EbBufferHeaderType *header_ptr)
222 {
223  EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
224  ptrdiff_t linesizes[4];
225  size_t sizes[4];
226  int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
227  int ret, frame_size;
228 
229  for (int i = 0; i < 4; i++)
230  linesizes[i] = frame->linesize[i];
231 
233  linesizes);
234  if (ret < 0)
235  return ret;
236 
237  frame_size = 0;
238  for (int i = 0; i < 4; i++) {
239  if (sizes[i] > INT_MAX - frame_size)
240  return AVERROR(EINVAL);
241  frame_size += sizes[i];
242  }
243 
244  in_data->luma = frame->data[0];
245  in_data->cb = frame->data[1];
246  in_data->cr = frame->data[2];
247 
248  in_data->y_stride = AV_CEIL_RSHIFT(frame->linesize[0], bytes_shift);
249  in_data->cb_stride = AV_CEIL_RSHIFT(frame->linesize[1], bytes_shift);
250  in_data->cr_stride = AV_CEIL_RSHIFT(frame->linesize[2], bytes_shift);
251 
252  header_ptr->n_filled_len = frame_size;
253 
254  return 0;
255 }
256 
258 {
259  SvtContext *svt_enc = avctx->priv_data;
260  EbErrorType svt_ret;
261  int ret;
262 
263  svt_enc->eos_flag = EOS_NOT_REACHED;
264 
265  svt_ret = svt_av1_enc_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
266  if (svt_ret != EB_ErrorNone) {
267  return svt_print_error(avctx, svt_ret, "Error initializing encoder handle");
268  }
269 
270  ret = config_enc_params(&svt_enc->enc_params, avctx);
271  if (ret < 0) {
272  av_log(avctx, AV_LOG_ERROR, "Error configuring encoder parameters\n");
273  return ret;
274  }
275 
276  svt_ret = svt_av1_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
277  if (svt_ret != EB_ErrorNone) {
278  return svt_print_error(avctx, svt_ret, "Error setting encoder parameters");
279  }
280 
281  svt_ret = svt_av1_enc_init(svt_enc->svt_handle);
282  if (svt_ret != EB_ErrorNone) {
283  return svt_print_error(avctx, svt_ret, "Error initializing encoder");
284  }
285 
286  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
287  EbBufferHeaderType *headerPtr = NULL;
288 
289  svt_ret = svt_av1_enc_stream_header(svt_enc->svt_handle, &headerPtr);
290  if (svt_ret != EB_ErrorNone) {
291  return svt_print_error(avctx, svt_ret, "Error building stream header");
292  }
293 
294  avctx->extradata_size = headerPtr->n_filled_len;
296  if (!avctx->extradata) {
297  av_log(avctx, AV_LOG_ERROR,
298  "Cannot allocate AV1 header of size %d.\n", avctx->extradata_size);
299  return AVERROR(ENOMEM);
300  }
301 
302  memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
303 
304  svt_ret = svt_av1_enc_stream_header_release(headerPtr);
305  if (svt_ret != EB_ErrorNone) {
306  return svt_print_error(avctx, svt_ret, "Error freeing stream header");
307  }
308  }
309 
310  svt_enc->frame = av_frame_alloc();
311  if (!svt_enc->frame)
312  return AVERROR(ENOMEM);
313 
314  return alloc_buffer(&svt_enc->enc_params, svt_enc);
315 }
316 
317 static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
318 {
319  SvtContext *svt_enc = avctx->priv_data;
320  EbBufferHeaderType *headerPtr = svt_enc->in_buf;
321  int ret;
322 
323  if (!frame) {
324  EbBufferHeaderType headerPtrLast;
325 
326  if (svt_enc->eos_flag == EOS_SENT)
327  return 0;
328 
329  headerPtrLast.n_alloc_len = 0;
330  headerPtrLast.n_filled_len = 0;
331  headerPtrLast.n_tick_count = 0;
332  headerPtrLast.p_app_private = NULL;
333  headerPtrLast.p_buffer = NULL;
334  headerPtrLast.flags = EB_BUFFERFLAG_EOS;
335 
336  svt_av1_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
337  svt_enc->eos_flag = EOS_SENT;
338  return 0;
339  }
340 
341  ret = read_in_data(&svt_enc->enc_params, frame, headerPtr);
342  if (ret < 0)
343  return ret;
344 
345  headerPtr->flags = 0;
346  headerPtr->p_app_private = NULL;
347  headerPtr->pts = frame->pts;
348 
349  svt_av1_enc_send_picture(svt_enc->svt_handle, headerPtr);
350 
351  return 0;
352 }
353 
354 static AVBufferRef *get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
355 {
356  if (filled_len > svt_enc->max_tu_size) {
357  const int max_frames = 8;
358  int max_tu_size;
359 
360  if (filled_len > svt_enc->raw_size * max_frames) {
361  av_log(avctx, AV_LOG_ERROR, "TU size > %d raw frame size.\n", max_frames);
362  return NULL;
363  }
364 
365  max_tu_size = 1 << av_ceil_log2(filled_len);
366  av_buffer_pool_uninit(&svt_enc->pool);
367  svt_enc->pool = av_buffer_pool_init(max_tu_size + AV_INPUT_BUFFER_PADDING_SIZE, NULL);
368  if (!svt_enc->pool)
369  return NULL;
370 
371  svt_enc->max_tu_size = max_tu_size;
372  }
373  av_assert0(svt_enc->pool);
374 
375  return av_buffer_pool_get(svt_enc->pool);
376 }
377 
379 {
380  SvtContext *svt_enc = avctx->priv_data;
381  EbBufferHeaderType *headerPtr;
382  AVFrame *frame = svt_enc->frame;
383  EbErrorType svt_ret;
384  AVBufferRef *ref;
385  int ret = 0, pict_type;
386 
387  if (svt_enc->eos_flag == EOS_RECEIVED)
388  return AVERROR_EOF;
389 
390  ret = ff_encode_get_frame(avctx, frame);
391  if (ret < 0 && ret != AVERROR_EOF)
392  return ret;
393  if (ret == AVERROR_EOF)
394  frame = NULL;
395 
396  ret = eb_send_frame(avctx, frame);
397  if (ret < 0)
398  return ret;
399  av_frame_unref(svt_enc->frame);
400 
401  svt_ret = svt_av1_enc_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
402  if (svt_ret == EB_NoErrorEmptyQueue)
403  return AVERROR(EAGAIN);
404 
405  ref = get_output_ref(avctx, svt_enc, headerPtr->n_filled_len);
406  if (!ref) {
407  av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
408  svt_av1_enc_release_out_buffer(&headerPtr);
409  return AVERROR(ENOMEM);
410  }
411  pkt->buf = ref;
412  pkt->data = ref->data;
413 
414  memcpy(pkt->data, headerPtr->p_buffer, headerPtr->n_filled_len);
415  memset(pkt->data + headerPtr->n_filled_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
416 
417  pkt->size = headerPtr->n_filled_len;
418  pkt->pts = headerPtr->pts;
419  pkt->dts = headerPtr->dts;
420 
421  switch (headerPtr->pic_type) {
422  case EB_AV1_KEY_PICTURE:
424  // fall-through
425  case EB_AV1_INTRA_ONLY_PICTURE:
426  pict_type = AV_PICTURE_TYPE_I;
427  break;
428  case EB_AV1_INVALID_PICTURE:
429  pict_type = AV_PICTURE_TYPE_NONE;
430  break;
431  default:
432  pict_type = AV_PICTURE_TYPE_P;
433  break;
434  }
435 
436  if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
438 
439  if (headerPtr->flags & EB_BUFFERFLAG_EOS)
440  svt_enc->eos_flag = EOS_RECEIVED;
441 
442  ff_side_data_set_encoder_stats(pkt, headerPtr->qp * FF_QP2LAMBDA, NULL, 0, pict_type);
443 
444  svt_av1_enc_release_out_buffer(&headerPtr);
445 
446  return 0;
447 }
448 
450 {
451  SvtContext *svt_enc = avctx->priv_data;
452 
453  if (svt_enc->svt_handle) {
454  svt_av1_enc_deinit(svt_enc->svt_handle);
455  svt_av1_enc_deinit_handle(svt_enc->svt_handle);
456  }
457  if (svt_enc->in_buf) {
458  av_free(svt_enc->in_buf->p_buffer);
459  av_freep(&svt_enc->in_buf);
460  }
461 
462  av_buffer_pool_uninit(&svt_enc->pool);
463  av_frame_free(&svt_enc->frame);
464 
465  return 0;
466 }
467 
468 #define OFFSET(x) offsetof(SvtContext, x)
469 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
470 static const AVOption options[] = {
471  { "hielevel", "Hierarchical prediction levels setting", OFFSET(hierarchical_level),
472  AV_OPT_TYPE_INT, { .i64 = 4 }, 3, 4, VE , "hielevel"},
473  { "3level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "hielevel" },
474  { "4level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 4 }, INT_MIN, INT_MAX, VE, "hielevel" },
475 
476  { "la_depth", "Look ahead distance [0, 120]", OFFSET(la_depth),
477  AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 120, VE },
478 
479  { "preset", "Encoding preset [0, 8]",
480  OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = MAX_ENC_PRESET }, 0, MAX_ENC_PRESET, VE },
481 
482  { "tier", "Set operating point tier", OFFSET(tier),
483  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "tier" },
484  { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
485  { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
486 
488 
489 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
490  { .i64 = value }, 0, 0, VE, "avctx.level"
491  { LEVEL("2.0", 20) },
492  { LEVEL("2.1", 21) },
493  { LEVEL("2.2", 22) },
494  { LEVEL("2.3", 23) },
495  { LEVEL("3.0", 30) },
496  { LEVEL("3.1", 31) },
497  { LEVEL("3.2", 32) },
498  { LEVEL("3.3", 33) },
499  { LEVEL("4.0", 40) },
500  { LEVEL("4.1", 41) },
501  { LEVEL("4.2", 42) },
502  { LEVEL("4.3", 43) },
503  { LEVEL("5.0", 50) },
504  { LEVEL("5.1", 51) },
505  { LEVEL("5.2", 52) },
506  { LEVEL("5.3", 53) },
507  { LEVEL("6.0", 60) },
508  { LEVEL("6.1", 61) },
509  { LEVEL("6.2", 62) },
510  { LEVEL("6.3", 63) },
511  { LEVEL("7.0", 70) },
512  { LEVEL("7.1", 71) },
513  { LEVEL("7.2", 72) },
514  { LEVEL("7.3", 73) },
515 #undef LEVEL
516 
517  { "rc", "Bit rate control mode", OFFSET(rc_mode),
518  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VE , "rc"},
519  { "cqp", "Constant quantizer", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "rc" },
520  { "vbr", "Variable Bit Rate, use a target bitrate for the entire stream", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "rc" },
521  { "cvbr", "Constrained Variable Bit Rate, use a target bitrate for each GOP", 0, AV_OPT_TYPE_CONST,{ .i64 = 2 }, INT_MIN, INT_MAX, VE, "rc" },
522 
523  { "qp", "Quantizer to use with cqp rate control mode", OFFSET(qp),
524  AV_OPT_TYPE_INT, { .i64 = 50 }, 0, 63, VE },
525 
526  { "sc_detection", "Scene change detection", OFFSET(scd),
527  AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
528 
529  { "tile_columns", "Log2 of number of tile columns to use", OFFSET(tile_columns), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, VE},
530  { "tile_rows", "Log2 of number of tile rows to use", OFFSET(tile_rows), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 6, VE},
531 
532  {NULL},
533 };
534 
535 static const AVClass class = {
536  .class_name = "libsvtav1",
537  .item_name = av_default_item_name,
538  .option = options,
540 };
541 
542 static const AVCodecDefault eb_enc_defaults[] = {
543  { "b", "7M" },
544  { "g", "-1" },
545  { "qmin", "0" },
546  { "qmax", "63" },
547  { NULL },
548 };
549 
551  .name = "libsvtav1",
552  .long_name = NULL_IF_CONFIG_SMALL("SVT-AV1(Scalable Video Technology for AV1) encoder"),
553  .priv_data_size = sizeof(SvtContext),
555  .id = AV_CODEC_ID_AV1,
556  .init = eb_enc_init,
557  .receive_packet = eb_receive_packet,
558  .close = eb_enc_close,
560  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
561  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
563  AV_PIX_FMT_NONE },
564  .priv_class = &class,
565  .defaults = eb_enc_defaults,
566  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
567  .wrapper_name = "libsvtav1",
568 };
#define av_cold
Definition: attributes.h:88
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1985
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1955
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1956
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:820
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
common internal and external API header
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define av_ceil_log2
Definition: common.h:119
#define NULL
Definition: coverity.c:32
static AVFrame * frame
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition: encode.c:160
reference-counted frame API
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:122
#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:77
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition: avcodec.h:215
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
Definition: packet.h:429
AVBufferPool * av_buffer_pool_init(buffer_size_t size, AVBufferRef *(*alloc)(buffer_size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:269
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:379
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:314
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:273
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
for(j=16;j >0;--j)
int tile_rows
Definition: h265_levels.c:217
cl_device_type type
static const int sizes[][2]
Definition: img2dec.c:54
misc image utilities
int i
Definition: input.c:407
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
static int config_enc_params(EbSvtAv1EncConfiguration *param, AVCodecContext *avctx)
Definition: libsvtav1.c:145
static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Definition: libsvtav1.c:317
EOS_STATUS
Definition: libsvtav1.c:40
@ EOS_SENT
Definition: libsvtav1.c:42
@ EOS_NOT_REACHED
Definition: libsvtav1.c:41
@ EOS_RECEIVED
Definition: libsvtav1.c:43
EbErrorType eb_err
Definition: libsvtav1.c:77
static int svt_print_error(void *log_ctx, EbErrorType err, const char *error_string)
Definition: libsvtav1.c:110
static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
Definition: libsvtav1.c:121
static const AVCodecDefault eb_enc_defaults[]
Definition: libsvtav1.c:542
static const AVOption options[]
Definition: libsvtav1.c:470
#define VE
Definition: libsvtav1.c:469
static int svt_map_error(EbErrorType eb_err, const char **desc)
Definition: libsvtav1.c:95
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
Definition: libsvtav1.c:378
static av_cold int eb_enc_init(AVCodecContext *avctx)
Definition: libsvtav1.c:257
static const struct @85 svt_errors[]
const char * desc
Definition: libsvtav1.c:79
#define LEVEL(name, value)
int av_err
Definition: libsvtav1.c:78
static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame, EbBufferHeaderType *header_ptr)
Definition: libsvtav1.c:220
#define OFFSET(x)
Definition: libsvtav1.c:468
static av_cold int eb_enc_close(AVCodecContext *avctx)
Definition: libsvtav1.c:449
AVCodec ff_libsvtav1_encoder
Definition: libsvtav1.c:550
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
Definition: libsvtav1.c:354
int frame_size
Definition: mxfenc.c:2206
AVOptions.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_AV1_PROFILE_OPTS
Definition: profiles.h:54
mfxU16 rc_mode
Definition: qsvenc.c:84
#define FF_ARRAY_ELEMS(a)
The buffer pool.
A reference to a data buffer.
Definition: buffer.h:84
Describe the class of an AVClass context structure.
Definition: log.h:67
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:72
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int qmin
minimum quantizer
Definition: avcodec.h:1380
AVRational framerate
Definition: avcodec.h:2071
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:668
int level
level
Definition: avcodec.h:1984
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
int profile
profile
Definition: avcodec.h:1858
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:731
int qmax
maximum quantizer
Definition: avcodec.h:1387
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
int extradata_size
Definition: avcodec.h:638
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int height
Definition: frame.h:376
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:352
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
uint8_t * data
Definition: packet.h:369
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
AVBufferPool * pool
Definition: libsvtav1.c:58
EbComponentType * svt_handle
Definition: libsvtav1.c:50
EbBufferHeaderType * in_buf
Definition: libsvtav1.c:52
AVFrame * frame
Definition: libsvtav1.c:56
int tile_columns
Definition: libsvtav1.c:72
int la_depth
Definition: libsvtav1.c:64
int raw_size
Definition: libsvtav1.c:53
EOS_STATUS eos_flag
Definition: libsvtav1.c:60
int hierarchical_level
Definition: libsvtav1.c:63
EbSvtAv1EncConfiguration enc_params
Definition: libsvtav1.c:49
int tile_rows
Definition: libsvtav1.c:73
int enc_mode
Definition: libsvtav1.c:65
int tier
Definition: libsvtav1.c:70
int rc_mode
Definition: libsvtav1.c:66
int max_tu_size
Definition: libsvtav1.c:54
#define av_free(p)
#define av_freep(p)
#define av_log(a,...)
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVPacket * pkt
Definition: movenc.c:59