FFmpeg
libaomenc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010, Google, Inc.
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * AV1 encoder support via libaom
24  */
25 
26 #define AOM_DISABLE_CTRL_TYPECHECKS 1
27 #include <aom/aom_encoder.h>
28 #include <aom/aomcx.h>
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/base64.h"
32 #include "libavutil/common.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 
37 #include "av1.h"
38 #include "avcodec.h"
39 #include "internal.h"
40 #include "profiles.h"
41 
42 /*
43  * Portion of struct aom_codec_cx_pkt from aom_encoder.h.
44  * One encoded frame returned from the library.
45  */
46 struct FrameListData {
47  void *buf; /**< compressed data buffer */
48  size_t sz; /**< length of compressed data */
49  int64_t pts; /**< time stamp to show frame
50  (in timebase units) */
51  unsigned long duration; /**< duration to show frame
52  (in timebase units) */
53  uint32_t flags; /**< flags for this frame */
54  uint64_t sse[4];
55  int have_sse; /**< true if we have pending sse[] */
56  uint64_t frame_number;
58 };
59 
60 typedef struct AOMEncoderContext {
61  AVClass *class;
63  struct aom_codec_ctx encoder;
64  struct aom_image rawimg;
65  struct aom_fixed_buf twopass_stats;
67  int cpu_used;
71  int aq_mode;
74  int crf;
79  uint64_t sse[4];
80  int have_sse; /**< true if we have pending sse[] */
81  uint64_t frame_number;
88  int tile_cols_log2, tile_rows_log2;
89  aom_superblock_size_t superblock_size;
91  int row_mt;
95 } AOMContext;
96 
97 static const char *const ctlidstr[] = {
98  [AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
99  [AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
100  [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
101  [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
102  [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
103  [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
104  [AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
105  [AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
106  [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
107  [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
108  [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
109  [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
110  [AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
111  [AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
112  [AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
113 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
114  [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
115 #endif
116 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
117  [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
118 #endif
119 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
120  [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
121 #endif
122 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
123  [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
124 #endif
125 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
126  [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
127 #endif
128 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
129  [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
130 #endif
131  [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
132 };
133 
134 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
135 {
136  AOMContext *ctx = avctx->priv_data;
137  const char *error = aom_codec_error(&ctx->encoder);
138  const char *detail = aom_codec_error_detail(&ctx->encoder);
139 
140  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
141  if (detail)
142  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
143 }
144 
146  const struct aom_codec_enc_cfg *cfg)
147 {
148  int width = -30;
149  int level = AV_LOG_DEBUG;
150 
151  av_log(avctx, level, "aom_codec_enc_cfg\n");
152  av_log(avctx, level, "generic settings\n"
153  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
154  " %*s%u\n %*s%u\n"
155  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
156  width, "g_usage:", cfg->g_usage,
157  width, "g_threads:", cfg->g_threads,
158  width, "g_profile:", cfg->g_profile,
159  width, "g_w:", cfg->g_w,
160  width, "g_h:", cfg->g_h,
161  width, "g_bit_depth:", cfg->g_bit_depth,
162  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
163  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
164  width, "g_error_resilient:", cfg->g_error_resilient,
165  width, "g_pass:", cfg->g_pass,
166  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
167  av_log(avctx, level, "rate control settings\n"
168  " %*s%u\n %*s%d\n %*s%p(%"SIZE_SPECIFIER")\n %*s%u\n",
169  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
170  width, "rc_end_usage:", cfg->rc_end_usage,
171  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
172  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
173  av_log(avctx, level, "quantizer settings\n"
174  " %*s%u\n %*s%u\n",
175  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
176  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
177  av_log(avctx, level, "bitrate tolerance\n"
178  " %*s%u\n %*s%u\n",
179  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
180  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
181  av_log(avctx, level, "decoder buffer model\n"
182  " %*s%u\n %*s%u\n %*s%u\n",
183  width, "rc_buf_sz:", cfg->rc_buf_sz,
184  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
185  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
186  av_log(avctx, level, "2 pass rate control settings\n"
187  " %*s%u\n %*s%u\n %*s%u\n",
188  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
189  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
190  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
191  av_log(avctx, level, "keyframing settings\n"
192  " %*s%d\n %*s%u\n %*s%u\n",
193  width, "kf_mode:", cfg->kf_mode,
194  width, "kf_min_dist:", cfg->kf_min_dist,
195  width, "kf_max_dist:", cfg->kf_max_dist);
196  av_log(avctx, level, "tile settings\n"
197  " %*s%d\n %*s%d\n",
198  width, "tile_width_count:", cfg->tile_width_count,
199  width, "tile_height_count:", cfg->tile_height_count);
200  av_log(avctx, level, "\n");
201 }
202 
203 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
204 {
205  struct FrameListData **p = list;
206 
207  while (*p)
208  p = &(*p)->next;
209  *p = cx_frame;
210  cx_frame->next = NULL;
211 }
212 
213 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
214 {
215  av_freep(&cx_frame->buf);
216  av_freep(&cx_frame);
217 }
218 
220 {
221  struct FrameListData *p = list;
222 
223  while (p) {
224  list = list->next;
225  free_coded_frame(p);
226  p = list;
227  }
228 }
229 
231 #ifdef UENUM1BYTE
232  aome_enc_control_id id,
233 #else
234  enum aome_enc_control_id id,
235 #endif
236  int val)
237 {
238  AOMContext *ctx = avctx->priv_data;
239  char buf[80];
240  int width = -30;
241  int res;
242 
243  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
244  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
245 
246  res = aom_codec_control(&ctx->encoder, id, val);
247  if (res != AOM_CODEC_OK) {
248  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
249  ctlidstr[id]);
250  log_encoder_error(avctx, buf);
251  return AVERROR(EINVAL);
252  }
253 
254  return 0;
255 }
256 
257 static av_cold int aom_free(AVCodecContext *avctx)
258 {
259  AOMContext *ctx = avctx->priv_data;
260 
261  aom_codec_destroy(&ctx->encoder);
262  av_freep(&ctx->twopass_stats.buf);
263  av_freep(&avctx->stats_out);
265  av_bsf_free(&ctx->bsf);
266  return 0;
267 }
268 
269 static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
270  struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
271  aom_img_fmt_t *img_fmt)
272 {
273  AOMContext av_unused *ctx = avctx->priv_data;
274  enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
275  switch (avctx->pix_fmt) {
276  case AV_PIX_FMT_YUV420P:
277  enccfg->g_profile = FF_PROFILE_AV1_MAIN;
278  *img_fmt = AOM_IMG_FMT_I420;
279  return 0;
280  case AV_PIX_FMT_YUV422P:
281  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
282  *img_fmt = AOM_IMG_FMT_I422;
283  return 0;
284  case AV_PIX_FMT_YUV444P:
285  enccfg->g_profile = FF_PROFILE_AV1_HIGH;
286  *img_fmt = AOM_IMG_FMT_I444;
287  return 0;
290  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
291  enccfg->g_bit_depth = enccfg->g_input_bit_depth =
292  avctx->pix_fmt == AV_PIX_FMT_YUV420P10 ? 10 : 12;
293  enccfg->g_profile =
294  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
295  *img_fmt = AOM_IMG_FMT_I42016;
296  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
297  return 0;
298  }
299  break;
302  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
303  enccfg->g_bit_depth = enccfg->g_input_bit_depth =
304  avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12;
305  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
306  *img_fmt = AOM_IMG_FMT_I42216;
307  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
308  return 0;
309  }
310  break;
313  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
314  enccfg->g_bit_depth = enccfg->g_input_bit_depth =
315  avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ? 10 : 12;
316  enccfg->g_profile =
317  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
318  *img_fmt = AOM_IMG_FMT_I44416;
319  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
320  return 0;
321  }
322  break;
323  default:
324  break;
325  }
326  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
327  return AVERROR_INVALIDDATA;
328 }
329 
330 static void set_color_range(AVCodecContext *avctx)
331 {
332  aom_color_range_t aom_cr;
333  switch (avctx->color_range) {
335  case AVCOL_RANGE_MPEG: aom_cr = AOM_CR_STUDIO_RANGE; break;
336  case AVCOL_RANGE_JPEG: aom_cr = AOM_CR_FULL_RANGE; break;
337  default:
338  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
339  avctx->color_range);
340  return;
341  }
342 
343  codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
344 }
345 
346 static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
347 {
348  int sb_dim = (dim + sb_size - 1) / sb_size;
349  int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
350  av_assert0(tile_dim > 0);
351  return (sb_dim + tile_dim - 1) / tile_dim;
352 }
353 
354 static int choose_tiling(AVCodecContext *avctx,
355  struct aom_codec_enc_cfg *enccfg)
356 {
357  AOMContext *ctx = avctx->priv_data;
358  int sb_128x128_possible, sb_size, sb_width, sb_height;
359  int uniform_rows, uniform_cols;
360  int uniform_64x64_possible, uniform_128x128_possible;
361  int tile_size, rounding, i;
362 
363  if (ctx->tile_cols_log2 >= 0)
364  ctx->tile_cols = 1 << ctx->tile_cols_log2;
365  if (ctx->tile_rows_log2 >= 0)
366  ctx->tile_rows = 1 << ctx->tile_rows_log2;
367 
368  if (ctx->tile_cols == 0) {
369  ctx->tile_cols = (avctx->width + AV1_MAX_TILE_WIDTH - 1) /
371  if (ctx->tile_cols > 1) {
372  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
373  "columns to fill width.\n", ctx->tile_cols);
374  }
375  }
376  av_assert0(ctx->tile_cols > 0);
377  if (ctx->tile_rows == 0) {
378  int max_tile_width =
379  FFALIGN((FFALIGN(avctx->width, 128) +
380  ctx->tile_cols - 1) / ctx->tile_cols, 128);
381  ctx->tile_rows =
382  (max_tile_width * FFALIGN(avctx->height, 128) +
384  if (ctx->tile_rows > 1) {
385  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
386  "rows to fill area.\n", ctx->tile_rows);
387  }
388  }
389  av_assert0(ctx->tile_rows > 0);
390 
391  if ((avctx->width + 63) / 64 < ctx->tile_cols ||
392  (avctx->height + 63) / 64 < ctx->tile_rows) {
393  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: frame not "
394  "large enough to fit specified tile arrangement.\n");
395  return AVERROR(EINVAL);
396  }
397  if (ctx->tile_cols > AV1_MAX_TILE_COLS ||
398  ctx->tile_rows > AV1_MAX_TILE_ROWS) {
399  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
400  "not allow more than %dx%d tiles.\n",
402  return AVERROR(EINVAL);
403  }
404  if (avctx->width / ctx->tile_cols > AV1_MAX_TILE_WIDTH) {
405  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
406  "not allow tiles of width greater than %d.\n",
408  return AVERROR(EINVAL);
409  }
410 
411  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
412 
413  if (ctx->tile_cols == 1 && ctx->tile_rows == 1) {
414  av_log(avctx, AV_LOG_DEBUG, "Using a single tile.\n");
415  return 0;
416  }
417 
418  sb_128x128_possible =
419  (avctx->width + 127) / 128 >= ctx->tile_cols &&
420  (avctx->height + 127) / 128 >= ctx->tile_rows;
421 
422  ctx->tile_cols_log2 = ctx->tile_cols == 1 ? 0 :
423  av_log2(ctx->tile_cols - 1) + 1;
424  ctx->tile_rows_log2 = ctx->tile_rows == 1 ? 0 :
425  av_log2(ctx->tile_rows - 1) + 1;
426 
427  uniform_cols = count_uniform_tiling(avctx->width,
428  64, ctx->tile_cols_log2);
429  uniform_rows = count_uniform_tiling(avctx->height,
430  64, ctx->tile_rows_log2);
431  av_log(avctx, AV_LOG_DEBUG, "Uniform with 64x64 superblocks "
432  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
433  uniform_64x64_possible = uniform_cols == ctx->tile_cols &&
434  uniform_rows == ctx->tile_rows;
435 
436  if (sb_128x128_possible) {
437  uniform_cols = count_uniform_tiling(avctx->width,
438  128, ctx->tile_cols_log2);
439  uniform_rows = count_uniform_tiling(avctx->height,
440  128, ctx->tile_rows_log2);
441  av_log(avctx, AV_LOG_DEBUG, "Uniform with 128x128 superblocks "
442  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
443  uniform_128x128_possible = uniform_cols == ctx->tile_cols &&
444  uniform_rows == ctx->tile_rows;
445  } else {
446  av_log(avctx, AV_LOG_DEBUG, "128x128 superblocks not possible.\n");
447  uniform_128x128_possible = 0;
448  }
449 
450  ctx->uniform_tiles = 1;
451  if (uniform_64x64_possible && uniform_128x128_possible) {
452  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with dynamic "
453  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
454  ctx->tile_cols_log2, ctx->tile_rows_log2);
455  return 0;
456  }
457  if (uniform_64x64_possible && !sb_128x128_possible) {
458  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 64x64 "
459  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
460  ctx->tile_cols_log2, ctx->tile_rows_log2);
461  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
462  return 0;
463  }
464  if (uniform_128x128_possible) {
465  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 128x128 "
466  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
467  ctx->tile_cols_log2, ctx->tile_rows_log2);
468  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
469  return 0;
470  }
471  ctx->uniform_tiles = 0;
472 
473  if (sb_128x128_possible) {
474  sb_size = 128;
475  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
476  } else {
477  sb_size = 64;
478  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
479  }
480  av_log(avctx, AV_LOG_DEBUG, "Using fixed tiling with %dx%d "
481  "superblocks (tile_cols = %d, tile_rows = %d).\n",
482  sb_size, sb_size, ctx->tile_cols, ctx->tile_rows);
483 
484  enccfg->tile_width_count = ctx->tile_cols;
485  enccfg->tile_height_count = ctx->tile_rows;
486 
487  sb_width = (avctx->width + sb_size - 1) / sb_size;
488  sb_height = (avctx->height + sb_size - 1) / sb_size;
489 
490  tile_size = sb_width / ctx->tile_cols;
491  rounding = sb_width % ctx->tile_cols;
492  for (i = 0; i < ctx->tile_cols; i++) {
493  enccfg->tile_widths[i] = tile_size +
494  (i < rounding / 2 ||
495  i > ctx->tile_cols - 1 - (rounding + 1) / 2);
496  }
497 
498  tile_size = sb_height / ctx->tile_rows;
499  rounding = sb_height % ctx->tile_rows;
500  for (i = 0; i < ctx->tile_rows; i++) {
501  enccfg->tile_heights[i] = tile_size +
502  (i < rounding / 2 ||
503  i > ctx->tile_rows - 1 - (rounding + 1) / 2);
504  }
505 
506  return 0;
507 }
508 
509 static av_cold int aom_init(AVCodecContext *avctx,
510  const struct aom_codec_iface *iface)
511 {
512  AOMContext *ctx = avctx->priv_data;
513  struct aom_codec_enc_cfg enccfg = { 0 };
514 #ifdef AOM_FRAME_IS_INTRAONLY
515  aom_codec_flags_t flags =
516  (avctx->flags & AV_CODEC_FLAG_PSNR) ? AOM_CODEC_USE_PSNR : 0;
517 #else
518  aom_codec_flags_t flags = 0;
519 #endif
520  AVCPBProperties *cpb_props;
521  int res;
522  aom_img_fmt_t img_fmt;
523  aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
524 
525  av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
526  av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
527 
528  if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
529  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
530  aom_codec_err_to_string(res));
531  return AVERROR(EINVAL);
532  }
533 
534  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
535  return AVERROR(EINVAL);
536 
537  if(!avctx->bit_rate)
538  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
539  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
540  return AVERROR(EINVAL);
541  }
542 
543  dump_enc_cfg(avctx, &enccfg);
544 
545  enccfg.g_w = avctx->width;
546  enccfg.g_h = avctx->height;
547  enccfg.g_timebase.num = avctx->time_base.num;
548  enccfg.g_timebase.den = avctx->time_base.den;
549  enccfg.g_threads =
550  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
551 
552  if (ctx->lag_in_frames >= 0)
553  enccfg.g_lag_in_frames = ctx->lag_in_frames;
554 
555  if (avctx->flags & AV_CODEC_FLAG_PASS1)
556  enccfg.g_pass = AOM_RC_FIRST_PASS;
557  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
558  enccfg.g_pass = AOM_RC_LAST_PASS;
559  else
560  enccfg.g_pass = AOM_RC_ONE_PASS;
561 
562  if (avctx->rc_min_rate == avctx->rc_max_rate &&
563  avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
564  enccfg.rc_end_usage = AOM_CBR;
565  } else if (ctx->crf >= 0) {
566  enccfg.rc_end_usage = AOM_CQ;
567  if (!avctx->bit_rate)
568  enccfg.rc_end_usage = AOM_Q;
569  }
570 
571  if (avctx->bit_rate) {
572  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
574  } else if (enccfg.rc_end_usage != AOM_Q) {
575  enccfg.rc_end_usage = AOM_Q;
576  ctx->crf = 32;
577  av_log(avctx, AV_LOG_WARNING,
578  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
579  ctx->crf);
580  }
581 
582  if (avctx->qmin >= 0)
583  enccfg.rc_min_quantizer = avctx->qmin;
584  if (avctx->qmax >= 0)
585  enccfg.rc_max_quantizer = avctx->qmax;
586 
587  if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
588  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
589  av_log(avctx, AV_LOG_ERROR,
590  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
591  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
592  return AVERROR(EINVAL);
593  }
594  }
595 
596  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
597 
598  // 0-100 (0 => CBR, 100 => VBR)
599  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
600  if (ctx->minsection_pct >= 0)
601  enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
602  else if (avctx->bit_rate)
603  enccfg.rc_2pass_vbr_minsection_pct =
604  avctx->rc_min_rate * 100LL / avctx->bit_rate;
605  if (ctx->maxsection_pct >= 0)
606  enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
607  else if (avctx->rc_max_rate)
608  enccfg.rc_2pass_vbr_maxsection_pct =
609  avctx->rc_max_rate * 100LL / avctx->bit_rate;
610 
611  if (avctx->rc_buffer_size)
612  enccfg.rc_buf_sz =
613  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
614  if (avctx->rc_initial_buffer_occupancy)
615  enccfg.rc_buf_initial_sz =
616  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
617  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
618 
619  if (ctx->rc_undershoot_pct >= 0)
620  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
621  if (ctx->rc_overshoot_pct >= 0)
622  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
623 
624  // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
625  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
626  enccfg.kf_min_dist = avctx->keyint_min;
627  if (avctx->gop_size >= 0)
628  enccfg.kf_max_dist = avctx->gop_size;
629 
630  if (enccfg.g_pass == AOM_RC_FIRST_PASS)
631  enccfg.g_lag_in_frames = 0;
632  else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
633  int decode_size, ret;
634 
635  if (!avctx->stats_in) {
636  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
637  return AVERROR_INVALIDDATA;
638  }
639 
640  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
641  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
642  if (ret < 0) {
643  av_log(avctx, AV_LOG_ERROR,
644  "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
645  ctx->twopass_stats.sz);
646  ctx->twopass_stats.sz = 0;
647  return ret;
648  }
649  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
650  ctx->twopass_stats.sz);
651  if (decode_size < 0) {
652  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
653  return AVERROR_INVALIDDATA;
654  }
655 
656  ctx->twopass_stats.sz = decode_size;
657  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
658  }
659 
660  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
661  * complexity playback on low powered devices at the expense of encode
662  * quality. */
663  if (avctx->profile != FF_PROFILE_UNKNOWN)
664  enccfg.g_profile = avctx->profile;
665 
666  enccfg.g_error_resilient = ctx->error_resilient;
667 
668  res = choose_tiling(avctx, &enccfg);
669  if (res < 0)
670  return res;
671 
672  dump_enc_cfg(avctx, &enccfg);
673  /* Construct Encoder Context */
674  res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
675  if (res != AOM_CODEC_OK) {
676  log_encoder_error(avctx, "Failed to initialize encoder");
677  return AVERROR(EINVAL);
678  }
679 
680  // codec control failures are currently treated only as warnings
681  av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
682  codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
683  if (ctx->auto_alt_ref >= 0)
684  codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
685  if (ctx->arnr_max_frames >= 0)
686  codecctl_int(avctx, AOME_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
687  if (ctx->arnr_strength >= 0)
688  codecctl_int(avctx, AOME_SET_ARNR_STRENGTH, ctx->arnr_strength);
689  if (ctx->enable_cdef >= 0)
690  codecctl_int(avctx, AV1E_SET_ENABLE_CDEF, ctx->enable_cdef);
691  codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
692  if (ctx->crf >= 0)
693  codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
694 
695  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
696  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
697  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
698  if (ctx->aq_mode >= 0)
699  codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
700  if (ctx->frame_parallel >= 0)
701  codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
702  set_color_range(avctx);
703 
704  codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
705  if (ctx->uniform_tiles) {
706  codecctl_int(avctx, AV1E_SET_TILE_COLUMNS, ctx->tile_cols_log2);
707  codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
708  }
709 
710 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
711  if (ctx->denoise_noise_level >= 0)
712  codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
713 #endif
714 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
715  if (ctx->denoise_block_size >= 0)
716  codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
717 #endif
718 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
719  if (ctx->enable_global_motion >= 0)
720  codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
721 #endif
722 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
723  if (avctx->refs >= 3) {
724  codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
725  }
726 #endif
727 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
728  if (ctx->row_mt >= 0)
729  codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
730 #endif
731 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
732  if (ctx->enable_intrabc >= 0)
733  codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
734 #endif
735 
736  // provide dummy value to initialize wrapper, values will be updated each _encode()
737  aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
738  (unsigned char*)1);
739 
740  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
741  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
742 
743  cpb_props = ff_add_cpb_side_data(avctx);
744  if (!cpb_props)
745  return AVERROR(ENOMEM);
746 
747  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
748  const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
749  int ret;
750 
751  if (!filter) {
752  av_log(avctx, AV_LOG_ERROR, "extract_extradata bitstream filter "
753  "not found. This is a bug, please report it.\n");
754  return AVERROR_BUG;
755  }
756  ret = av_bsf_alloc(filter, &ctx->bsf);
757  if (ret < 0)
758  return ret;
759 
760  ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx);
761  if (ret < 0)
762  return ret;
763 
764  ret = av_bsf_init(ctx->bsf);
765  if (ret < 0)
766  return ret;
767  }
768 
769  if (enccfg.rc_end_usage == AOM_CBR ||
770  enccfg.g_pass != AOM_RC_ONE_PASS) {
771  cpb_props->max_bitrate = avctx->rc_max_rate;
772  cpb_props->min_bitrate = avctx->rc_min_rate;
773  cpb_props->avg_bitrate = avctx->bit_rate;
774  }
775  cpb_props->buffer_size = avctx->rc_buffer_size;
776 
777  return 0;
778 }
779 
780 static inline void cx_pktcpy(AOMContext *ctx,
781  struct FrameListData *dst,
782  const struct aom_codec_cx_pkt *src)
783 {
784  dst->pts = src->data.frame.pts;
785  dst->duration = src->data.frame.duration;
786  dst->flags = src->data.frame.flags;
787  dst->sz = src->data.frame.sz;
788  dst->buf = src->data.frame.buf;
789 #ifdef AOM_FRAME_IS_INTRAONLY
790  dst->have_sse = 0;
791  dst->frame_number = ++ctx->frame_number;
792  dst->have_sse = ctx->have_sse;
793  if (ctx->have_sse) {
794  /* associate last-seen SSE to the frame. */
795  /* Transfers ownership from ctx to dst. */
796  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
797  ctx->have_sse = 0;
798  }
799 #endif
800 }
801 
802 /**
803  * Store coded frame information in format suitable for return from encode2().
804  *
805  * Write information from @a cx_frame to @a pkt
806  * @return packet data size on success
807  * @return a negative AVERROR on error
808  */
809 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
810  AVPacket *pkt)
811 {
812  AOMContext *ctx = avctx->priv_data;
813  int av_unused pict_type;
814  int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
815  if (ret < 0) {
816  av_log(avctx, AV_LOG_ERROR,
817  "Error getting output packet of size %"SIZE_SPECIFIER".\n", cx_frame->sz);
818  return ret;
819  }
820  memcpy(pkt->data, cx_frame->buf, pkt->size);
821  pkt->pts = pkt->dts = cx_frame->pts;
822 
823  if (!!(cx_frame->flags & AOM_FRAME_IS_KEY)) {
824  pkt->flags |= AV_PKT_FLAG_KEY;
825 #ifdef AOM_FRAME_IS_INTRAONLY
826  pict_type = AV_PICTURE_TYPE_I;
827  } else if (cx_frame->flags & AOM_FRAME_IS_INTRAONLY) {
828  pict_type = AV_PICTURE_TYPE_I;
829  } else {
830  pict_type = AV_PICTURE_TYPE_P;
831  }
832 
833  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
834  cx_frame->have_sse ? 3 : 0, pict_type);
835 
836  if (cx_frame->have_sse) {
837  int i;
838  for (i = 0; i < 3; ++i) {
839  avctx->error[i] += cx_frame->sse[i + 1];
840  }
841  cx_frame->have_sse = 0;
842 #endif
843  }
844 
845  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
846  ret = av_bsf_send_packet(ctx->bsf, pkt);
847  if (ret < 0) {
848  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
849  "failed to send input packet\n");
850  return ret;
851  }
852  ret = av_bsf_receive_packet(ctx->bsf, pkt);
853 
854  if (ret < 0) {
855  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
856  "failed to receive output packet\n");
857  return ret;
858  }
859  }
860  return pkt->size;
861 }
862 
863 /**
864  * Queue multiple output frames from the encoder, returning the front-most.
865  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
866  * the frame queue. Return the head frame if available.
867  * @return Stored frame size
868  * @return AVERROR(EINVAL) on output size error
869  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
870  */
871 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
872 {
873  AOMContext *ctx = avctx->priv_data;
874  const struct aom_codec_cx_pkt *pkt;
875  const void *iter = NULL;
876  int size = 0;
877 
878  if (ctx->coded_frame_list) {
879  struct FrameListData *cx_frame = ctx->coded_frame_list;
880  /* return the leading frame if we've already begun queueing */
881  size = storeframe(avctx, cx_frame, pkt_out);
882  if (size < 0)
883  return size;
884  ctx->coded_frame_list = cx_frame->next;
885  free_coded_frame(cx_frame);
886  }
887 
888  /* consume all available output from the encoder before returning. buffers
889  * are only good through the next aom_codec call */
890  while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
891  switch (pkt->kind) {
892  case AOM_CODEC_CX_FRAME_PKT:
893  if (!size) {
894  struct FrameListData cx_frame;
895 
896  /* avoid storing the frame when the list is empty and we haven't yet
897  * provided a frame for output */
899  cx_pktcpy(ctx, &cx_frame, pkt);
900  size = storeframe(avctx, &cx_frame, pkt_out);
901  if (size < 0)
902  return size;
903  } else {
904  struct FrameListData *cx_frame =
905  av_malloc(sizeof(struct FrameListData));
906 
907  if (!cx_frame) {
908  av_log(avctx, AV_LOG_ERROR,
909  "Frame queue element alloc failed\n");
910  return AVERROR(ENOMEM);
911  }
912  cx_pktcpy(ctx, cx_frame, pkt);
913  cx_frame->buf = av_malloc(cx_frame->sz);
914 
915  if (!cx_frame->buf) {
916  av_log(avctx, AV_LOG_ERROR,
917  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
918  cx_frame->sz);
919  av_freep(&cx_frame);
920  return AVERROR(ENOMEM);
921  }
922  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
923  coded_frame_add(&ctx->coded_frame_list, cx_frame);
924  }
925  break;
926  case AOM_CODEC_STATS_PKT:
927  {
928  struct aom_fixed_buf *stats = &ctx->twopass_stats;
929  int err;
930  if ((err = av_reallocp(&stats->buf,
931  stats->sz +
932  pkt->data.twopass_stats.sz)) < 0) {
933  stats->sz = 0;
934  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
935  return err;
936  }
937  memcpy((uint8_t *)stats->buf + stats->sz,
938  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
939  stats->sz += pkt->data.twopass_stats.sz;
940  break;
941  }
942 #ifdef AOM_FRAME_IS_INTRAONLY
943  case AOM_CODEC_PSNR_PKT:
944  {
945  av_assert0(!ctx->have_sse);
946  ctx->sse[0] = pkt->data.psnr.sse[0];
947  ctx->sse[1] = pkt->data.psnr.sse[1];
948  ctx->sse[2] = pkt->data.psnr.sse[2];
949  ctx->sse[3] = pkt->data.psnr.sse[3];
950  ctx->have_sse = 1;
951  break;
952  }
953 #endif
954  case AOM_CODEC_CUSTOM_PKT:
955  // ignore unsupported/unrecognized packet types
956  break;
957  }
958  }
959 
960  return size;
961 }
962 
963 static int aom_encode(AVCodecContext *avctx, AVPacket *pkt,
964  const AVFrame *frame, int *got_packet)
965 {
966  AOMContext *ctx = avctx->priv_data;
967  struct aom_image *rawimg = NULL;
968  int64_t timestamp = 0;
969  int res, coded_size;
970  aom_enc_frame_flags_t flags = 0;
971 
972  if (frame) {
973  rawimg = &ctx->rawimg;
974  rawimg->planes[AOM_PLANE_Y] = frame->data[0];
975  rawimg->planes[AOM_PLANE_U] = frame->data[1];
976  rawimg->planes[AOM_PLANE_V] = frame->data[2];
977  rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
978  rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
979  rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
980  timestamp = frame->pts;
981  switch (frame->color_range) {
982  case AVCOL_RANGE_MPEG:
983  rawimg->range = AOM_CR_STUDIO_RANGE;
984  break;
985  case AVCOL_RANGE_JPEG:
986  rawimg->range = AOM_CR_FULL_RANGE;
987  break;
988  }
989 
990  if (frame->pict_type == AV_PICTURE_TYPE_I)
991  flags |= AOM_EFLAG_FORCE_KF;
992  }
993 
994  res = aom_codec_encode(&ctx->encoder, rawimg, timestamp,
995  avctx->ticks_per_frame, flags);
996  if (res != AOM_CODEC_OK) {
997  log_encoder_error(avctx, "Error encoding frame");
998  return AVERROR_INVALIDDATA;
999  }
1000  coded_size = queue_frames(avctx, pkt);
1001 
1002  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1003  size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1004 
1005  avctx->stats_out = av_malloc(b64_size);
1006  if (!avctx->stats_out) {
1007  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1008  b64_size);
1009  return AVERROR(ENOMEM);
1010  }
1011  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1012  ctx->twopass_stats.sz);
1013  }
1014 
1015  *got_packet = !!coded_size;
1016  return 0;
1017 }
1018 
1019 static const enum AVPixelFormat av1_pix_fmts[] = {
1024 };
1025 
1026 static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
1037 };
1038 
1039 static av_cold void av1_init_static(AVCodec *codec)
1040 {
1041  aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1042  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1043  codec->pix_fmts = av1_pix_fmts_highbd;
1044  else
1045  codec->pix_fmts = av1_pix_fmts;
1046 }
1047 
1048 static av_cold int av1_init(AVCodecContext *avctx)
1049 {
1050  return aom_init(avctx, aom_codec_av1_cx());
1051 }
1052 
1053 #define OFFSET(x) offsetof(AOMContext, x)
1054 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1055 static const AVOption options[] = {
1056  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 8, VE},
1057  { "auto-alt-ref", "Enable use of alternate reference "
1058  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1059  { "lag-in-frames", "Number of frames to look ahead at for "
1060  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1061  { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1062  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1063  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
1064  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode"},
1065  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode"},
1066  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode"},
1067  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode"},
1068  { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
1069  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
1070  { "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1071  { "static-thresh", "A change threshold on blocks below which they will be skipped by the encoder", OFFSET(static_thresh), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
1072  { "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1073  { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1074  { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1075  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1076  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1077  { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1078  { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1079  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1080  { "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
1081  { "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1082  { "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1083  { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1084  { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1085  { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1086  { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1087  { NULL },
1088 };
1089 
1090 static const AVCodecDefault defaults[] = {
1091  { "b", "0" },
1092  { "qmin", "-1" },
1093  { "qmax", "-1" },
1094  { "g", "-1" },
1095  { "keyint_min", "-1" },
1096  { NULL },
1097 };
1098 
1099 static const AVClass class_aom = {
1100  .class_name = "libaom-av1 encoder",
1101  .item_name = av_default_item_name,
1102  .option = options,
1103  .version = LIBAVUTIL_VERSION_INT,
1104 };
1105 
1107  .name = "libaom-av1",
1108  .long_name = NULL_IF_CONFIG_SMALL("libaom AV1"),
1109  .type = AVMEDIA_TYPE_VIDEO,
1110  .id = AV_CODEC_ID_AV1,
1111  .priv_data_size = sizeof(AOMContext),
1112  .init = av1_init,
1113  .encode2 = aom_encode,
1114  .close = aom_free,
1117  .priv_class = &class_aom,
1118  .defaults = defaults,
1119  .init_static_data = av1_init_static,
1120  .wrapper_name = "libaom",
1121 };
#define OFFSET(x)
Definition: libaomenc.c:1053
int denoise_block_size
Definition: libaomenc.c:78
void av_bsf_free(AVBSFContext **ctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:35
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
uint64_t sse[4]
Definition: libaomenc.c:79
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int minsection_pct
Definition: libaomenc.c:84
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int enable_cdef
Definition: libaomenc.c:92
AVOption.
Definition: opt.h:246
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:720
int av_cpu_count(void)
Definition: cpu.c:267
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:2751
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const char * desc
Definition: nvenc.c:68
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1137
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2474
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
Definition: libaomenc.c:509
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2203
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: avcodec.h:5774
int size
Definition: avcodec.h:1481
void * buf
compressed data buffer
Definition: libaomenc.c:47
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
int av_log2(unsigned v)
Definition: intmath.c:26
int maxsection_pct
Definition: libaomenc.c:85
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
size_t sz
length of compressed data
Definition: libaomenc.c:48
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1032
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2595
int tile_cols_log2
Definition: libaomenc.c:88
uint64_t frame_number
Definition: libaomenc.c:81
static AVPacket pkt
static const AVOption options[]
Definition: libaomenc.c:1055
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1052
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2901
AVCodec.
Definition: avcodec.h:3492
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:135
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1146
int error_resilient
Definition: libaomenc.c:73
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1691
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:82
int tile_rows_log2
Definition: libaomenc.c:88
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
Definition: libaomenc.c:354
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
#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: avcodec.h:1009
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int tile_cols
Definition: h265_levels.c:218
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libaomenc.c:219
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:212
struct FrameListData * next
Definition: libaomenc.c:57
uint8_t
struct aom_fixed_buf twopass_stats
Definition: libaomenc.c:65
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
int64_t pts
time stamp to show frame (in timebase units)
Definition: libaomenc.c:49
int arnr_strength
Definition: libaomenc.c:70
AVOptions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
struct aom_image rawimg
Definition: libaomenc.c:64
uint8_t * data
Definition: avcodec.h:1480
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
Definition: libaomenc.c:230
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1164
ptrdiff_t size
Definition: opengl_enc.c:100
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2587
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
int rc_overshoot_pct
Definition: libaomenc.c:83
int enable_intrabc
Definition: libaomenc.c:94
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
Definition: libaomenc.c:780
#define VE
Definition: libaomenc.c:1054
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
static av_cold void av1_init_static(AVCodec *codec)
Definition: libaomenc.c:1039
int tile_rows
Definition: libaomenc.c:87
int qmax
maximum quantizer
Definition: avcodec.h:2417
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int aq_mode
Definition: libaomenc.c:71
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:539
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
static av_always_inline av_const double round(double x)
Definition: libm.h:444
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:138
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
Definition: libaomenc.c:809
static void set_color_range(AVCodecContext *avctx)
Definition: libaomenc.c:330
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2431
static const AVClass class_aom
Definition: libaomenc.c:1099
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2453
AVCodec ff_libaom_av1_encoder
Definition: libaomenc.c:1106
int refs
number of reference frames
Definition: avcodec.h:2156
struct FrameListData * coded_frame_list
Definition: libaomenc.c:66
static enum AVPixelFormat av1_pix_fmts_highbd[]
Definition: libaomenc.c:1026
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3513
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
Definition: libaomenc.c:871
#define FFMIN(a, b)
Definition: common.h:96
uint64_t sse[4]
Definition: libaomenc.c:54
#define width
int width
picture width / height.
Definition: avcodec.h:1741
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2902
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:186
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libaomenc.c:213
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:890
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:874
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2182
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
Definition: libaomenc.c:346
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
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
int row_mt
Definition: libaomenc.c:91
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1700
static const char *const ctlidstr[]
Definition: libaomenc.c:97
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
static void error(const char *err)
int cpu_used
Definition: libaomenc.c:67
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2827
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:523
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:80
static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps, struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags, aom_img_fmt_t *img_fmt)
Definition: libaomenc.c:269
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1131
struct aom_codec_ctx encoder
Definition: libaomenc.c:63
int enable_global_motion
Definition: libaomenc.c:93
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
Libavcodec external API header.
aom_superblock_size_t superblock_size
Definition: libaomenc.c:89
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
const AVProfile ff_av1_profiles[]
Definition: profiles.c:142
main external API structure.
Definition: avcodec.h:1568
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 list
static enum AVPixelFormat av1_pix_fmts[]
Definition: libaomenc.c:1019
int qmin
minimum quantizer
Definition: avcodec.h:2410
AV1 common definitions.
int frame_parallel
Definition: libaomenc.c:86
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
static av_cold int av1_init(AVCodecContext *avctx)
Definition: libaomenc.c:1048
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libaomenc.c:203
Describe the class of an AVClass context structure.
Definition: log.h:67
static const AVProfile profiles[]
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:2996
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2196
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2189
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2053
int uniform_tiles
Definition: libaomenc.c:90
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:2994
uint32_t flags
flags for this frame
Definition: libaomenc.c:53
int dim
#define snprintf
Definition: snprintf.h:34
uint64_t frame_number
Definition: libaomenc.c:56
offset must point to two consecutive integers
Definition: opt.h:233
int static_thresh
Definition: libaomenc.c:75
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct aom_codec_enc_cfg *cfg)
Definition: libaomenc.c:145
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2402
int drop_threshold
Definition: libaomenc.c:76
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:55
#define SIZE_SPECIFIER
Definition: internal.h:262
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:907
AVBSFContext * bsf
Definition: libaomenc.c:62
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:522
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1763
int denoise_noise_level
Definition: libaomenc.c:77
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
common internal api header.
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libaomenc.c:134
common internal and external API header
int auto_alt_ref
Definition: libaomenc.c:68
static int aom_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libaomenc.c:963
int den
Denominator.
Definition: rational.h:60
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1968
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:878
void * priv_data
Definition: avcodec.h:1595
int tile_cols
Definition: libaomenc.c:87
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libaomenc.c:46
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
int arnr_max_frames
Definition: libaomenc.c:69
unsigned long duration
duration to show frame (in timebase units)
Definition: libaomenc.c:51
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:79
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
#define av_freep(p)
static const AVCodecDefault defaults[]
Definition: libaomenc.c:1090
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5802
int rc_undershoot_pct
Definition: libaomenc.c:82
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
static av_cold int aom_free(AVCodecContext *avctx)
Definition: libaomenc.c:257
Predicted.
Definition: avutil.h:275
int lag_in_frames
Definition: libaomenc.c:72
#define av_unused
Definition: attributes.h:125
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:2995
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2446
int keyint_min
minimum GOP size
Definition: avcodec.h:2149