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