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 "packet_internal.h"
41 #include "profiles.h"
42 
43 /*
44  * Portion of struct aom_codec_cx_pkt from aom_encoder.h.
45  * One encoded frame returned from the library.
46  */
47 struct FrameListData {
48  void *buf; /**< compressed data buffer */
49  size_t sz; /**< length of compressed data */
50  int64_t pts; /**< time stamp to show frame
51  (in timebase units) */
52  unsigned long duration; /**< duration to show frame
53  (in timebase units) */
54  uint32_t flags; /**< flags for this frame */
55  uint64_t sse[4];
56  int have_sse; /**< true if we have pending sse[] */
57  uint64_t frame_number;
59 };
60 
61 typedef struct AOMEncoderContext {
62  AVClass *class;
64  struct aom_codec_ctx encoder;
65  struct aom_image rawimg;
66  struct aom_fixed_buf twopass_stats;
68  int cpu_used;
72  int aq_mode;
75  int crf;
80  uint64_t sse[4];
81  int have_sse; /**< true if we have pending sse[] */
82  uint64_t frame_number;
90  aom_superblock_size_t superblock_size;
92  int row_mt;
97  int usage;
98  int tune;
128 } AOMContext;
129 
130 static const char *const ctlidstr[] = {
131  [AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
132  [AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
133  [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
134  [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
135  [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
136  [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
137  [AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
138  [AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
139  [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
140  [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
141  [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
142  [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
143  [AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
144  [AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
145  [AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
146  [AV1E_SET_ENABLE_RESTORATION] = "AV1E_SET_ENABLE_RESTORATION",
147 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
148  [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
149 #endif
150 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
151  [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
152 #endif
153 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
154  [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
155 #endif
156 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
157  [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
158 #endif
159 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
160  [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
161 #endif
162 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
163  [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
164 #endif
165  [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
166  [AOME_SET_TUNING] = "AOME_SET_TUNING",
167 #if AOM_ENCODER_ABI_VERSION >= 22
168  [AV1E_SET_ENABLE_1TO4_PARTITIONS] = "AV1E_SET_ENABLE_1TO4_PARTITIONS",
169  [AV1E_SET_ENABLE_AB_PARTITIONS] = "AV1E_SET_ENABLE_AB_PARTITIONS",
170  [AV1E_SET_ENABLE_RECT_PARTITIONS] = "AV1E_SET_ENABLE_RECT_PARTITIONS",
171  [AV1E_SET_ENABLE_ANGLE_DELTA] = "AV1E_SET_ENABLE_ANGLE_DELTA",
172  [AV1E_SET_ENABLE_CFL_INTRA] = "AV1E_SET_ENABLE_CFL_INTRA",
173  [AV1E_SET_ENABLE_FILTER_INTRA] = "AV1E_SET_ENABLE_FILTER_INTRA",
174  [AV1E_SET_ENABLE_INTRA_EDGE_FILTER] = "AV1E_SET_ENABLE_INTRA_EDGE_FILTER",
175  [AV1E_SET_ENABLE_PAETH_INTRA] = "AV1E_SET_ENABLE_PAETH_INTRA",
176  [AV1E_SET_ENABLE_SMOOTH_INTRA] = "AV1E_SET_ENABLE_SMOOTH_INTRA",
177  [AV1E_SET_ENABLE_PALETTE] = "AV1E_SET_ENABLE_PALETTE",
178  [AV1E_SET_ENABLE_FLIP_IDTX] = "AV1E_SET_ENABLE_FLIP_IDTX",
179  [AV1E_SET_ENABLE_TX64] = "AV1E_SET_ENABLE_TX64",
180  [AV1E_SET_INTRA_DCT_ONLY] = "AV1E_SET_INTRA_DCT_ONLY",
181  [AV1E_SET_INTER_DCT_ONLY] = "AV1E_SET_INTER_DCT_ONLY",
182  [AV1E_SET_INTRA_DEFAULT_TX_ONLY] = "AV1E_SET_INTRA_DEFAULT_TX_ONLY",
183  [AV1E_SET_REDUCED_TX_TYPE_SET] = "AV1E_SET_REDUCED_TX_TYPE_SET",
184  [AV1E_SET_ENABLE_DIFF_WTD_COMP] = "AV1E_SET_ENABLE_DIFF_WTD_COMP",
185  [AV1E_SET_ENABLE_DIST_WTD_COMP] = "AV1E_SET_ENABLE_DIST_WTD_COMP",
186  [AV1E_SET_ENABLE_DUAL_FILTER] = "AV1E_SET_ENABLE_DUAL_FILTER",
187  [AV1E_SET_ENABLE_INTERINTER_WEDGE] = "AV1E_SET_ENABLE_INTERINTER_WEDGE",
188  [AV1E_SET_ENABLE_INTERINTRA_WEDGE] = "AV1E_SET_ENABLE_INTERINTRA_WEDGE",
189  [AV1E_SET_ENABLE_MASKED_COMP] = "AV1E_SET_ENABLE_MASKED_COMP",
190  [AV1E_SET_ENABLE_INTERINTRA_COMP] = "AV1E_SET_ENABLE_INTERINTRA_COMP",
191  [AV1E_SET_ENABLE_OBMC] = "AV1E_SET_ENABLE_OBMC",
192  [AV1E_SET_ENABLE_ONESIDED_COMP] = "AV1E_SET_ENABLE_ONESIDED_COMP",
193  [AV1E_SET_REDUCED_REFERENCE_SET] = "AV1E_SET_REDUCED_REFERENCE_SET",
194  [AV1E_SET_ENABLE_SMOOTH_INTERINTRA] = "AV1E_SET_ENABLE_SMOOTH_INTERINTRA",
195  [AV1E_SET_ENABLE_REF_FRAME_MVS] = "AV1E_SET_ENABLE_REF_FRAME_MVS",
196 #endif
197 };
198 
199 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
200 {
201  AOMContext *ctx = avctx->priv_data;
202  const char *error = aom_codec_error(&ctx->encoder);
203  const char *detail = aom_codec_error_detail(&ctx->encoder);
204 
205  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
206  if (detail)
207  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
208 }
209 
211  const struct aom_codec_enc_cfg *cfg)
212 {
213  int width = -30;
214  int level = AV_LOG_DEBUG;
215 
216  av_log(avctx, level, "aom_codec_enc_cfg\n");
217  av_log(avctx, level, "generic settings\n"
218  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
219  " %*s%u\n %*s%u\n"
220  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
221  width, "g_usage:", cfg->g_usage,
222  width, "g_threads:", cfg->g_threads,
223  width, "g_profile:", cfg->g_profile,
224  width, "g_w:", cfg->g_w,
225  width, "g_h:", cfg->g_h,
226  width, "g_bit_depth:", cfg->g_bit_depth,
227  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
228  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
229  width, "g_error_resilient:", cfg->g_error_resilient,
230  width, "g_pass:", cfg->g_pass,
231  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
232  av_log(avctx, level, "rate control settings\n"
233  " %*s%u\n %*s%d\n %*s%p(%"SIZE_SPECIFIER")\n %*s%u\n",
234  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
235  width, "rc_end_usage:", cfg->rc_end_usage,
236  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
237  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
238  av_log(avctx, level, "quantizer settings\n"
239  " %*s%u\n %*s%u\n",
240  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
241  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
242  av_log(avctx, level, "bitrate tolerance\n"
243  " %*s%u\n %*s%u\n",
244  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
245  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
246  av_log(avctx, level, "decoder buffer model\n"
247  " %*s%u\n %*s%u\n %*s%u\n",
248  width, "rc_buf_sz:", cfg->rc_buf_sz,
249  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
250  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
251  av_log(avctx, level, "2 pass rate control settings\n"
252  " %*s%u\n %*s%u\n %*s%u\n",
253  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
254  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
255  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
256  av_log(avctx, level, "keyframing settings\n"
257  " %*s%d\n %*s%u\n %*s%u\n",
258  width, "kf_mode:", cfg->kf_mode,
259  width, "kf_min_dist:", cfg->kf_min_dist,
260  width, "kf_max_dist:", cfg->kf_max_dist);
261  av_log(avctx, level, "tile settings\n"
262  " %*s%d\n %*s%d\n",
263  width, "tile_width_count:", cfg->tile_width_count,
264  width, "tile_height_count:", cfg->tile_height_count);
265  av_log(avctx, level, "\n");
266 }
267 
268 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
269 {
270  struct FrameListData **p = list;
271 
272  while (*p)
273  p = &(*p)->next;
274  *p = cx_frame;
275  cx_frame->next = NULL;
276 }
277 
278 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
279 {
280  av_freep(&cx_frame->buf);
281  av_freep(&cx_frame);
282 }
283 
285 {
286  struct FrameListData *p = list;
287 
288  while (p) {
289  list = list->next;
290  free_coded_frame(p);
291  p = list;
292  }
293 }
294 
296 #ifdef UENUM1BYTE
297  aome_enc_control_id id,
298 #else
299  enum aome_enc_control_id id,
300 #endif
301  int val)
302 {
303  AOMContext *ctx = avctx->priv_data;
304  char buf[80];
305  int width = -30;
306  int res;
307 
308  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
309  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
310 
311  res = aom_codec_control(&ctx->encoder, id, val);
312  if (res != AOM_CODEC_OK) {
313  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
314  ctlidstr[id]);
315  log_encoder_error(avctx, buf);
316  return AVERROR(EINVAL);
317  }
318 
319  return 0;
320 }
321 
322 static av_cold int aom_free(AVCodecContext *avctx)
323 {
324  AOMContext *ctx = avctx->priv_data;
325 
326  aom_codec_destroy(&ctx->encoder);
327  av_freep(&ctx->twopass_stats.buf);
328  av_freep(&avctx->stats_out);
329  free_frame_list(ctx->coded_frame_list);
330  av_bsf_free(&ctx->bsf);
331  return 0;
332 }
333 
334 static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
335  struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
336  aom_img_fmt_t *img_fmt)
337 {
338  AOMContext av_unused *ctx = avctx->priv_data;
340  enccfg->g_bit_depth = enccfg->g_input_bit_depth = desc->comp[0].depth;
341  switch (avctx->pix_fmt) {
342  case AV_PIX_FMT_GRAY8:
343  enccfg->monochrome = 1;
344  /* Fall-through */
345  case AV_PIX_FMT_YUV420P:
346  enccfg->g_profile = FF_PROFILE_AV1_MAIN;
347  *img_fmt = AOM_IMG_FMT_I420;
348  return 0;
349  case AV_PIX_FMT_YUV422P:
350  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
351  *img_fmt = AOM_IMG_FMT_I422;
352  return 0;
353  case AV_PIX_FMT_YUV444P:
354  case AV_PIX_FMT_GBRP:
355  enccfg->g_profile = FF_PROFILE_AV1_HIGH;
356  *img_fmt = AOM_IMG_FMT_I444;
357  return 0;
358  case AV_PIX_FMT_GRAY10:
359  case AV_PIX_FMT_GRAY12:
360  enccfg->monochrome = 1;
361  /* Fall-through */
364  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
365  enccfg->g_profile =
366  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
367  *img_fmt = AOM_IMG_FMT_I42016;
368  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
369  return 0;
370  }
371  break;
374  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
375  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
376  *img_fmt = AOM_IMG_FMT_I42216;
377  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
378  return 0;
379  }
380  break;
383  case AV_PIX_FMT_GBRP10:
384  case AV_PIX_FMT_GBRP12:
385  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
386  enccfg->g_profile =
387  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
388  *img_fmt = AOM_IMG_FMT_I44416;
389  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
390  return 0;
391  }
392  break;
393  default:
394  break;
395  }
396  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
397  return AVERROR_INVALIDDATA;
398 }
399 
400 static void set_color_range(AVCodecContext *avctx)
401 {
402  aom_color_range_t aom_cr;
403  switch (avctx->color_range) {
405  case AVCOL_RANGE_MPEG: aom_cr = AOM_CR_STUDIO_RANGE; break;
406  case AVCOL_RANGE_JPEG: aom_cr = AOM_CR_FULL_RANGE; break;
407  default:
408  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
409  avctx->color_range);
410  return;
411  }
412 
413  codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
414 }
415 
416 static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
417 {
418  int sb_dim = (dim + sb_size - 1) / sb_size;
419  int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
420  av_assert0(tile_dim > 0);
421  return (sb_dim + tile_dim - 1) / tile_dim;
422 }
423 
424 static int choose_tiling(AVCodecContext *avctx,
425  struct aom_codec_enc_cfg *enccfg)
426 {
427  AOMContext *ctx = avctx->priv_data;
428  int sb_128x128_possible, sb_size, sb_width, sb_height;
429  int uniform_rows, uniform_cols;
430  int uniform_64x64_possible, uniform_128x128_possible;
431  int tile_size, rounding, i;
432 
433  if (ctx->tile_cols_log2 >= 0)
434  ctx->tile_cols = 1 << ctx->tile_cols_log2;
435  if (ctx->tile_rows_log2 >= 0)
436  ctx->tile_rows = 1 << ctx->tile_rows_log2;
437 
438  if (ctx->tile_cols == 0) {
439  ctx->tile_cols = (avctx->width + AV1_MAX_TILE_WIDTH - 1) /
441  if (ctx->tile_cols > 1) {
442  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
443  "columns to fill width.\n", ctx->tile_cols);
444  }
445  }
446  av_assert0(ctx->tile_cols > 0);
447  if (ctx->tile_rows == 0) {
448  int max_tile_width =
449  FFALIGN((FFALIGN(avctx->width, 128) +
450  ctx->tile_cols - 1) / ctx->tile_cols, 128);
451  ctx->tile_rows =
452  (max_tile_width * FFALIGN(avctx->height, 128) +
454  if (ctx->tile_rows > 1) {
455  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
456  "rows to fill area.\n", ctx->tile_rows);
457  }
458  }
459  av_assert0(ctx->tile_rows > 0);
460 
461  if ((avctx->width + 63) / 64 < ctx->tile_cols ||
462  (avctx->height + 63) / 64 < ctx->tile_rows) {
463  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: frame not "
464  "large enough to fit specified tile arrangement.\n");
465  return AVERROR(EINVAL);
466  }
467  if (ctx->tile_cols > AV1_MAX_TILE_COLS ||
468  ctx->tile_rows > AV1_MAX_TILE_ROWS) {
469  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
470  "not allow more than %dx%d tiles.\n",
472  return AVERROR(EINVAL);
473  }
474  if (avctx->width / ctx->tile_cols > AV1_MAX_TILE_WIDTH) {
475  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
476  "not allow tiles of width greater than %d.\n",
478  return AVERROR(EINVAL);
479  }
480 
481  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
482 
483  if (ctx->tile_cols == 1 && ctx->tile_rows == 1) {
484  av_log(avctx, AV_LOG_DEBUG, "Using a single tile.\n");
485  return 0;
486  }
487 
488  sb_128x128_possible =
489  (avctx->width + 127) / 128 >= ctx->tile_cols &&
490  (avctx->height + 127) / 128 >= ctx->tile_rows;
491 
492  ctx->tile_cols_log2 = ctx->tile_cols == 1 ? 0 :
493  av_log2(ctx->tile_cols - 1) + 1;
494  ctx->tile_rows_log2 = ctx->tile_rows == 1 ? 0 :
495  av_log2(ctx->tile_rows - 1) + 1;
496 
497  uniform_cols = count_uniform_tiling(avctx->width,
498  64, ctx->tile_cols_log2);
499  uniform_rows = count_uniform_tiling(avctx->height,
500  64, ctx->tile_rows_log2);
501  av_log(avctx, AV_LOG_DEBUG, "Uniform with 64x64 superblocks "
502  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
503  uniform_64x64_possible = uniform_cols == ctx->tile_cols &&
504  uniform_rows == ctx->tile_rows;
505 
506  if (sb_128x128_possible) {
507  uniform_cols = count_uniform_tiling(avctx->width,
508  128, ctx->tile_cols_log2);
509  uniform_rows = count_uniform_tiling(avctx->height,
510  128, ctx->tile_rows_log2);
511  av_log(avctx, AV_LOG_DEBUG, "Uniform with 128x128 superblocks "
512  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
513  uniform_128x128_possible = uniform_cols == ctx->tile_cols &&
514  uniform_rows == ctx->tile_rows;
515  } else {
516  av_log(avctx, AV_LOG_DEBUG, "128x128 superblocks not possible.\n");
517  uniform_128x128_possible = 0;
518  }
519 
520  ctx->uniform_tiles = 1;
521  if (uniform_64x64_possible && uniform_128x128_possible) {
522  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with dynamic "
523  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
524  ctx->tile_cols_log2, ctx->tile_rows_log2);
525  return 0;
526  }
527  if (uniform_64x64_possible && !sb_128x128_possible) {
528  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 64x64 "
529  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
530  ctx->tile_cols_log2, ctx->tile_rows_log2);
531  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
532  return 0;
533  }
534  if (uniform_128x128_possible) {
535  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 128x128 "
536  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
537  ctx->tile_cols_log2, ctx->tile_rows_log2);
538  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
539  return 0;
540  }
541  ctx->uniform_tiles = 0;
542 
543  if (sb_128x128_possible) {
544  sb_size = 128;
545  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
546  } else {
547  sb_size = 64;
548  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
549  }
550  av_log(avctx, AV_LOG_DEBUG, "Using fixed tiling with %dx%d "
551  "superblocks (tile_cols = %d, tile_rows = %d).\n",
552  sb_size, sb_size, ctx->tile_cols, ctx->tile_rows);
553 
554  enccfg->tile_width_count = ctx->tile_cols;
555  enccfg->tile_height_count = ctx->tile_rows;
556 
557  sb_width = (avctx->width + sb_size - 1) / sb_size;
558  sb_height = (avctx->height + sb_size - 1) / sb_size;
559 
560  tile_size = sb_width / ctx->tile_cols;
561  rounding = sb_width % ctx->tile_cols;
562  for (i = 0; i < ctx->tile_cols; i++) {
563  enccfg->tile_widths[i] = tile_size +
564  (i < rounding / 2 ||
565  i > ctx->tile_cols - 1 - (rounding + 1) / 2);
566  }
567 
568  tile_size = sb_height / ctx->tile_rows;
569  rounding = sb_height % ctx->tile_rows;
570  for (i = 0; i < ctx->tile_rows; i++) {
571  enccfg->tile_heights[i] = tile_size +
572  (i < rounding / 2 ||
573  i > ctx->tile_rows - 1 - (rounding + 1) / 2);
574  }
575 
576  return 0;
577 }
578 
579 static av_cold int aom_init(AVCodecContext *avctx,
580  const struct aom_codec_iface *iface)
581 {
582  AOMContext *ctx = avctx->priv_data;
584  struct aom_codec_enc_cfg enccfg = { 0 };
585 #ifdef AOM_FRAME_IS_INTRAONLY
586  aom_codec_flags_t flags =
587  (avctx->flags & AV_CODEC_FLAG_PSNR) ? AOM_CODEC_USE_PSNR : 0;
588 #else
589  aom_codec_flags_t flags = 0;
590 #endif
591  AVCPBProperties *cpb_props;
592  int res;
593  aom_img_fmt_t img_fmt;
594  aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
595 
596  av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
597  av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
598 
599  if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
600  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
601  aom_codec_err_to_string(res));
602  return AVERROR(EINVAL);
603  }
604 
605  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
606  return AVERROR(EINVAL);
607 
608  if(!avctx->bit_rate)
609  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
610  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
611  return AVERROR(EINVAL);
612  }
613 
614  dump_enc_cfg(avctx, &enccfg);
615 
616  enccfg.g_w = avctx->width;
617  enccfg.g_h = avctx->height;
618  enccfg.g_timebase.num = avctx->time_base.num;
619  enccfg.g_timebase.den = avctx->time_base.den;
620  enccfg.g_threads =
621  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
622 
623  enccfg.g_usage = ctx->usage;
624 
625  if (ctx->lag_in_frames >= 0)
626  enccfg.g_lag_in_frames = ctx->lag_in_frames;
627 
628  if (avctx->flags & AV_CODEC_FLAG_PASS1)
629  enccfg.g_pass = AOM_RC_FIRST_PASS;
630  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
631  enccfg.g_pass = AOM_RC_LAST_PASS;
632  else
633  enccfg.g_pass = AOM_RC_ONE_PASS;
634 
635  if (avctx->rc_min_rate == avctx->rc_max_rate &&
636  avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
637  enccfg.rc_end_usage = AOM_CBR;
638  } else if (ctx->crf >= 0) {
639  enccfg.rc_end_usage = AOM_CQ;
640  if (!avctx->bit_rate)
641  enccfg.rc_end_usage = AOM_Q;
642  }
643 
644  if (avctx->bit_rate) {
645  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
647  } else if (enccfg.rc_end_usage != AOM_Q) {
648  enccfg.rc_end_usage = AOM_Q;
649  ctx->crf = 32;
650  av_log(avctx, AV_LOG_WARNING,
651  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
652  ctx->crf);
653  }
654 
655  if (avctx->qmin >= 0)
656  enccfg.rc_min_quantizer = avctx->qmin;
657  if (avctx->qmax >= 0) {
658  enccfg.rc_max_quantizer = avctx->qmax;
659  } else if (!ctx->crf) {
660  enccfg.rc_max_quantizer = 0;
661  }
662 
663  if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
664  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
665  av_log(avctx, AV_LOG_ERROR,
666  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
667  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
668  return AVERROR(EINVAL);
669  }
670  }
671 
672  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
673 
674  // 0-100 (0 => CBR, 100 => VBR)
675  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
676  if (ctx->minsection_pct >= 0)
677  enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
678  else if (avctx->bit_rate)
679  enccfg.rc_2pass_vbr_minsection_pct =
680  avctx->rc_min_rate * 100LL / avctx->bit_rate;
681  if (ctx->maxsection_pct >= 0)
682  enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
683  else if (avctx->rc_max_rate)
684  enccfg.rc_2pass_vbr_maxsection_pct =
685  avctx->rc_max_rate * 100LL / avctx->bit_rate;
686 
687  if (avctx->rc_buffer_size)
688  enccfg.rc_buf_sz =
689  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
690  if (avctx->rc_initial_buffer_occupancy)
691  enccfg.rc_buf_initial_sz =
692  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
693  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
694 
695  if (ctx->rc_undershoot_pct >= 0)
696  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
697  if (ctx->rc_overshoot_pct >= 0)
698  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
699 
700  // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
701  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
702  enccfg.kf_min_dist = avctx->keyint_min;
703  if (avctx->gop_size >= 0)
704  enccfg.kf_max_dist = avctx->gop_size;
705 
706  if (enccfg.g_pass == AOM_RC_FIRST_PASS)
707  enccfg.g_lag_in_frames = 0;
708  else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
709  int decode_size, ret;
710 
711  if (!avctx->stats_in) {
712  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
713  return AVERROR_INVALIDDATA;
714  }
715 
716  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
717  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
718  if (ret < 0) {
719  av_log(avctx, AV_LOG_ERROR,
720  "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
721  ctx->twopass_stats.sz);
722  ctx->twopass_stats.sz = 0;
723  return ret;
724  }
725  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
726  ctx->twopass_stats.sz);
727  if (decode_size < 0) {
728  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
729  return AVERROR_INVALIDDATA;
730  }
731 
732  ctx->twopass_stats.sz = decode_size;
733  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
734  }
735 
736  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
737  * complexity playback on low powered devices at the expense of encode
738  * quality. */
739  if (avctx->profile != FF_PROFILE_UNKNOWN)
740  enccfg.g_profile = avctx->profile;
741 
742  enccfg.g_error_resilient = ctx->error_resilient;
743 
744  res = choose_tiling(avctx, &enccfg);
745  if (res < 0)
746  return res;
747 
748  dump_enc_cfg(avctx, &enccfg);
749  /* Construct Encoder Context */
750  res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
751  if (res != AOM_CODEC_OK) {
752  log_encoder_error(avctx, "Failed to initialize encoder");
753  return AVERROR(EINVAL);
754  }
755 
756  // codec control failures are currently treated only as warnings
757  av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
758  codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
759  if (ctx->auto_alt_ref >= 0)
760  codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
761  if (ctx->arnr_max_frames >= 0)
762  codecctl_int(avctx, AOME_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
763  if (ctx->arnr_strength >= 0)
764  codecctl_int(avctx, AOME_SET_ARNR_STRENGTH, ctx->arnr_strength);
765  if (ctx->enable_cdef >= 0)
766  codecctl_int(avctx, AV1E_SET_ENABLE_CDEF, ctx->enable_cdef);
767  if (ctx->enable_restoration >= 0)
768  codecctl_int(avctx, AV1E_SET_ENABLE_RESTORATION, ctx->enable_restoration);
769 #if AOM_ENCODER_ABI_VERSION >= 22
770  if (ctx->enable_rect_partitions >= 0)
771  codecctl_int(avctx, AV1E_SET_ENABLE_RECT_PARTITIONS, ctx->enable_rect_partitions);
772  if (ctx->enable_1to4_partitions >= 0)
773  codecctl_int(avctx, AV1E_SET_ENABLE_1TO4_PARTITIONS, ctx->enable_1to4_partitions);
774  if (ctx->enable_ab_partitions >= 0)
775  codecctl_int(avctx, AV1E_SET_ENABLE_AB_PARTITIONS, ctx->enable_ab_partitions);
776  if (ctx->enable_angle_delta >= 0)
777  codecctl_int(avctx, AV1E_SET_ENABLE_ANGLE_DELTA, ctx->enable_angle_delta);
778  if (ctx->enable_cfl_intra >= 0)
779  codecctl_int(avctx, AV1E_SET_ENABLE_CFL_INTRA, ctx->enable_cfl_intra);
780  if (ctx->enable_filter_intra >= 0)
781  codecctl_int(avctx, AV1E_SET_ENABLE_FILTER_INTRA, ctx->enable_filter_intra);
782  if (ctx->enable_intra_edge_filter >= 0)
783  codecctl_int(avctx, AV1E_SET_ENABLE_INTRA_EDGE_FILTER, ctx->enable_intra_edge_filter);
784  if (ctx->enable_paeth_intra >= 0)
785  codecctl_int(avctx, AV1E_SET_ENABLE_PAETH_INTRA, ctx->enable_paeth_intra);
786  if (ctx->enable_smooth_intra >= 0)
787  codecctl_int(avctx, AV1E_SET_ENABLE_SMOOTH_INTRA, ctx->enable_smooth_intra);
788  if (ctx->enable_palette >= 0)
789  codecctl_int(avctx, AV1E_SET_ENABLE_PALETTE, ctx->enable_palette);
790  if (ctx->enable_tx64 >= 0)
791  codecctl_int(avctx, AV1E_SET_ENABLE_TX64, ctx->enable_tx64);
792  if (ctx->enable_flip_idtx >= 0)
793  codecctl_int(avctx, AV1E_SET_ENABLE_FLIP_IDTX, ctx->enable_flip_idtx);
794  if (ctx->use_intra_dct_only >= 0)
795  codecctl_int(avctx, AV1E_SET_INTRA_DCT_ONLY, ctx->use_intra_dct_only);
796  if (ctx->use_inter_dct_only >= 0)
797  codecctl_int(avctx, AV1E_SET_INTER_DCT_ONLY, ctx->use_inter_dct_only);
798  if (ctx->use_intra_default_tx_only >= 0)
799  codecctl_int(avctx, AV1E_SET_INTRA_DEFAULT_TX_ONLY, ctx->use_intra_default_tx_only);
800  if (ctx->reduced_tx_type_set >= 0)
801  codecctl_int(avctx, AV1E_SET_REDUCED_TX_TYPE_SET, ctx->reduced_tx_type_set);
802  if (ctx->enable_ref_frame_mvs >= 0)
803  codecctl_int(avctx, AV1E_SET_ENABLE_REF_FRAME_MVS, ctx->enable_ref_frame_mvs);
804  if (ctx->enable_reduced_reference_set >= 0)
805  codecctl_int(avctx, AV1E_SET_REDUCED_REFERENCE_SET, ctx->enable_reduced_reference_set);
806  if (ctx->enable_diff_wtd_comp >= 0)
807  codecctl_int(avctx, AV1E_SET_ENABLE_DIFF_WTD_COMP, ctx->enable_diff_wtd_comp);
808  if (ctx->enable_dist_wtd_comp >= 0)
809  codecctl_int(avctx, AV1E_SET_ENABLE_DIST_WTD_COMP, ctx->enable_dist_wtd_comp);
810  if (ctx->enable_dual_filter >= 0)
811  codecctl_int(avctx, AV1E_SET_ENABLE_DUAL_FILTER, ctx->enable_dual_filter);
812  if (ctx->enable_interinter_wedge >= 0)
813  codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTER_WEDGE, ctx->enable_interinter_wedge);
814  if (ctx->enable_masked_comp >= 0)
815  codecctl_int(avctx, AV1E_SET_ENABLE_MASKED_COMP, ctx->enable_masked_comp);
816  if (ctx->enable_interintra_comp >= 0)
817  codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTRA_COMP, ctx->enable_interintra_comp);
818  if (ctx->enable_interintra_wedge >= 0)
819  codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTRA_WEDGE, ctx->enable_interintra_wedge);
820  if (ctx->enable_obmc >= 0)
821  codecctl_int(avctx, AV1E_SET_ENABLE_OBMC, ctx->enable_obmc);
822  if (ctx->enable_onesided_comp >= 0)
823  codecctl_int(avctx, AV1E_SET_ENABLE_ONESIDED_COMP, ctx->enable_onesided_comp);
824  if (ctx->enable_smooth_interintra >= 0)
825  codecctl_int(avctx, AV1E_SET_ENABLE_SMOOTH_INTERINTRA, ctx->enable_smooth_interintra);
826 #endif
827 
828  codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
829  if (ctx->crf >= 0)
830  codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
831  if (ctx->tune >= 0)
832  codecctl_int(avctx, AOME_SET_TUNING, ctx->tune);
833 
834  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
835  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, AVCOL_PRI_BT709);
836  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, AVCOL_SPC_RGB);
837  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, AVCOL_TRC_IEC61966_2_1);
838  } else {
839  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
840  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
841  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
842  }
843  if (ctx->aq_mode >= 0)
844  codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
845  if (ctx->frame_parallel >= 0)
846  codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
847  set_color_range(avctx);
848 
849  codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
850  if (ctx->uniform_tiles) {
851  codecctl_int(avctx, AV1E_SET_TILE_COLUMNS, ctx->tile_cols_log2);
852  codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
853  }
854 
855 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
856  if (ctx->denoise_noise_level >= 0)
857  codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
858 #endif
859 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
860  if (ctx->denoise_block_size >= 0)
861  codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
862 #endif
863 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
864  if (ctx->enable_global_motion >= 0)
865  codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
866 #endif
867 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
868  if (avctx->refs >= 3) {
869  codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
870  }
871 #endif
872 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
873  if (ctx->row_mt >= 0)
874  codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
875 #endif
876 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
877  if (ctx->enable_intrabc >= 0)
878  codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
879 #endif
880 
881 #if AOM_ENCODER_ABI_VERSION >= 23
882  {
883  AVDictionaryEntry *en = NULL;
884 
885  while ((en = av_dict_get(ctx->aom_params, "", en, AV_DICT_IGNORE_SUFFIX))) {
886  int ret = aom_codec_set_option(&ctx->encoder, en->key, en->value);
887  if (ret != AOM_CODEC_OK) {
888  log_encoder_error(avctx, en->key);
889  return AVERROR_EXTERNAL;
890  }
891  }
892  }
893 #endif
894 
895  // provide dummy value to initialize wrapper, values will be updated each _encode()
896  aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
897  (unsigned char*)1);
898 
899  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
900  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
901 
902  cpb_props = ff_add_cpb_side_data(avctx);
903  if (!cpb_props)
904  return AVERROR(ENOMEM);
905 
906  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
907  const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
908  int ret;
909 
910  if (!filter) {
911  av_log(avctx, AV_LOG_ERROR, "extract_extradata bitstream filter "
912  "not found. This is a bug, please report it.\n");
913  return AVERROR_BUG;
914  }
915  ret = av_bsf_alloc(filter, &ctx->bsf);
916  if (ret < 0)
917  return ret;
918 
919  ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx);
920  if (ret < 0)
921  return ret;
922 
923  ret = av_bsf_init(ctx->bsf);
924  if (ret < 0)
925  return ret;
926  }
927 
928  if (enccfg.rc_end_usage == AOM_CBR ||
929  enccfg.g_pass != AOM_RC_ONE_PASS) {
930  cpb_props->max_bitrate = avctx->rc_max_rate;
931  cpb_props->min_bitrate = avctx->rc_min_rate;
932  cpb_props->avg_bitrate = avctx->bit_rate;
933  }
934  cpb_props->buffer_size = avctx->rc_buffer_size;
935 
936  return 0;
937 }
938 
939 static inline void cx_pktcpy(AOMContext *ctx,
940  struct FrameListData *dst,
941  const struct aom_codec_cx_pkt *src)
942 {
943  dst->pts = src->data.frame.pts;
944  dst->duration = src->data.frame.duration;
945  dst->flags = src->data.frame.flags;
946  dst->sz = src->data.frame.sz;
947  dst->buf = src->data.frame.buf;
948 #ifdef AOM_FRAME_IS_INTRAONLY
949  dst->have_sse = 0;
950  dst->frame_number = ++ctx->frame_number;
951  dst->have_sse = ctx->have_sse;
952  if (ctx->have_sse) {
953  /* associate last-seen SSE to the frame. */
954  /* Transfers ownership from ctx to dst. */
955  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
956  ctx->have_sse = 0;
957  }
958 #endif
959 }
960 
961 /**
962  * Store coded frame information in format suitable for return from encode2().
963  *
964  * Write information from @a cx_frame to @a pkt
965  * @return packet data size on success
966  * @return a negative AVERROR on error
967  */
968 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
969  AVPacket *pkt)
970 {
971  AOMContext *ctx = avctx->priv_data;
972  int av_unused pict_type;
973  int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
974  if (ret < 0) {
975  av_log(avctx, AV_LOG_ERROR,
976  "Error getting output packet of size %"SIZE_SPECIFIER".\n", cx_frame->sz);
977  return ret;
978  }
979  memcpy(pkt->data, cx_frame->buf, pkt->size);
980  pkt->pts = pkt->dts = cx_frame->pts;
981 
982  if (!!(cx_frame->flags & AOM_FRAME_IS_KEY)) {
984 #ifdef AOM_FRAME_IS_INTRAONLY
985  pict_type = AV_PICTURE_TYPE_I;
986  } else if (cx_frame->flags & AOM_FRAME_IS_INTRAONLY) {
987  pict_type = AV_PICTURE_TYPE_I;
988  } else {
989  pict_type = AV_PICTURE_TYPE_P;
990  }
991 
992  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
993  cx_frame->have_sse ? 3 : 0, pict_type);
994 
995  if (cx_frame->have_sse) {
996  int i;
997  for (i = 0; i < 3; ++i) {
998  avctx->error[i] += cx_frame->sse[i + 1];
999  }
1000  cx_frame->have_sse = 0;
1001 #endif
1002  }
1003 
1004  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1005  ret = av_bsf_send_packet(ctx->bsf, pkt);
1006  if (ret < 0) {
1007  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
1008  "failed to send input packet\n");
1009  return ret;
1010  }
1011  ret = av_bsf_receive_packet(ctx->bsf, pkt);
1012 
1013  if (ret < 0) {
1014  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
1015  "failed to receive output packet\n");
1016  return ret;
1017  }
1018  }
1019  return pkt->size;
1020 }
1021 
1022 /**
1023  * Queue multiple output frames from the encoder, returning the front-most.
1024  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
1025  * the frame queue. Return the head frame if available.
1026  * @return Stored frame size
1027  * @return AVERROR(EINVAL) on output size error
1028  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
1029  */
1030 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
1031 {
1032  AOMContext *ctx = avctx->priv_data;
1033  const struct aom_codec_cx_pkt *pkt;
1034  const void *iter = NULL;
1035  int size = 0;
1036 
1037  if (ctx->coded_frame_list) {
1038  struct FrameListData *cx_frame = ctx->coded_frame_list;
1039  /* return the leading frame if we've already begun queueing */
1040  size = storeframe(avctx, cx_frame, pkt_out);
1041  if (size < 0)
1042  return size;
1043  ctx->coded_frame_list = cx_frame->next;
1044  free_coded_frame(cx_frame);
1045  }
1046 
1047  /* consume all available output from the encoder before returning. buffers
1048  * are only good through the next aom_codec call */
1049  while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
1050  switch (pkt->kind) {
1051  case AOM_CODEC_CX_FRAME_PKT:
1052  if (!size) {
1053  struct FrameListData cx_frame;
1054 
1055  /* avoid storing the frame when the list is empty and we haven't yet
1056  * provided a frame for output */
1057  av_assert0(!ctx->coded_frame_list);
1058  cx_pktcpy(ctx, &cx_frame, pkt);
1059  size = storeframe(avctx, &cx_frame, pkt_out);
1060  if (size < 0)
1061  return size;
1062  } else {
1063  struct FrameListData *cx_frame =
1064  av_malloc(sizeof(struct FrameListData));
1065 
1066  if (!cx_frame) {
1067  av_log(avctx, AV_LOG_ERROR,
1068  "Frame queue element alloc failed\n");
1069  return AVERROR(ENOMEM);
1070  }
1071  cx_pktcpy(ctx, cx_frame, pkt);
1072  cx_frame->buf = av_malloc(cx_frame->sz);
1073 
1074  if (!cx_frame->buf) {
1075  av_log(avctx, AV_LOG_ERROR,
1076  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1077  cx_frame->sz);
1078  av_freep(&cx_frame);
1079  return AVERROR(ENOMEM);
1080  }
1081  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
1082  coded_frame_add(&ctx->coded_frame_list, cx_frame);
1083  }
1084  break;
1085  case AOM_CODEC_STATS_PKT:
1086  {
1087  struct aom_fixed_buf *stats = &ctx->twopass_stats;
1088  int err;
1089  if ((err = av_reallocp(&stats->buf,
1090  stats->sz +
1091  pkt->data.twopass_stats.sz)) < 0) {
1092  stats->sz = 0;
1093  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
1094  return err;
1095  }
1096  memcpy((uint8_t *)stats->buf + stats->sz,
1097  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1098  stats->sz += pkt->data.twopass_stats.sz;
1099  break;
1100  }
1101 #ifdef AOM_FRAME_IS_INTRAONLY
1102  case AOM_CODEC_PSNR_PKT:
1103  {
1104  av_assert0(!ctx->have_sse);
1105  ctx->sse[0] = pkt->data.psnr.sse[0];
1106  ctx->sse[1] = pkt->data.psnr.sse[1];
1107  ctx->sse[2] = pkt->data.psnr.sse[2];
1108  ctx->sse[3] = pkt->data.psnr.sse[3];
1109  ctx->have_sse = 1;
1110  break;
1111  }
1112 #endif
1113  case AOM_CODEC_CUSTOM_PKT:
1114  // ignore unsupported/unrecognized packet types
1115  break;
1116  }
1117  }
1118 
1119  return size;
1120 }
1121 
1123  const AVFrame *frame, int *got_packet)
1124 {
1125  AOMContext *ctx = avctx->priv_data;
1126  struct aom_image *rawimg = NULL;
1127  int64_t timestamp = 0;
1128  int res, coded_size;
1129  aom_enc_frame_flags_t flags = 0;
1130 
1131  if (frame) {
1132  rawimg = &ctx->rawimg;
1133  rawimg->planes[AOM_PLANE_Y] = frame->data[0];
1134  rawimg->planes[AOM_PLANE_U] = frame->data[1];
1135  rawimg->planes[AOM_PLANE_V] = frame->data[2];
1136  rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
1137  rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
1138  rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
1139  timestamp = frame->pts;
1140  switch (frame->color_range) {
1141  case AVCOL_RANGE_MPEG:
1142  rawimg->range = AOM_CR_STUDIO_RANGE;
1143  break;
1144  case AVCOL_RANGE_JPEG:
1145  rawimg->range = AOM_CR_FULL_RANGE;
1146  break;
1147  }
1148 
1149  if (frame->pict_type == AV_PICTURE_TYPE_I)
1150  flags |= AOM_EFLAG_FORCE_KF;
1151  }
1152 
1153  res = aom_codec_encode(&ctx->encoder, rawimg, timestamp,
1154  avctx->ticks_per_frame, flags);
1155  if (res != AOM_CODEC_OK) {
1156  log_encoder_error(avctx, "Error encoding frame");
1157  return AVERROR_INVALIDDATA;
1158  }
1159  coded_size = queue_frames(avctx, pkt);
1160 
1161  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1162  size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1163 
1164  avctx->stats_out = av_malloc(b64_size);
1165  if (!avctx->stats_out) {
1166  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1167  b64_size);
1168  return AVERROR(ENOMEM);
1169  }
1170  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1171  ctx->twopass_stats.sz);
1172  }
1173 
1174  *got_packet = !!coded_size;
1175  return 0;
1176 }
1177 
1178 static const enum AVPixelFormat av1_pix_fmts[] = {
1184 };
1185 
1186 static const enum AVPixelFormat av1_pix_fmts_with_gray[] = {
1193 };
1194 
1195 static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
1209 };
1210 
1228 };
1229 
1230 static av_cold void av1_init_static(AVCodec *codec)
1231 {
1232  int supports_monochrome = aom_codec_version() >= 20001;
1233  aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1234  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1235  codec->pix_fmts = supports_monochrome ? av1_pix_fmts_highbd_with_gray :
1237  else
1238  codec->pix_fmts = supports_monochrome ? av1_pix_fmts_with_gray :
1239  av1_pix_fmts;
1240 
1241  if (aom_codec_version_major() < 2)
1243 }
1244 
1245 static av_cold int av1_init(AVCodecContext *avctx)
1246 {
1247  return aom_init(avctx, aom_codec_av1_cx());
1248 }
1249 
1250 #define OFFSET(x) offsetof(AOMContext, x)
1251 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1252 static const AVOption options[] = {
1253  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 8, VE},
1254  { "auto-alt-ref", "Enable use of alternate reference "
1255  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1256  { "lag-in-frames", "Number of frames to look ahead at for "
1257  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1258  { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1259  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1260  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
1261  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode"},
1262  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode"},
1263  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode"},
1264  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode"},
1265  { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
1266  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
1267  { "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1268  { "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 },
1269  { "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1270  { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1271  { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1272  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1273  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1274  { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1275  { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1276  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1277  { "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
1278  { "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1279  { "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1280  { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1281  { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1282  { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1283  { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1284  { "enable-restoration", "Enable Loop Restoration filtering", OFFSET(enable_restoration), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1285  { "usage", "Quality and compression efficiency vs speed trade-off", OFFSET(usage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, "usage"},
1286  { "good", "Good quality", 0, AV_OPT_TYPE_CONST, {.i64 = 0 /* AOM_USAGE_GOOD_QUALITY */}, 0, 0, VE, "usage"},
1287  { "realtime", "Realtime encoding", 0, AV_OPT_TYPE_CONST, {.i64 = 1 /* AOM_USAGE_REALTIME */}, 0, 0, VE, "usage"},
1288  { "tune", "The metric that the encoder tunes for. Automatically chosen by the encoder by default", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, AOM_TUNE_SSIM, VE, "tune"},
1289  { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AOM_TUNE_PSNR}, 0, 0, VE, "tune"},
1290  { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AOM_TUNE_SSIM}, 0, 0, VE, "tune"},
1292  { "enable-rect-partitions", "Enable rectangular partitions", OFFSET(enable_rect_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1293  { "enable-1to4-partitions", "Enable 1:4/4:1 partitions", OFFSET(enable_1to4_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1294  { "enable-ab-partitions", "Enable ab shape partitions", OFFSET(enable_ab_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1295  { "enable-angle-delta", "Enable angle delta intra prediction", OFFSET(enable_angle_delta), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1296  { "enable-cfl-intra", "Enable chroma predicted from luma intra prediction", OFFSET(enable_cfl_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1297  { "enable-filter-intra", "Enable filter intra predictor", OFFSET(enable_filter_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1298  { "enable-intra-edge-filter", "Enable intra edge filter", OFFSET(enable_intra_edge_filter), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1299  { "enable-smooth-intra", "Enable smooth intra prediction mode", OFFSET(enable_smooth_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1300  { "enable-paeth-intra", "Enable paeth predictor in intra prediction", OFFSET(enable_paeth_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1301  { "enable-palette", "Enable palette prediction mode", OFFSET(enable_palette), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1302  { "enable-flip-idtx", "Enable extended transform type", OFFSET(enable_flip_idtx), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1303  { "enable-tx64", "Enable 64-pt transform", OFFSET(enable_tx64), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1304  { "reduced-tx-type-set", "Use reduced set of transform types", OFFSET(reduced_tx_type_set), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1305  { "use-intra-dct-only", "Use DCT only for INTRA modes", OFFSET(use_intra_dct_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1306  { "use-inter-dct-only", "Use DCT only for INTER modes", OFFSET(use_inter_dct_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1307  { "use-intra-default-tx-only", "Use default-transform only for INTRA modes", OFFSET(use_intra_default_tx_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1308  { "enable-ref-frame-mvs", "Enable temporal mv prediction", OFFSET(enable_ref_frame_mvs), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1309  { "enable-reduced-reference-set", "Use reduced set of single and compound references", OFFSET(enable_reduced_reference_set), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1310  { "enable-obmc", "Enable obmc", OFFSET(enable_obmc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1311  { "enable-dual-filter", "Enable dual filter", OFFSET(enable_dual_filter), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1312  { "enable-diff-wtd-comp", "Enable difference-weighted compound", OFFSET(enable_diff_wtd_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1313  { "enable-dist-wtd-comp", "Enable distance-weighted compound", OFFSET(enable_dist_wtd_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1314  { "enable-onesided-comp", "Enable one sided compound", OFFSET(enable_onesided_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1315  { "enable-interinter-wedge", "Enable interinter wedge compound", OFFSET(enable_interinter_wedge), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1316  { "enable-interintra-wedge", "Enable interintra wedge compound", OFFSET(enable_interintra_wedge), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1317  { "enable-masked-comp", "Enable masked compound", OFFSET(enable_masked_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1318  { "enable-interintra-comp", "Enable interintra compound", OFFSET(enable_interintra_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1319  { "enable-smooth-interintra", "Enable smooth interintra mode", OFFSET(enable_smooth_interintra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1320 #if AOM_ENCODER_ABI_VERSION >= 23
1321  { "aom-params", "Set libaom options using a :-separated list of key=value pairs", OFFSET(aom_params), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
1322 #endif
1323  { NULL },
1324 };
1325 
1326 static const AVCodecDefault defaults[] = {
1327  { "b", "0" },
1328  { "qmin", "-1" },
1329  { "qmax", "-1" },
1330  { "g", "-1" },
1331  { "keyint_min", "-1" },
1332  { NULL },
1333 };
1334 
1335 static const AVClass class_aom = {
1336  .class_name = "libaom-av1 encoder",
1337  .item_name = av_default_item_name,
1338  .option = options,
1339  .version = LIBAVUTIL_VERSION_INT,
1340 };
1341 
1343  .name = "libaom-av1",
1344  .long_name = NULL_IF_CONFIG_SMALL("libaom AV1"),
1345  .type = AVMEDIA_TYPE_VIDEO,
1346  .id = AV_CODEC_ID_AV1,
1347  .priv_data_size = sizeof(AOMContext),
1348  .init = av1_init,
1349  .encode2 = aom_encode,
1350  .close = aom_free,
1352  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
1354  .priv_class = &class_aom,
1355  .defaults = defaults,
1356  .init_static_data = av1_init_static,
1357  .wrapper_name = "libaom",
1358 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
AOMEncoderContext::error_resilient
int error_resilient
Definition: libaomenc.c:74
AOMEncoderContext::usage
int usage
Definition: libaomenc.c:97
AVCodec
AVCodec.
Definition: codec.h:197
AOMEncoderContext::enable_filter_intra
int enable_filter_intra
Definition: libaomenc.c:108
AOMEncoderContext::enable_paeth_intra
int enable_paeth_intra
Definition: libaomenc.c:104
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
AOMEncoderContext::tile_rows_log2
int tile_rows_log2
Definition: libaomenc.c:89
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AOMEncoderContext::enable_interintra_comp
int enable_interintra_comp
Definition: libaomenc.c:118
level
uint8_t level
Definition: svq3.c:204
FrameListData::pts
int64_t pts
time stamp to show frame (in timebase units)
Definition: libaomenc.c:50
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:1031
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AOMEncoderContext::sse
uint64_t sse[4]
Definition: libaomenc.c:80
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
set_color_range
static void set_color_range(AVCodecContext *avctx)
Definition: libaomenc.c:400
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1066
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1307
aom_init
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
Definition: libaomenc.c:579
ff_libaom_av1_encoder
AVCodec ff_libaom_av1_encoder
Definition: libaomenc.c:1342
stats
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
Definition: vp9_superframe_bsf.c:34
AOMEncoderContext::enable_restoration
int enable_restoration
Definition: libaomenc.c:96
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:586
avcodec_parameters_from_context
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:90
AOMEncoderContext::enable_smooth_intra
int enable_smooth_intra
Definition: libaomenc.c:105
AOMEncoderContext::enable_1to4_partitions
int enable_1to4_partitions
Definition: libaomenc.c:100
FF_AV1_PROFILE_OPTS
#define FF_AV1_PROFILE_OPTS
Definition: profiles.h:54
AOMEncoderContext::denoise_noise_level
int denoise_noise_level
Definition: libaomenc.c:78
av_unused
#define av_unused
Definition: attributes.h:131
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:218
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:145
AOMEncoderContext::lag_in_frames
int lag_in_frames
Definition: libaomenc.c:73
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1059
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:216
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:576
coded_frame_add
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libaomenc.c:268
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
AV1_MAX_TILE_ROWS
@ AV1_MAX_TILE_ROWS
Definition: av1.h:80
AOMEncoderContext::frame_number
uint64_t frame_number
Definition: libaomenc.c:82
AVOption
AVOption.
Definition: opt.h:248
AOMEncoderContext::use_intra_default_tx_only
int use_intra_default_tx_only
Definition: libaomenc.c:114
cx_pktcpy
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
Definition: libaomenc.c:939
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:389
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:70
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:197
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:503
dump_enc_cfg
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct aom_codec_enc_cfg *cfg)
Definition: libaomenc.c:210
mathematics.h
filter
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
Definition: filter_design.txt:228
AVDictionary
Definition: dict.c:30
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:289
AOMEncoderContext::aom_params
AVDictionary * aom_params
Definition: libaomenc.c:127
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:991
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1271
options
static const AVOption options[]
Definition: libaomenc.c:1252
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:396
AVBSFContext
The bitstream filter state.
Definition: bsf.h:49
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:306
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:78
storeframe
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:968
FrameListData::flags
uint32_t flags
flags for this frame
Definition: libaomenc.c:54
AOMEncoderContext::cpu_used
int cpu_used
Definition: libaomenc.c:68
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:487
AOMEncoderContext::enable_ab_partitions
int enable_ab_partitions
Definition: libaomenc.c:101
AOMEncoderContext::coded_frame_list
struct FrameListData * coded_frame_list
Definition: libaomenc.c:67
AOMEncoderContext::static_thresh
int static_thresh
Definition: libaomenc.c:76
AV1_MAX_TILE_AREA
@ AV1_MAX_TILE_AREA
Definition: av1.h:79
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1546
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:405
AOMEncoderContext::minsection_pct
int minsection_pct
Definition: libaomenc.c:85
AOMEncoderContext::uniform_tiles
int uniform_tiles
Definition: libaomenc.c:91
AOMEncoderContext::enable_ref_frame_mvs
int enable_ref_frame_mvs
Definition: libaomenc.c:115
AOMEncoderContext::row_mt
int row_mt
Definition: libaomenc.c:92
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1038
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:581
AOMEncoderContext::denoise_block_size
int denoise_block_size
Definition: libaomenc.c:79
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVRational::num
int num
Numerator.
Definition: rational.h:59
AOMEncoderContext::use_inter_dct_only
int use_inter_dct_only
Definition: libaomenc.c:113
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
free_coded_frame
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libaomenc.c:278
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1052
count_uniform_tiling
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
Definition: libaomenc.c:416
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:100
av_cold
#define av_cold
Definition: attributes.h:90
AOMEncoderContext::enable_angle_delta
int enable_angle_delta
Definition: libaomenc.c:102
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1328
AOMEncoderContext::enable_cdef
int enable_cdef
Definition: libaomenc.c:93
AOMEncoderContext::enable_smooth_interintra
int enable_smooth_interintra
Definition: libaomenc.c:123
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
AOMEncoderContext::twopass_stats
struct aom_fixed_buf twopass_stats
Definition: libaomenc.c:66
width
#define width
queue_frames
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
Definition: libaomenc.c:1030
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1350
codecctl_int
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
Definition: libaomenc.c:295
AVDictionaryEntry::key
char * key
Definition: dict.h:82
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:633
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:122
FrameListData::sse
uint64_t sse[4]
Definition: libaomenc.c:55
AOMEncoderContext::enable_interintra_wedge
int enable_interintra_wedge
Definition: libaomenc.c:117
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1632
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AOMEncoderContext::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:81
AOMEncoderContext::enable_obmc
int enable_obmc
Definition: libaomenc.c:120
FrameListData::frame_number
uint64_t frame_number
Definition: libaomenc.c:57
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
set_pix_fmt
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:334
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:147
tile_cols
int tile_cols
Definition: h265_levels.c:218
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1300
AOMEncoderContext::superblock_size
aom_superblock_size_t superblock_size
Definition: libaomenc.c:90
AVCodecContext::error
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1483
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:430
AOMEncoderContext::enable_dist_wtd_comp
int enable_dist_wtd_comp
Definition: libaomenc.c:125
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:370
AVCodecDefault
Definition: internal.h:207
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1285
AOMEncoderContext::drop_threshold
int drop_threshold
Definition: libaomenc.c:77
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AOMEncoderContext::tile_rows
int tile_rows
Definition: libaomenc.c:88
NULL
#define NULL
Definition: coverity.c:32
AOMEncoderContext
Definition: libaomenc.c:61
AOMEncoderContext::rc_overshoot_pct
int rc_overshoot_pct
Definition: libaomenc.c:84
AOMEncoderContext::enable_diff_wtd_comp
int enable_diff_wtd_comp
Definition: libaomenc.c:124
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1073
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:278
AOMEncoderContext::enable_palette
int enable_palette
Definition: libaomenc.c:107
AOMEncoderContext::arnr_max_frames
int arnr_max_frames
Definition: libaomenc.c:70
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:551
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:232
AOMEncoderContext::enable_tx64
int enable_tx64
Definition: libaomenc.c:110
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:450
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
profiles.h
src
#define src
Definition: vp8dsp.c:255
list
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
Definition: filter_design.txt:25
FrameListData::buf
void * buf
compressed data buffer
Definition: libaomenc.c:48
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
AOMEncoderContext::rc_undershoot_pct
int rc_undershoot_pct
Definition: libaomenc.c:83
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
AV1_MAX_TILE_COLS
@ AV1_MAX_TILE_COLS
Definition: av1.h:81
av_base64_decode
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:79
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
defaults
static const AVCodecDefault defaults[]
Definition: libaomenc.c:1326
base64.h
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:542
AOMEncoderContext::enable_global_motion
int enable_global_motion
Definition: libaomenc.c:94
AOMEncoderContext::encoder
struct aom_codec_ctx encoder
Definition: libaomenc.c:64
av1_init
static av_cold int av1_init(AVCodecContext *avctx)
Definition: libaomenc.c:1245
AOMEncoderContext::enable_onesided_comp
int enable_onesided_comp
Definition: libaomenc.c:121
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:184
usage
const char * usage
Definition: floatimg_cmp.c:60
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1256
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:624
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
av_rescale_rnd
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
FrameListData::next
struct FrameListData * next
Definition: libaomenc.c:58
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1342
ctlidstr
static const char *const ctlidstr[]
Definition: libaomenc.c:130
FF_PROFILE_AV1_MAIN
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:1727
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:696
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:137
AOMEncoderContext::enable_flip_idtx
int enable_flip_idtx
Definition: libaomenc.c:109
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
size
int size
Definition: twinvq_data.h:10344
av_reallocp
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:167
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
aom_encode
static int aom_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libaomenc.c:1122
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:440
av1.h
FrameListData
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libaomenc.c:47
AOMEncoderContext::tile_cols_log2
int tile_cols_log2
Definition: libaomenc.c:89
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:364
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:277
AOMEncoderContext::tile_cols
int tile_cols
Definition: libaomenc.c:88
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:57
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:371
AOMEncoderContext::rawimg
struct aom_image rawimg
Definition: libaomenc.c:65
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:445
AOMEncoderContext::enable_dual_filter
int enable_dual_filter
Definition: libaomenc.c:126
AOMEncoderContext::aq_mode
int aq_mode
Definition: libaomenc.c:72
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
AOMEncoderContext::enable_cfl_intra
int enable_cfl_intra
Definition: libaomenc.c:103
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
i
int i
Definition: input.c:407
AOMEncoderContext::arnr_strength
int arnr_strength
Definition: libaomenc.c:71
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:224
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:358
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:406
AOMEncoderContext::enable_interinter_wedge
int enable_interinter_wedge
Definition: libaomenc.c:116
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:435
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:674
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
FrameListData::duration
unsigned long duration
duration to show frame (in timebase units)
Definition: libaomenc.c:52
AOMEncoderContext::auto_alt_ref
int auto_alt_ref
Definition: libaomenc.c:69
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:559
FF_PROFILE_AV1_PROFESSIONAL
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1729
avcodec.h
dim
int dim
Definition: vorbis_enc_data.h:451
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
frame
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
Definition: filter_design.txt:264
av1_pix_fmts_with_gray
static enum AVPixelFormat av1_pix_fmts_with_gray[]
Definition: libaomenc.c:1186
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:451
AOMEncoderContext::bsf
AVBSFContext * bsf
Definition: libaomenc.c:63
log_encoder_error
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libaomenc.c:199
AV1_MAX_TILE_WIDTH
@ AV1_MAX_TILE_WIDTH
Definition: av1.h:78
VE
#define VE
Definition: libaomenc.c:1251
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:393
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:198
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
free_frame_list
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libaomenc.c:284
AVCodecContext
main external API structure.
Definition: avcodec.h:501
AOMEncoderContext::enable_rect_partitions
int enable_rect_partitions
Definition: libaomenc.c:99
AVBitStreamFilter
Definition: bsf.h:98
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1264
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1631
choose_tiling
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
Definition: libaomenc.c:424
AOMEncoderContext::maxsection_pct
int maxsection_pct
Definition: libaomenc.c:86
av_base64_encode
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:143
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:427
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
AOMEncoderContext::enable_intra_edge_filter
int enable_intra_edge_filter
Definition: libaomenc.c:106
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
class_aom
static const AVClass class_aom
Definition: libaomenc.c:1335
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
packet_internal.h
av1_pix_fmts
static enum AVPixelFormat av1_pix_fmts[]
Definition: libaomenc.c:1178
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
AOMEncoderContext::enable_reduced_reference_set
int enable_reduced_reference_set
Definition: libaomenc.c:122
AVDictionaryEntry
Definition: dict.h:81
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AOMEncoderContext::frame_parallel
int frame_parallel
Definition: libaomenc.c:87
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
av1_pix_fmts_highbd
static enum AVPixelFormat av1_pix_fmts_highbd[]
Definition: libaomenc.c:1195
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:40
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:674
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:224
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
AOMEncoderContext::enable_masked_comp
int enable_masked_comp
Definition: libaomenc.c:119
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FrameListData::sz
size_t sz
length of compressed data
Definition: libaomenc.c:49
AOMEncoderContext::reduced_tx_type_set
int reduced_tx_type_set
Definition: libaomenc.c:111
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
FF_PROFILE_AV1_HIGH
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1728
AVDictionaryEntry::value
char * value
Definition: dict.h:83
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:371
ff_alloc_packet2
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:33
av1_init_static
static av_cold void av1_init_static(AVCodec *codec)
Definition: libaomenc.c:1230
AOMEncoderContext::enable_intrabc
int enable_intrabc
Definition: libaomenc.c:95
aom_free
static av_cold int aom_free(AVCodecContext *avctx)
Definition: libaomenc.c:322
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
snprintf
#define snprintf
Definition: snprintf.h:34
AOMEncoderContext::tune
int tune
Definition: libaomenc.c:98
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AOMEncoderContext::crf
int crf
Definition: libaomenc.c:75
OFFSET
#define OFFSET(x)
Definition: libaomenc.c:1250
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:92
AOMEncoderContext::use_intra_dct_only
int use_intra_dct_only
Definition: libaomenc.c:112
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:273
FrameListData::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:56
av1_pix_fmts_highbd_with_gray
static enum AVPixelFormat av1_pix_fmts_highbd_with_gray[]
Definition: libaomenc.c:1211