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;
96  int usage;
97 } AOMContext;
98 
99 static const char *const ctlidstr[] = {
100  [AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
101  [AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
102  [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
103  [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
104  [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
105  [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
106  [AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
107  [AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
108  [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
109  [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
110  [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
111  [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
112  [AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
113  [AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
114  [AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
115  [AV1E_SET_ENABLE_RESTORATION] = "AV1E_SET_ENABLE_RESTORATION",
116 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
117  [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
118 #endif
119 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
120  [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
121 #endif
122 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
123  [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
124 #endif
125 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
126  [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
127 #endif
128 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
129  [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
130 #endif
131 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
132  [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
133 #endif
134  [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
135 };
136 
137 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
138 {
139  AOMContext *ctx = avctx->priv_data;
140  const char *error = aom_codec_error(&ctx->encoder);
141  const char *detail = aom_codec_error_detail(&ctx->encoder);
142 
143  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
144  if (detail)
145  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
146 }
147 
149  const struct aom_codec_enc_cfg *cfg)
150 {
151  int width = -30;
152  int level = AV_LOG_DEBUG;
153 
154  av_log(avctx, level, "aom_codec_enc_cfg\n");
155  av_log(avctx, level, "generic settings\n"
156  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
157  " %*s%u\n %*s%u\n"
158  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
159  width, "g_usage:", cfg->g_usage,
160  width, "g_threads:", cfg->g_threads,
161  width, "g_profile:", cfg->g_profile,
162  width, "g_w:", cfg->g_w,
163  width, "g_h:", cfg->g_h,
164  width, "g_bit_depth:", cfg->g_bit_depth,
165  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
166  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
167  width, "g_error_resilient:", cfg->g_error_resilient,
168  width, "g_pass:", cfg->g_pass,
169  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
170  av_log(avctx, level, "rate control settings\n"
171  " %*s%u\n %*s%d\n %*s%p(%"SIZE_SPECIFIER")\n %*s%u\n",
172  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
173  width, "rc_end_usage:", cfg->rc_end_usage,
174  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
175  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
176  av_log(avctx, level, "quantizer settings\n"
177  " %*s%u\n %*s%u\n",
178  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
179  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
180  av_log(avctx, level, "bitrate tolerance\n"
181  " %*s%u\n %*s%u\n",
182  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
183  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
184  av_log(avctx, level, "decoder buffer model\n"
185  " %*s%u\n %*s%u\n %*s%u\n",
186  width, "rc_buf_sz:", cfg->rc_buf_sz,
187  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
188  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
189  av_log(avctx, level, "2 pass rate control settings\n"
190  " %*s%u\n %*s%u\n %*s%u\n",
191  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
192  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
193  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
194  av_log(avctx, level, "keyframing settings\n"
195  " %*s%d\n %*s%u\n %*s%u\n",
196  width, "kf_mode:", cfg->kf_mode,
197  width, "kf_min_dist:", cfg->kf_min_dist,
198  width, "kf_max_dist:", cfg->kf_max_dist);
199  av_log(avctx, level, "tile settings\n"
200  " %*s%d\n %*s%d\n",
201  width, "tile_width_count:", cfg->tile_width_count,
202  width, "tile_height_count:", cfg->tile_height_count);
203  av_log(avctx, level, "\n");
204 }
205 
206 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
207 {
208  struct FrameListData **p = list;
209 
210  while (*p)
211  p = &(*p)->next;
212  *p = cx_frame;
213  cx_frame->next = NULL;
214 }
215 
216 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
217 {
218  av_freep(&cx_frame->buf);
219  av_freep(&cx_frame);
220 }
221 
223 {
224  struct FrameListData *p = list;
225 
226  while (p) {
227  list = list->next;
228  free_coded_frame(p);
229  p = list;
230  }
231 }
232 
234 #ifdef UENUM1BYTE
235  aome_enc_control_id id,
236 #else
237  enum aome_enc_control_id id,
238 #endif
239  int val)
240 {
241  AOMContext *ctx = avctx->priv_data;
242  char buf[80];
243  int width = -30;
244  int res;
245 
246  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
247  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
248 
249  res = aom_codec_control(&ctx->encoder, id, val);
250  if (res != AOM_CODEC_OK) {
251  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
252  ctlidstr[id]);
253  log_encoder_error(avctx, buf);
254  return AVERROR(EINVAL);
255  }
256 
257  return 0;
258 }
259 
260 static av_cold int aom_free(AVCodecContext *avctx)
261 {
262  AOMContext *ctx = avctx->priv_data;
263 
264  aom_codec_destroy(&ctx->encoder);
265  av_freep(&ctx->twopass_stats.buf);
266  av_freep(&avctx->stats_out);
268  av_bsf_free(&ctx->bsf);
269  return 0;
270 }
271 
272 static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
273  struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
274  aom_img_fmt_t *img_fmt)
275 {
276  AOMContext av_unused *ctx = avctx->priv_data;
277  enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
278  switch (avctx->pix_fmt) {
279  case AV_PIX_FMT_YUV420P:
280  enccfg->g_profile = FF_PROFILE_AV1_MAIN;
281  *img_fmt = AOM_IMG_FMT_I420;
282  return 0;
283  case AV_PIX_FMT_YUV422P:
284  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
285  *img_fmt = AOM_IMG_FMT_I422;
286  return 0;
287  case AV_PIX_FMT_YUV444P:
288  enccfg->g_profile = FF_PROFILE_AV1_HIGH;
289  *img_fmt = AOM_IMG_FMT_I444;
290  return 0;
293  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
294  enccfg->g_bit_depth = enccfg->g_input_bit_depth =
295  avctx->pix_fmt == AV_PIX_FMT_YUV420P10 ? 10 : 12;
296  enccfg->g_profile =
297  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
298  *img_fmt = AOM_IMG_FMT_I42016;
299  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
300  return 0;
301  }
302  break;
305  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
306  enccfg->g_bit_depth = enccfg->g_input_bit_depth =
307  avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12;
308  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
309  *img_fmt = AOM_IMG_FMT_I42216;
310  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
311  return 0;
312  }
313  break;
316  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
317  enccfg->g_bit_depth = enccfg->g_input_bit_depth =
318  avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ? 10 : 12;
319  enccfg->g_profile =
320  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
321  *img_fmt = AOM_IMG_FMT_I44416;
322  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
323  return 0;
324  }
325  break;
326  default:
327  break;
328  }
329  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
330  return AVERROR_INVALIDDATA;
331 }
332 
333 static void set_color_range(AVCodecContext *avctx)
334 {
335  aom_color_range_t aom_cr;
336  switch (avctx->color_range) {
338  case AVCOL_RANGE_MPEG: aom_cr = AOM_CR_STUDIO_RANGE; break;
339  case AVCOL_RANGE_JPEG: aom_cr = AOM_CR_FULL_RANGE; break;
340  default:
341  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
342  avctx->color_range);
343  return;
344  }
345 
346  codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
347 }
348 
349 static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
350 {
351  int sb_dim = (dim + sb_size - 1) / sb_size;
352  int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
353  av_assert0(tile_dim > 0);
354  return (sb_dim + tile_dim - 1) / tile_dim;
355 }
356 
357 static int choose_tiling(AVCodecContext *avctx,
358  struct aom_codec_enc_cfg *enccfg)
359 {
360  AOMContext *ctx = avctx->priv_data;
361  int sb_128x128_possible, sb_size, sb_width, sb_height;
362  int uniform_rows, uniform_cols;
363  int uniform_64x64_possible, uniform_128x128_possible;
364  int tile_size, rounding, i;
365 
366  if (ctx->tile_cols_log2 >= 0)
367  ctx->tile_cols = 1 << ctx->tile_cols_log2;
368  if (ctx->tile_rows_log2 >= 0)
369  ctx->tile_rows = 1 << ctx->tile_rows_log2;
370 
371  if (ctx->tile_cols == 0) {
372  ctx->tile_cols = (avctx->width + AV1_MAX_TILE_WIDTH - 1) /
374  if (ctx->tile_cols > 1) {
375  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
376  "columns to fill width.\n", ctx->tile_cols);
377  }
378  }
379  av_assert0(ctx->tile_cols > 0);
380  if (ctx->tile_rows == 0) {
381  int max_tile_width =
382  FFALIGN((FFALIGN(avctx->width, 128) +
383  ctx->tile_cols - 1) / ctx->tile_cols, 128);
384  ctx->tile_rows =
385  (max_tile_width * FFALIGN(avctx->height, 128) +
387  if (ctx->tile_rows > 1) {
388  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
389  "rows to fill area.\n", ctx->tile_rows);
390  }
391  }
392  av_assert0(ctx->tile_rows > 0);
393 
394  if ((avctx->width + 63) / 64 < ctx->tile_cols ||
395  (avctx->height + 63) / 64 < ctx->tile_rows) {
396  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: frame not "
397  "large enough to fit specified tile arrangement.\n");
398  return AVERROR(EINVAL);
399  }
400  if (ctx->tile_cols > AV1_MAX_TILE_COLS ||
401  ctx->tile_rows > AV1_MAX_TILE_ROWS) {
402  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
403  "not allow more than %dx%d tiles.\n",
405  return AVERROR(EINVAL);
406  }
407  if (avctx->width / ctx->tile_cols > AV1_MAX_TILE_WIDTH) {
408  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
409  "not allow tiles of width greater than %d.\n",
411  return AVERROR(EINVAL);
412  }
413 
414  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
415 
416  if (ctx->tile_cols == 1 && ctx->tile_rows == 1) {
417  av_log(avctx, AV_LOG_DEBUG, "Using a single tile.\n");
418  return 0;
419  }
420 
421  sb_128x128_possible =
422  (avctx->width + 127) / 128 >= ctx->tile_cols &&
423  (avctx->height + 127) / 128 >= ctx->tile_rows;
424 
425  ctx->tile_cols_log2 = ctx->tile_cols == 1 ? 0 :
426  av_log2(ctx->tile_cols - 1) + 1;
427  ctx->tile_rows_log2 = ctx->tile_rows == 1 ? 0 :
428  av_log2(ctx->tile_rows - 1) + 1;
429 
430  uniform_cols = count_uniform_tiling(avctx->width,
431  64, ctx->tile_cols_log2);
432  uniform_rows = count_uniform_tiling(avctx->height,
433  64, ctx->tile_rows_log2);
434  av_log(avctx, AV_LOG_DEBUG, "Uniform with 64x64 superblocks "
435  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
436  uniform_64x64_possible = uniform_cols == ctx->tile_cols &&
437  uniform_rows == ctx->tile_rows;
438 
439  if (sb_128x128_possible) {
440  uniform_cols = count_uniform_tiling(avctx->width,
441  128, ctx->tile_cols_log2);
442  uniform_rows = count_uniform_tiling(avctx->height,
443  128, ctx->tile_rows_log2);
444  av_log(avctx, AV_LOG_DEBUG, "Uniform with 128x128 superblocks "
445  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
446  uniform_128x128_possible = uniform_cols == ctx->tile_cols &&
447  uniform_rows == ctx->tile_rows;
448  } else {
449  av_log(avctx, AV_LOG_DEBUG, "128x128 superblocks not possible.\n");
450  uniform_128x128_possible = 0;
451  }
452 
453  ctx->uniform_tiles = 1;
454  if (uniform_64x64_possible && uniform_128x128_possible) {
455  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with dynamic "
456  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
457  ctx->tile_cols_log2, ctx->tile_rows_log2);
458  return 0;
459  }
460  if (uniform_64x64_possible && !sb_128x128_possible) {
461  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 64x64 "
462  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
463  ctx->tile_cols_log2, ctx->tile_rows_log2);
464  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
465  return 0;
466  }
467  if (uniform_128x128_possible) {
468  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 128x128 "
469  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
470  ctx->tile_cols_log2, ctx->tile_rows_log2);
471  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
472  return 0;
473  }
474  ctx->uniform_tiles = 0;
475 
476  if (sb_128x128_possible) {
477  sb_size = 128;
478  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
479  } else {
480  sb_size = 64;
481  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
482  }
483  av_log(avctx, AV_LOG_DEBUG, "Using fixed tiling with %dx%d "
484  "superblocks (tile_cols = %d, tile_rows = %d).\n",
485  sb_size, sb_size, ctx->tile_cols, ctx->tile_rows);
486 
487  enccfg->tile_width_count = ctx->tile_cols;
488  enccfg->tile_height_count = ctx->tile_rows;
489 
490  sb_width = (avctx->width + sb_size - 1) / sb_size;
491  sb_height = (avctx->height + sb_size - 1) / sb_size;
492 
493  tile_size = sb_width / ctx->tile_cols;
494  rounding = sb_width % ctx->tile_cols;
495  for (i = 0; i < ctx->tile_cols; i++) {
496  enccfg->tile_widths[i] = tile_size +
497  (i < rounding / 2 ||
498  i > ctx->tile_cols - 1 - (rounding + 1) / 2);
499  }
500 
501  tile_size = sb_height / ctx->tile_rows;
502  rounding = sb_height % ctx->tile_rows;
503  for (i = 0; i < ctx->tile_rows; i++) {
504  enccfg->tile_heights[i] = tile_size +
505  (i < rounding / 2 ||
506  i > ctx->tile_rows - 1 - (rounding + 1) / 2);
507  }
508 
509  return 0;
510 }
511 
512 static av_cold int aom_init(AVCodecContext *avctx,
513  const struct aom_codec_iface *iface)
514 {
515  AOMContext *ctx = avctx->priv_data;
516  struct aom_codec_enc_cfg enccfg = { 0 };
517 #ifdef AOM_FRAME_IS_INTRAONLY
518  aom_codec_flags_t flags =
519  (avctx->flags & AV_CODEC_FLAG_PSNR) ? AOM_CODEC_USE_PSNR : 0;
520 #else
521  aom_codec_flags_t flags = 0;
522 #endif
523  AVCPBProperties *cpb_props;
524  int res;
525  aom_img_fmt_t img_fmt;
526  aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
527 
528  av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
529  av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
530 
531  if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
532  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
533  aom_codec_err_to_string(res));
534  return AVERROR(EINVAL);
535  }
536 
537  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
538  return AVERROR(EINVAL);
539 
540  if(!avctx->bit_rate)
541  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
542  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
543  return AVERROR(EINVAL);
544  }
545 
546  dump_enc_cfg(avctx, &enccfg);
547 
548  enccfg.g_w = avctx->width;
549  enccfg.g_h = avctx->height;
550  enccfg.g_timebase.num = avctx->time_base.num;
551  enccfg.g_timebase.den = avctx->time_base.den;
552  enccfg.g_threads =
553  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
554 
555  enccfg.g_usage = ctx->usage;
556 
557  if (ctx->lag_in_frames >= 0)
558  enccfg.g_lag_in_frames = ctx->lag_in_frames;
559 
560  if (avctx->flags & AV_CODEC_FLAG_PASS1)
561  enccfg.g_pass = AOM_RC_FIRST_PASS;
562  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
563  enccfg.g_pass = AOM_RC_LAST_PASS;
564  else
565  enccfg.g_pass = AOM_RC_ONE_PASS;
566 
567  if (avctx->rc_min_rate == avctx->rc_max_rate &&
568  avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
569  enccfg.rc_end_usage = AOM_CBR;
570  } else if (ctx->crf >= 0) {
571  enccfg.rc_end_usage = AOM_CQ;
572  if (!avctx->bit_rate)
573  enccfg.rc_end_usage = AOM_Q;
574  }
575 
576  if (avctx->bit_rate) {
577  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
579  } else if (enccfg.rc_end_usage != AOM_Q) {
580  enccfg.rc_end_usage = AOM_Q;
581  ctx->crf = 32;
582  av_log(avctx, AV_LOG_WARNING,
583  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
584  ctx->crf);
585  }
586 
587  if (avctx->qmin >= 0)
588  enccfg.rc_min_quantizer = avctx->qmin;
589  if (avctx->qmax >= 0)
590  enccfg.rc_max_quantizer = avctx->qmax;
591 
592  if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
593  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
594  av_log(avctx, AV_LOG_ERROR,
595  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
596  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
597  return AVERROR(EINVAL);
598  }
599  }
600 
601  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
602 
603  // 0-100 (0 => CBR, 100 => VBR)
604  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
605  if (ctx->minsection_pct >= 0)
606  enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
607  else if (avctx->bit_rate)
608  enccfg.rc_2pass_vbr_minsection_pct =
609  avctx->rc_min_rate * 100LL / avctx->bit_rate;
610  if (ctx->maxsection_pct >= 0)
611  enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
612  else if (avctx->rc_max_rate)
613  enccfg.rc_2pass_vbr_maxsection_pct =
614  avctx->rc_max_rate * 100LL / avctx->bit_rate;
615 
616  if (avctx->rc_buffer_size)
617  enccfg.rc_buf_sz =
618  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
619  if (avctx->rc_initial_buffer_occupancy)
620  enccfg.rc_buf_initial_sz =
621  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
622  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
623 
624  if (ctx->rc_undershoot_pct >= 0)
625  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
626  if (ctx->rc_overshoot_pct >= 0)
627  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
628 
629  // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
630  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
631  enccfg.kf_min_dist = avctx->keyint_min;
632  if (avctx->gop_size >= 0)
633  enccfg.kf_max_dist = avctx->gop_size;
634 
635  if (enccfg.g_pass == AOM_RC_FIRST_PASS)
636  enccfg.g_lag_in_frames = 0;
637  else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
638  int decode_size, ret;
639 
640  if (!avctx->stats_in) {
641  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
642  return AVERROR_INVALIDDATA;
643  }
644 
645  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
646  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
647  if (ret < 0) {
648  av_log(avctx, AV_LOG_ERROR,
649  "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
650  ctx->twopass_stats.sz);
651  ctx->twopass_stats.sz = 0;
652  return ret;
653  }
654  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
655  ctx->twopass_stats.sz);
656  if (decode_size < 0) {
657  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
658  return AVERROR_INVALIDDATA;
659  }
660 
661  ctx->twopass_stats.sz = decode_size;
662  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
663  }
664 
665  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
666  * complexity playback on low powered devices at the expense of encode
667  * quality. */
668  if (avctx->profile != FF_PROFILE_UNKNOWN)
669  enccfg.g_profile = avctx->profile;
670 
671  enccfg.g_error_resilient = ctx->error_resilient;
672 
673  res = choose_tiling(avctx, &enccfg);
674  if (res < 0)
675  return res;
676 
677  dump_enc_cfg(avctx, &enccfg);
678  /* Construct Encoder Context */
679  res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
680  if (res != AOM_CODEC_OK) {
681  log_encoder_error(avctx, "Failed to initialize encoder");
682  return AVERROR(EINVAL);
683  }
684 
685  // codec control failures are currently treated only as warnings
686  av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
687  codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
688  if (ctx->auto_alt_ref >= 0)
689  codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
690  if (ctx->arnr_max_frames >= 0)
691  codecctl_int(avctx, AOME_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
692  if (ctx->arnr_strength >= 0)
693  codecctl_int(avctx, AOME_SET_ARNR_STRENGTH, ctx->arnr_strength);
694  if (ctx->enable_cdef >= 0)
695  codecctl_int(avctx, AV1E_SET_ENABLE_CDEF, ctx->enable_cdef);
696  if (ctx->enable_restoration >= 0)
697  codecctl_int(avctx, AV1E_SET_ENABLE_RESTORATION, ctx->enable_restoration);
698 
699  codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
700  if (ctx->crf >= 0)
701  codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
702 
703  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
704  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
705  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
706  if (ctx->aq_mode >= 0)
707  codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
708  if (ctx->frame_parallel >= 0)
709  codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
710  set_color_range(avctx);
711 
712  codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
713  if (ctx->uniform_tiles) {
714  codecctl_int(avctx, AV1E_SET_TILE_COLUMNS, ctx->tile_cols_log2);
715  codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
716  }
717 
718 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
719  if (ctx->denoise_noise_level >= 0)
720  codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
721 #endif
722 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
723  if (ctx->denoise_block_size >= 0)
724  codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
725 #endif
726 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
727  if (ctx->enable_global_motion >= 0)
728  codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
729 #endif
730 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
731  if (avctx->refs >= 3) {
732  codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
733  }
734 #endif
735 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
736  if (ctx->row_mt >= 0)
737  codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
738 #endif
739 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
740  if (ctx->enable_intrabc >= 0)
741  codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
742 #endif
743 
744  // provide dummy value to initialize wrapper, values will be updated each _encode()
745  aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
746  (unsigned char*)1);
747 
748  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
749  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
750 
751  cpb_props = ff_add_cpb_side_data(avctx);
752  if (!cpb_props)
753  return AVERROR(ENOMEM);
754 
755  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
756  const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
757  int ret;
758 
759  if (!filter) {
760  av_log(avctx, AV_LOG_ERROR, "extract_extradata bitstream filter "
761  "not found. This is a bug, please report it.\n");
762  return AVERROR_BUG;
763  }
764  ret = av_bsf_alloc(filter, &ctx->bsf);
765  if (ret < 0)
766  return ret;
767 
768  ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx);
769  if (ret < 0)
770  return ret;
771 
772  ret = av_bsf_init(ctx->bsf);
773  if (ret < 0)
774  return ret;
775  }
776 
777  if (enccfg.rc_end_usage == AOM_CBR ||
778  enccfg.g_pass != AOM_RC_ONE_PASS) {
779  cpb_props->max_bitrate = avctx->rc_max_rate;
780  cpb_props->min_bitrate = avctx->rc_min_rate;
781  cpb_props->avg_bitrate = avctx->bit_rate;
782  }
783  cpb_props->buffer_size = avctx->rc_buffer_size;
784 
785  return 0;
786 }
787 
788 static inline void cx_pktcpy(AOMContext *ctx,
789  struct FrameListData *dst,
790  const struct aom_codec_cx_pkt *src)
791 {
792  dst->pts = src->data.frame.pts;
793  dst->duration = src->data.frame.duration;
794  dst->flags = src->data.frame.flags;
795  dst->sz = src->data.frame.sz;
796  dst->buf = src->data.frame.buf;
797 #ifdef AOM_FRAME_IS_INTRAONLY
798  dst->have_sse = 0;
799  dst->frame_number = ++ctx->frame_number;
800  dst->have_sse = ctx->have_sse;
801  if (ctx->have_sse) {
802  /* associate last-seen SSE to the frame. */
803  /* Transfers ownership from ctx to dst. */
804  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
805  ctx->have_sse = 0;
806  }
807 #endif
808 }
809 
810 /**
811  * Store coded frame information in format suitable for return from encode2().
812  *
813  * Write information from @a cx_frame to @a pkt
814  * @return packet data size on success
815  * @return a negative AVERROR on error
816  */
817 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
818  AVPacket *pkt)
819 {
820  AOMContext *ctx = avctx->priv_data;
821  int av_unused pict_type;
822  int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
823  if (ret < 0) {
824  av_log(avctx, AV_LOG_ERROR,
825  "Error getting output packet of size %"SIZE_SPECIFIER".\n", cx_frame->sz);
826  return ret;
827  }
828  memcpy(pkt->data, cx_frame->buf, pkt->size);
829  pkt->pts = pkt->dts = cx_frame->pts;
830 
831  if (!!(cx_frame->flags & AOM_FRAME_IS_KEY)) {
832  pkt->flags |= AV_PKT_FLAG_KEY;
833 #ifdef AOM_FRAME_IS_INTRAONLY
834  pict_type = AV_PICTURE_TYPE_I;
835  } else if (cx_frame->flags & AOM_FRAME_IS_INTRAONLY) {
836  pict_type = AV_PICTURE_TYPE_I;
837  } else {
838  pict_type = AV_PICTURE_TYPE_P;
839  }
840 
841  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
842  cx_frame->have_sse ? 3 : 0, pict_type);
843 
844  if (cx_frame->have_sse) {
845  int i;
846  for (i = 0; i < 3; ++i) {
847  avctx->error[i] += cx_frame->sse[i + 1];
848  }
849  cx_frame->have_sse = 0;
850 #endif
851  }
852 
853  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
854  ret = av_bsf_send_packet(ctx->bsf, pkt);
855  if (ret < 0) {
856  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
857  "failed to send input packet\n");
858  return ret;
859  }
860  ret = av_bsf_receive_packet(ctx->bsf, pkt);
861 
862  if (ret < 0) {
863  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
864  "failed to receive output packet\n");
865  return ret;
866  }
867  }
868  return pkt->size;
869 }
870 
871 /**
872  * Queue multiple output frames from the encoder, returning the front-most.
873  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
874  * the frame queue. Return the head frame if available.
875  * @return Stored frame size
876  * @return AVERROR(EINVAL) on output size error
877  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
878  */
879 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
880 {
881  AOMContext *ctx = avctx->priv_data;
882  const struct aom_codec_cx_pkt *pkt;
883  const void *iter = NULL;
884  int size = 0;
885 
886  if (ctx->coded_frame_list) {
887  struct FrameListData *cx_frame = ctx->coded_frame_list;
888  /* return the leading frame if we've already begun queueing */
889  size = storeframe(avctx, cx_frame, pkt_out);
890  if (size < 0)
891  return size;
892  ctx->coded_frame_list = cx_frame->next;
893  free_coded_frame(cx_frame);
894  }
895 
896  /* consume all available output from the encoder before returning. buffers
897  * are only good through the next aom_codec call */
898  while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
899  switch (pkt->kind) {
900  case AOM_CODEC_CX_FRAME_PKT:
901  if (!size) {
902  struct FrameListData cx_frame;
903 
904  /* avoid storing the frame when the list is empty and we haven't yet
905  * provided a frame for output */
907  cx_pktcpy(ctx, &cx_frame, pkt);
908  size = storeframe(avctx, &cx_frame, pkt_out);
909  if (size < 0)
910  return size;
911  } else {
912  struct FrameListData *cx_frame =
913  av_malloc(sizeof(struct FrameListData));
914 
915  if (!cx_frame) {
916  av_log(avctx, AV_LOG_ERROR,
917  "Frame queue element alloc failed\n");
918  return AVERROR(ENOMEM);
919  }
920  cx_pktcpy(ctx, cx_frame, pkt);
921  cx_frame->buf = av_malloc(cx_frame->sz);
922 
923  if (!cx_frame->buf) {
924  av_log(avctx, AV_LOG_ERROR,
925  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
926  cx_frame->sz);
927  av_freep(&cx_frame);
928  return AVERROR(ENOMEM);
929  }
930  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
931  coded_frame_add(&ctx->coded_frame_list, cx_frame);
932  }
933  break;
934  case AOM_CODEC_STATS_PKT:
935  {
936  struct aom_fixed_buf *stats = &ctx->twopass_stats;
937  int err;
938  if ((err = av_reallocp(&stats->buf,
939  stats->sz +
940  pkt->data.twopass_stats.sz)) < 0) {
941  stats->sz = 0;
942  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
943  return err;
944  }
945  memcpy((uint8_t *)stats->buf + stats->sz,
946  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
947  stats->sz += pkt->data.twopass_stats.sz;
948  break;
949  }
950 #ifdef AOM_FRAME_IS_INTRAONLY
951  case AOM_CODEC_PSNR_PKT:
952  {
953  av_assert0(!ctx->have_sse);
954  ctx->sse[0] = pkt->data.psnr.sse[0];
955  ctx->sse[1] = pkt->data.psnr.sse[1];
956  ctx->sse[2] = pkt->data.psnr.sse[2];
957  ctx->sse[3] = pkt->data.psnr.sse[3];
958  ctx->have_sse = 1;
959  break;
960  }
961 #endif
962  case AOM_CODEC_CUSTOM_PKT:
963  // ignore unsupported/unrecognized packet types
964  break;
965  }
966  }
967 
968  return size;
969 }
970 
971 static int aom_encode(AVCodecContext *avctx, AVPacket *pkt,
972  const AVFrame *frame, int *got_packet)
973 {
974  AOMContext *ctx = avctx->priv_data;
975  struct aom_image *rawimg = NULL;
976  int64_t timestamp = 0;
977  int res, coded_size;
978  aom_enc_frame_flags_t flags = 0;
979 
980  if (frame) {
981  rawimg = &ctx->rawimg;
982  rawimg->planes[AOM_PLANE_Y] = frame->data[0];
983  rawimg->planes[AOM_PLANE_U] = frame->data[1];
984  rawimg->planes[AOM_PLANE_V] = frame->data[2];
985  rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
986  rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
987  rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
988  timestamp = frame->pts;
989  switch (frame->color_range) {
990  case AVCOL_RANGE_MPEG:
991  rawimg->range = AOM_CR_STUDIO_RANGE;
992  break;
993  case AVCOL_RANGE_JPEG:
994  rawimg->range = AOM_CR_FULL_RANGE;
995  break;
996  }
997 
998  if (frame->pict_type == AV_PICTURE_TYPE_I)
999  flags |= AOM_EFLAG_FORCE_KF;
1000  }
1001 
1002  res = aom_codec_encode(&ctx->encoder, rawimg, timestamp,
1003  avctx->ticks_per_frame, flags);
1004  if (res != AOM_CODEC_OK) {
1005  log_encoder_error(avctx, "Error encoding frame");
1006  return AVERROR_INVALIDDATA;
1007  }
1008  coded_size = queue_frames(avctx, pkt);
1009 
1010  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1011  size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1012 
1013  avctx->stats_out = av_malloc(b64_size);
1014  if (!avctx->stats_out) {
1015  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1016  b64_size);
1017  return AVERROR(ENOMEM);
1018  }
1019  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1020  ctx->twopass_stats.sz);
1021  }
1022 
1023  *got_packet = !!coded_size;
1024  return 0;
1025 }
1026 
1027 static const enum AVPixelFormat av1_pix_fmts[] = {
1032 };
1033 
1034 static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
1045 };
1046 
1047 static av_cold void av1_init_static(AVCodec *codec)
1048 {
1049  aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1050  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1051  codec->pix_fmts = av1_pix_fmts_highbd;
1052  else
1053  codec->pix_fmts = av1_pix_fmts;
1054 }
1055 
1056 static av_cold int av1_init(AVCodecContext *avctx)
1057 {
1058  return aom_init(avctx, aom_codec_av1_cx());
1059 }
1060 
1061 #define OFFSET(x) offsetof(AOMContext, x)
1062 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1063 static const AVOption options[] = {
1064  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 8, VE},
1065  { "auto-alt-ref", "Enable use of alternate reference "
1066  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1067  { "lag-in-frames", "Number of frames to look ahead at for "
1068  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1069  { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1070  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1071  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
1072  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode"},
1073  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode"},
1074  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode"},
1075  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode"},
1076  { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
1077  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
1078  { "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1079  { "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 },
1080  { "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1081  { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1082  { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1083  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1084  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1085  { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1086  { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1087  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1088  { "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
1089  { "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1090  { "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1091  { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1092  { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1093  { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1094  { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1095  { "enable-restoration", "Enable Loop Restoration filtering", OFFSET(enable_restoration), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1096  { "usage", "Quality and compression efficiency vs speed tradeof", OFFSET(usage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, "usage"},
1097  { "good", "Good quality", 0, AV_OPT_TYPE_CONST, {.i64 = 0 /* AOM_USAGE_GOOD_QUALITY */}, 0, 0, VE, "usage"},
1098  { "realtime", "Realtime encoding", 0, AV_OPT_TYPE_CONST, {.i64 = 1 /* AOM_USAGE_REALTIME */}, 0, 0, VE, "usage"},
1099  { NULL },
1100 };
1101 
1102 static const AVCodecDefault defaults[] = {
1103  { "b", "0" },
1104  { "qmin", "-1" },
1105  { "qmax", "-1" },
1106  { "g", "-1" },
1107  { "keyint_min", "-1" },
1108  { NULL },
1109 };
1110 
1111 static const AVClass class_aom = {
1112  .class_name = "libaom-av1 encoder",
1113  .item_name = av_default_item_name,
1114  .option = options,
1115  .version = LIBAVUTIL_VERSION_INT,
1116 };
1117 
1119  .name = "libaom-av1",
1120  .long_name = NULL_IF_CONFIG_SMALL("libaom AV1"),
1121  .type = AVMEDIA_TYPE_VIDEO,
1122  .id = AV_CODEC_ID_AV1,
1123  .priv_data_size = sizeof(AOMContext),
1124  .init = av1_init,
1125  .encode2 = aom_encode,
1126  .close = aom_free,
1129  .priv_class = &class_aom,
1130  .defaults = defaults,
1131  .init_static_data = av1_init_static,
1132  .wrapper_name = "libaom",
1133 };
#define OFFSET(x)
Definition: libaomenc.c:1061
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
ptrdiff_t const GLvoid GLenum usage
Definition: opengl_enc.c:100
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:723
int av_cpu_count(void)
Definition: cpu.c:267
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:2804
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:1671
#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:1164
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2527
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
Definition: libaomenc.c:512
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2256
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: avcodec.h:5843
int size
Definition: avcodec.h:1534
void * buf
compressed data buffer
Definition: libaomenc.c:47
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:1831
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:1047
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2648
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:1063
static void error(const char *err)
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1067
int profile
profile
Definition: avcodec.h:2954
AVCodec.
Definition: avcodec.h:3555
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:139
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1173
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:1744
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:86
int tile_rows_log2
Definition: libaomenc.c:88
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
Definition: libaomenc.c:357
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:1024
#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:222
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:219
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
int usage
Definition: libaomenc.c:96
struct aom_image rawimg
Definition: libaomenc.c:64
uint8_t * data
Definition: avcodec.h:1533
#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:233
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1191
ptrdiff_t size
Definition: opengl_enc.c:100
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2640
#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:1565
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
Definition: libaomenc.c:788
#define VE
Definition: libaomenc.c:1062
#define src
Definition: vp8dsp.c:254
#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:1047
int tile_rows
Definition: libaomenc.c:87
int qmax
maximum quantizer
Definition: avcodec.h:2470
#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:1701
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:3562
static av_always_inline av_const double round(double x)
Definition: libm.h:444
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
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:817
static void set_color_range(AVCodecContext *avctx)
Definition: libaomenc.c:333
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
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:2484
static const AVClass class_aom
Definition: libaomenc.c:1111
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2506
AVCodec ff_libaom_av1_encoder
Definition: libaomenc.c:1118
int refs
number of reference frames
Definition: avcodec.h:2209
struct FrameListData * coded_frame_list
Definition: libaomenc.c:66
static enum AVPixelFormat av1_pix_fmts_highbd[]
Definition: libaomenc.c:1034
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3576
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:879
#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:1794
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2955
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:192
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libaomenc.c:216
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:905
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:889
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2235
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
Definition: libaomenc.c:349
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:1753
static const char *const ctlidstr[]
Definition: libaomenc.c:99
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
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:2880
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
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:272
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1158
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:1621
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:1027
int qmin
minimum quantizer
Definition: avcodec.h:2463
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:1056
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libaomenc.c:206
Describe the class of an AVClass context structure.
Definition: log.h:67
static const AVProfile profiles[]
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:3049
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2249
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2242
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:2069
int uniform_tiles
Definition: libaomenc.c:90
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:3047
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:148
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2455
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:398
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:209
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:922
AVBSFContext * bsf
Definition: libaomenc.c:62
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:534
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1816
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:137
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:971
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:1979
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:893
void * priv_data
Definition: avcodec.h:1648
int enable_restoration
Definition: libaomenc.c:95
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:1182
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:1532
#define av_freep(p)
static const AVCodecDefault defaults[]
Definition: libaomenc.c:1102
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
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: avcodec.h:1510
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5871
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:1526
static av_cold int aom_free(AVCodecContext *avctx)
Definition: libaomenc.c:260
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:3048
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2499
int keyint_min
minimum GOP size
Definition: avcodec.h:2202