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  if (enccfg.rc_end_usage == AOM_CQ) {
576  enccfg.rc_target_bitrate = 1000000;
577  } else {
578  enccfg.rc_end_usage = AOM_Q;
579  ctx->crf = 32;
580  av_log(avctx, AV_LOG_WARNING,
581  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
582  ctx->crf);
583  }
584  }
585 
586  if (avctx->qmin >= 0)
587  enccfg.rc_min_quantizer = avctx->qmin;
588  if (avctx->qmax >= 0)
589  enccfg.rc_max_quantizer = avctx->qmax;
590 
591  if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
592  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
593  av_log(avctx, AV_LOG_ERROR,
594  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
595  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
596  return AVERROR(EINVAL);
597  }
598  }
599 
600  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
601 
602  // 0-100 (0 => CBR, 100 => VBR)
603  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
604  if (ctx->minsection_pct >= 0)
605  enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
606  else if (avctx->bit_rate)
607  enccfg.rc_2pass_vbr_minsection_pct =
608  avctx->rc_min_rate * 100LL / avctx->bit_rate;
609  if (ctx->maxsection_pct >= 0)
610  enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
611  else if (avctx->rc_max_rate)
612  enccfg.rc_2pass_vbr_maxsection_pct =
613  avctx->rc_max_rate * 100LL / avctx->bit_rate;
614 
615  if (avctx->rc_buffer_size)
616  enccfg.rc_buf_sz =
617  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
618  if (avctx->rc_initial_buffer_occupancy)
619  enccfg.rc_buf_initial_sz =
620  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
621  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
622 
623  if (ctx->rc_undershoot_pct >= 0)
624  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
625  if (ctx->rc_overshoot_pct >= 0)
626  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
627 
628  // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
629  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
630  enccfg.kf_min_dist = avctx->keyint_min;
631  if (avctx->gop_size >= 0)
632  enccfg.kf_max_dist = avctx->gop_size;
633 
634  if (enccfg.g_pass == AOM_RC_FIRST_PASS)
635  enccfg.g_lag_in_frames = 0;
636  else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
637  int decode_size, ret;
638 
639  if (!avctx->stats_in) {
640  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
641  return AVERROR_INVALIDDATA;
642  }
643 
644  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
645  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
646  if (ret < 0) {
647  av_log(avctx, AV_LOG_ERROR,
648  "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
649  ctx->twopass_stats.sz);
650  ctx->twopass_stats.sz = 0;
651  return ret;
652  }
653  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
654  ctx->twopass_stats.sz);
655  if (decode_size < 0) {
656  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
657  return AVERROR_INVALIDDATA;
658  }
659 
660  ctx->twopass_stats.sz = decode_size;
661  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
662  }
663 
664  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
665  * complexity playback on low powered devices at the expense of encode
666  * quality. */
667  if (avctx->profile != FF_PROFILE_UNKNOWN)
668  enccfg.g_profile = avctx->profile;
669 
670  enccfg.g_error_resilient = ctx->error_resilient;
671 
672  res = choose_tiling(avctx, &enccfg);
673  if (res < 0)
674  return res;
675 
676  dump_enc_cfg(avctx, &enccfg);
677  /* Construct Encoder Context */
678  res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
679  if (res != AOM_CODEC_OK) {
680  log_encoder_error(avctx, "Failed to initialize encoder");
681  return AVERROR(EINVAL);
682  }
683 
684  // codec control failures are currently treated only as warnings
685  av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
686  codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
687  if (ctx->auto_alt_ref >= 0)
688  codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
689  if (ctx->arnr_max_frames >= 0)
690  codecctl_int(avctx, AOME_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
691  if (ctx->arnr_strength >= 0)
692  codecctl_int(avctx, AOME_SET_ARNR_STRENGTH, ctx->arnr_strength);
693  if (ctx->enable_cdef >= 0)
694  codecctl_int(avctx, AV1E_SET_ENABLE_CDEF, ctx->enable_cdef);
695  codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
696  if (ctx->crf >= 0)
697  codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
698 
699  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
700  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
701  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
702  if (ctx->aq_mode >= 0)
703  codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
704  if (ctx->frame_parallel >= 0)
705  codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
706  set_color_range(avctx);
707 
708  codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
709  if (ctx->uniform_tiles) {
710  codecctl_int(avctx, AV1E_SET_TILE_COLUMNS, ctx->tile_cols_log2);
711  codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
712  }
713 
714 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
715  if (ctx->denoise_noise_level >= 0)
716  codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
717 #endif
718 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
719  if (ctx->denoise_block_size >= 0)
720  codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
721 #endif
722 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
723  if (ctx->enable_global_motion >= 0)
724  codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
725 #endif
726 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
727  if (avctx->refs >= 3) {
728  codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
729  }
730 #endif
731 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
732  if (ctx->row_mt >= 0)
733  codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
734 #endif
735 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
736  if (ctx->enable_intrabc >= 0)
737  codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
738 #endif
739 
740  // provide dummy value to initialize wrapper, values will be updated each _encode()
741  aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
742  (unsigned char*)1);
743 
744  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
745  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
746 
747  cpb_props = ff_add_cpb_side_data(avctx);
748  if (!cpb_props)
749  return AVERROR(ENOMEM);
750 
751  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
752  const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
753  int ret;
754 
755  if (!filter) {
756  av_log(avctx, AV_LOG_ERROR, "extract_extradata bitstream filter "
757  "not found. This is a bug, please report it.\n");
758  return AVERROR_BUG;
759  }
760  ret = av_bsf_alloc(filter, &ctx->bsf);
761  if (ret < 0)
762  return ret;
763 
764  ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx);
765  if (ret < 0)
766  return ret;
767 
768  ret = av_bsf_init(ctx->bsf);
769  if (ret < 0)
770  return ret;
771  }
772 
773  if (enccfg.rc_end_usage == AOM_CBR ||
774  enccfg.g_pass != AOM_RC_ONE_PASS) {
775  cpb_props->max_bitrate = avctx->rc_max_rate;
776  cpb_props->min_bitrate = avctx->rc_min_rate;
777  cpb_props->avg_bitrate = avctx->bit_rate;
778  }
779  cpb_props->buffer_size = avctx->rc_buffer_size;
780 
781  return 0;
782 }
783 
784 static inline void cx_pktcpy(AOMContext *ctx,
785  struct FrameListData *dst,
786  const struct aom_codec_cx_pkt *src)
787 {
788  dst->pts = src->data.frame.pts;
789  dst->duration = src->data.frame.duration;
790  dst->flags = src->data.frame.flags;
791  dst->sz = src->data.frame.sz;
792  dst->buf = src->data.frame.buf;
793 #ifdef AOM_FRAME_IS_INTRAONLY
794  dst->have_sse = 0;
795  dst->frame_number = ++ctx->frame_number;
796  dst->have_sse = ctx->have_sse;
797  if (ctx->have_sse) {
798  /* associate last-seen SSE to the frame. */
799  /* Transfers ownership from ctx to dst. */
800  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
801  ctx->have_sse = 0;
802  }
803 #endif
804 }
805 
806 /**
807  * Store coded frame information in format suitable for return from encode2().
808  *
809  * Write information from @a cx_frame to @a pkt
810  * @return packet data size on success
811  * @return a negative AVERROR on error
812  */
813 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
814  AVPacket *pkt)
815 {
816  AOMContext *ctx = avctx->priv_data;
817  int av_unused pict_type;
818  int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
819  if (ret < 0) {
820  av_log(avctx, AV_LOG_ERROR,
821  "Error getting output packet of size %"SIZE_SPECIFIER".\n", cx_frame->sz);
822  return ret;
823  }
824  memcpy(pkt->data, cx_frame->buf, pkt->size);
825  pkt->pts = pkt->dts = cx_frame->pts;
826 
827  if (!!(cx_frame->flags & AOM_FRAME_IS_KEY)) {
828  pkt->flags |= AV_PKT_FLAG_KEY;
829 #ifdef AOM_FRAME_IS_INTRAONLY
830  pict_type = AV_PICTURE_TYPE_I;
831  } else if (cx_frame->flags & AOM_FRAME_IS_INTRAONLY) {
832  pict_type = AV_PICTURE_TYPE_I;
833  } else {
834  pict_type = AV_PICTURE_TYPE_P;
835  }
836 
837  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
838  cx_frame->have_sse ? 3 : 0, pict_type);
839 
840  if (cx_frame->have_sse) {
841  int i;
842  for (i = 0; i < 3; ++i) {
843  avctx->error[i] += cx_frame->sse[i + 1];
844  }
845  cx_frame->have_sse = 0;
846 #endif
847  }
848 
849  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
850  ret = av_bsf_send_packet(ctx->bsf, pkt);
851  if (ret < 0) {
852  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
853  "failed to send input packet\n");
854  return ret;
855  }
856  ret = av_bsf_receive_packet(ctx->bsf, pkt);
857 
858  if (ret < 0) {
859  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
860  "failed to receive output packet\n");
861  return ret;
862  }
863  }
864  return pkt->size;
865 }
866 
867 /**
868  * Queue multiple output frames from the encoder, returning the front-most.
869  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
870  * the frame queue. Return the head frame if available.
871  * @return Stored frame size
872  * @return AVERROR(EINVAL) on output size error
873  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
874  */
875 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
876 {
877  AOMContext *ctx = avctx->priv_data;
878  const struct aom_codec_cx_pkt *pkt;
879  const void *iter = NULL;
880  int size = 0;
881 
882  if (ctx->coded_frame_list) {
883  struct FrameListData *cx_frame = ctx->coded_frame_list;
884  /* return the leading frame if we've already begun queueing */
885  size = storeframe(avctx, cx_frame, pkt_out);
886  if (size < 0)
887  return size;
888  ctx->coded_frame_list = cx_frame->next;
889  free_coded_frame(cx_frame);
890  }
891 
892  /* consume all available output from the encoder before returning. buffers
893  * are only good through the next aom_codec call */
894  while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
895  switch (pkt->kind) {
896  case AOM_CODEC_CX_FRAME_PKT:
897  if (!size) {
898  struct FrameListData cx_frame;
899 
900  /* avoid storing the frame when the list is empty and we haven't yet
901  * provided a frame for output */
903  cx_pktcpy(ctx, &cx_frame, pkt);
904  size = storeframe(avctx, &cx_frame, pkt_out);
905  if (size < 0)
906  return size;
907  } else {
908  struct FrameListData *cx_frame =
909  av_malloc(sizeof(struct FrameListData));
910 
911  if (!cx_frame) {
912  av_log(avctx, AV_LOG_ERROR,
913  "Frame queue element alloc failed\n");
914  return AVERROR(ENOMEM);
915  }
916  cx_pktcpy(ctx, cx_frame, pkt);
917  cx_frame->buf = av_malloc(cx_frame->sz);
918 
919  if (!cx_frame->buf) {
920  av_log(avctx, AV_LOG_ERROR,
921  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
922  cx_frame->sz);
923  av_freep(&cx_frame);
924  return AVERROR(ENOMEM);
925  }
926  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
927  coded_frame_add(&ctx->coded_frame_list, cx_frame);
928  }
929  break;
930  case AOM_CODEC_STATS_PKT:
931  {
932  struct aom_fixed_buf *stats = &ctx->twopass_stats;
933  int err;
934  if ((err = av_reallocp(&stats->buf,
935  stats->sz +
936  pkt->data.twopass_stats.sz)) < 0) {
937  stats->sz = 0;
938  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
939  return err;
940  }
941  memcpy((uint8_t *)stats->buf + stats->sz,
942  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
943  stats->sz += pkt->data.twopass_stats.sz;
944  break;
945  }
946 #ifdef AOM_FRAME_IS_INTRAONLY
947  case AOM_CODEC_PSNR_PKT:
948  {
949  av_assert0(!ctx->have_sse);
950  ctx->sse[0] = pkt->data.psnr.sse[0];
951  ctx->sse[1] = pkt->data.psnr.sse[1];
952  ctx->sse[2] = pkt->data.psnr.sse[2];
953  ctx->sse[3] = pkt->data.psnr.sse[3];
954  ctx->have_sse = 1;
955  break;
956  }
957 #endif
958  case AOM_CODEC_CUSTOM_PKT:
959  // ignore unsupported/unrecognized packet types
960  break;
961  }
962  }
963 
964  return size;
965 }
966 
967 static int aom_encode(AVCodecContext *avctx, AVPacket *pkt,
968  const AVFrame *frame, int *got_packet)
969 {
970  AOMContext *ctx = avctx->priv_data;
971  struct aom_image *rawimg = NULL;
972  int64_t timestamp = 0;
973  int res, coded_size;
974  aom_enc_frame_flags_t flags = 0;
975 
976  if (frame) {
977  rawimg = &ctx->rawimg;
978  rawimg->planes[AOM_PLANE_Y] = frame->data[0];
979  rawimg->planes[AOM_PLANE_U] = frame->data[1];
980  rawimg->planes[AOM_PLANE_V] = frame->data[2];
981  rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
982  rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
983  rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
984  timestamp = frame->pts;
985  switch (frame->color_range) {
986  case AVCOL_RANGE_MPEG:
987  rawimg->range = AOM_CR_STUDIO_RANGE;
988  break;
989  case AVCOL_RANGE_JPEG:
990  rawimg->range = AOM_CR_FULL_RANGE;
991  break;
992  }
993 
994  if (frame->pict_type == AV_PICTURE_TYPE_I)
995  flags |= AOM_EFLAG_FORCE_KF;
996  }
997 
998  res = aom_codec_encode(&ctx->encoder, rawimg, timestamp,
999  avctx->ticks_per_frame, flags);
1000  if (res != AOM_CODEC_OK) {
1001  log_encoder_error(avctx, "Error encoding frame");
1002  return AVERROR_INVALIDDATA;
1003  }
1004  coded_size = queue_frames(avctx, pkt);
1005 
1006  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1007  size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1008 
1009  avctx->stats_out = av_malloc(b64_size);
1010  if (!avctx->stats_out) {
1011  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1012  b64_size);
1013  return AVERROR(ENOMEM);
1014  }
1015  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1016  ctx->twopass_stats.sz);
1017  }
1018 
1019  *got_packet = !!coded_size;
1020  return 0;
1021 }
1022 
1023 static const enum AVPixelFormat av1_pix_fmts[] = {
1028 };
1029 
1030 static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
1041 };
1042 
1043 static av_cold void av1_init_static(AVCodec *codec)
1044 {
1045  aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1046  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1047  codec->pix_fmts = av1_pix_fmts_highbd;
1048  else
1049  codec->pix_fmts = av1_pix_fmts;
1050 }
1051 
1052 static av_cold int av1_init(AVCodecContext *avctx)
1053 {
1054  return aom_init(avctx, aom_codec_av1_cx());
1055 }
1056 
1057 #define OFFSET(x) offsetof(AOMContext, x)
1058 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1059 static const AVOption options[] = {
1060  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 8, VE},
1061  { "auto-alt-ref", "Enable use of alternate reference "
1062  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1063  { "lag-in-frames", "Number of frames to look ahead at for "
1064  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1065  { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1066  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1067  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
1068  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode"},
1069  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode"},
1070  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode"},
1071  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode"},
1072  { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
1073  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
1074  { "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1075  { "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 },
1076  { "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1077  { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1078  { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1079  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1080  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1081  { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1082  { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1083  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1084  { "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
1085  { "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1086  { "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1087  { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1088  { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1089  { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1090  { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1091  { NULL },
1092 };
1093 
1094 static const AVCodecDefault defaults[] = {
1095  { "b", "0" },
1096  { "qmin", "-1" },
1097  { "qmax", "-1" },
1098  { "g", "-1" },
1099  { "keyint_min", "-1" },
1100  { NULL },
1101 };
1102 
1103 static const AVClass class_aom = {
1104  .class_name = "libaom-av1 encoder",
1105  .item_name = av_default_item_name,
1106  .option = options,
1107  .version = LIBAVUTIL_VERSION_INT,
1108 };
1109 
1111  .name = "libaom-av1",
1112  .long_name = NULL_IF_CONFIG_SMALL("libaom AV1"),
1113  .type = AVMEDIA_TYPE_VIDEO,
1114  .id = AV_CODEC_ID_AV1,
1115  .priv_data_size = sizeof(AOMContext),
1116  .init = av1_init,
1117  .encode2 = aom_encode,
1118  .close = aom_free,
1121  .priv_class = &class_aom,
1122  .defaults = defaults,
1123  .init_static_data = av1_init_static,
1124  .wrapper_name = "libaom",
1125 };
#define OFFSET(x)
Definition: libaomenc.c:1057
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:2749
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:1616
#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:1135
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2472
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:2201
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: avcodec.h:5764
int size
Definition: avcodec.h:1479
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:1776
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:1030
#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:2593
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:1059
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1050
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2899
AVCodec.
Definition: avcodec.h:3482
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:134
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1144
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:1689
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:81
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:1007
#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:211
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:1478
#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:1162
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:2585
#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:1510
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
Definition: libaomenc.c:784
#define VE
Definition: libaomenc.c:1058
#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:1043
int tile_rows
Definition: libaomenc.c:87
int qmax
maximum quantizer
Definition: avcodec.h:2415
#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:1646
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:3489
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:813
static void set_color_range(AVCodecContext *avctx)
Definition: libaomenc.c:330
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1484
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:2429
static const AVClass class_aom
Definition: libaomenc.c:1103
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2451
AVCodec ff_libaom_av1_encoder
Definition: libaomenc.c:1110
int refs
number of reference frames
Definition: avcodec.h:2154
struct FrameListData * coded_frame_list
Definition: libaomenc.c:66
static enum AVPixelFormat av1_pix_fmts_highbd[]
Definition: libaomenc.c:1030
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3503
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:875
#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:1739
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2900
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:185
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:888
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:872
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2180
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:1698
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:2825
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:1129
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:1566
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:1023
int qmin
minimum quantizer
Definition: avcodec.h:2408
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:1052
#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:2994
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2194
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2187
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:2042
int uniform_tiles
Definition: libaomenc.c:90
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:2992
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:2400
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:905
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:1761
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:967
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:1957
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:876
void * priv_data
Definition: avcodec.h:1593
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:1153
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:1477
#define av_freep(p)
static const AVCodecDefault defaults[]
Definition: libaomenc.c:1094
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:1455
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5792
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:1471
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:2993
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2444
int keyint_min
minimum GOP size
Definition: avcodec.h:2147