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 "encode.h"
40 #include "internal.h"
41 #include "packet_internal.h"
42 #include "profiles.h"
43 
44 /*
45  * Portion of struct aom_codec_cx_pkt from aom_encoder.h.
46  * One encoded frame returned from the library.
47  */
48 struct FrameListData {
49  void *buf; /**< compressed data buffer */
50  size_t sz; /**< length of compressed data */
51  int64_t pts; /**< time stamp to show frame
52  (in timebase units) */
53  unsigned long duration; /**< duration to show frame
54  (in timebase units) */
55  uint32_t flags; /**< flags for this frame */
56  uint64_t sse[4];
57  int have_sse; /**< true if we have pending sse[] */
58  uint64_t frame_number;
60 };
61 
62 typedef struct AOMEncoderContext {
63  AVClass *class;
65  struct aom_codec_ctx encoder;
66  struct aom_image rawimg;
67  struct aom_fixed_buf twopass_stats;
69  int cpu_used;
73  int aq_mode;
76  int crf;
81  uint64_t sse[4];
82  int have_sse; /**< true if we have pending sse[] */
83  uint64_t frame_number;
91  aom_superblock_size_t superblock_size;
93  int row_mt;
98  int usage;
99  int tune;
129 } AOMContext;
130 
131 static const char *const ctlidstr[] = {
132  [AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
133  [AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
134  [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
135  [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
136  [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
137  [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
138  [AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
139  [AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
140  [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
141  [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
142  [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
143  [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
144  [AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
145  [AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
146  [AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
147  [AV1E_SET_ENABLE_RESTORATION] = "AV1E_SET_ENABLE_RESTORATION",
148 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
149  [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
150 #endif
151 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
152  [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
153 #endif
154 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
155  [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
156 #endif
157 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
158  [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
159 #endif
160 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
161  [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
162 #endif
163 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
164  [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
165 #endif
166  [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
167  [AOME_SET_TUNING] = "AOME_SET_TUNING",
168 #if AOM_ENCODER_ABI_VERSION >= 22
169  [AV1E_SET_ENABLE_1TO4_PARTITIONS] = "AV1E_SET_ENABLE_1TO4_PARTITIONS",
170  [AV1E_SET_ENABLE_AB_PARTITIONS] = "AV1E_SET_ENABLE_AB_PARTITIONS",
171  [AV1E_SET_ENABLE_RECT_PARTITIONS] = "AV1E_SET_ENABLE_RECT_PARTITIONS",
172  [AV1E_SET_ENABLE_ANGLE_DELTA] = "AV1E_SET_ENABLE_ANGLE_DELTA",
173  [AV1E_SET_ENABLE_CFL_INTRA] = "AV1E_SET_ENABLE_CFL_INTRA",
174  [AV1E_SET_ENABLE_FILTER_INTRA] = "AV1E_SET_ENABLE_FILTER_INTRA",
175  [AV1E_SET_ENABLE_INTRA_EDGE_FILTER] = "AV1E_SET_ENABLE_INTRA_EDGE_FILTER",
176  [AV1E_SET_ENABLE_PAETH_INTRA] = "AV1E_SET_ENABLE_PAETH_INTRA",
177  [AV1E_SET_ENABLE_SMOOTH_INTRA] = "AV1E_SET_ENABLE_SMOOTH_INTRA",
178  [AV1E_SET_ENABLE_PALETTE] = "AV1E_SET_ENABLE_PALETTE",
179  [AV1E_SET_ENABLE_FLIP_IDTX] = "AV1E_SET_ENABLE_FLIP_IDTX",
180  [AV1E_SET_ENABLE_TX64] = "AV1E_SET_ENABLE_TX64",
181  [AV1E_SET_INTRA_DCT_ONLY] = "AV1E_SET_INTRA_DCT_ONLY",
182  [AV1E_SET_INTER_DCT_ONLY] = "AV1E_SET_INTER_DCT_ONLY",
183  [AV1E_SET_INTRA_DEFAULT_TX_ONLY] = "AV1E_SET_INTRA_DEFAULT_TX_ONLY",
184  [AV1E_SET_REDUCED_TX_TYPE_SET] = "AV1E_SET_REDUCED_TX_TYPE_SET",
185  [AV1E_SET_ENABLE_DIFF_WTD_COMP] = "AV1E_SET_ENABLE_DIFF_WTD_COMP",
186  [AV1E_SET_ENABLE_DIST_WTD_COMP] = "AV1E_SET_ENABLE_DIST_WTD_COMP",
187  [AV1E_SET_ENABLE_DUAL_FILTER] = "AV1E_SET_ENABLE_DUAL_FILTER",
188  [AV1E_SET_ENABLE_INTERINTER_WEDGE] = "AV1E_SET_ENABLE_INTERINTER_WEDGE",
189  [AV1E_SET_ENABLE_INTERINTRA_WEDGE] = "AV1E_SET_ENABLE_INTERINTRA_WEDGE",
190  [AV1E_SET_ENABLE_MASKED_COMP] = "AV1E_SET_ENABLE_MASKED_COMP",
191  [AV1E_SET_ENABLE_INTERINTRA_COMP] = "AV1E_SET_ENABLE_INTERINTRA_COMP",
192  [AV1E_SET_ENABLE_OBMC] = "AV1E_SET_ENABLE_OBMC",
193  [AV1E_SET_ENABLE_ONESIDED_COMP] = "AV1E_SET_ENABLE_ONESIDED_COMP",
194  [AV1E_SET_REDUCED_REFERENCE_SET] = "AV1E_SET_REDUCED_REFERENCE_SET",
195  [AV1E_SET_ENABLE_SMOOTH_INTERINTRA] = "AV1E_SET_ENABLE_SMOOTH_INTERINTRA",
196  [AV1E_SET_ENABLE_REF_FRAME_MVS] = "AV1E_SET_ENABLE_REF_FRAME_MVS",
197 #endif
198 };
199 
200 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
201 {
202  AOMContext *ctx = avctx->priv_data;
203  const char *error = aom_codec_error(&ctx->encoder);
204  const char *detail = aom_codec_error_detail(&ctx->encoder);
205 
206  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
207  if (detail)
208  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
209 }
210 
212  const struct aom_codec_enc_cfg *cfg,
213  int level)
214 {
215  int width = -30;
216 
217  av_log(avctx, level, "aom_codec_enc_cfg\n");
218  av_log(avctx, level, "generic settings\n"
219  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
220  " %*s%u\n %*s%u\n"
221  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
222  width, "g_usage:", cfg->g_usage,
223  width, "g_threads:", cfg->g_threads,
224  width, "g_profile:", cfg->g_profile,
225  width, "g_w:", cfg->g_w,
226  width, "g_h:", cfg->g_h,
227  width, "g_bit_depth:", cfg->g_bit_depth,
228  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
229  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
230  width, "g_error_resilient:", cfg->g_error_resilient,
231  width, "g_pass:", cfg->g_pass,
232  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
233  av_log(avctx, level, "rate control settings\n"
234  " %*s%u\n %*s%d\n %*s%p(%"SIZE_SPECIFIER")\n %*s%u\n",
235  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
236  width, "rc_end_usage:", cfg->rc_end_usage,
237  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
238  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
239  av_log(avctx, level, "quantizer settings\n"
240  " %*s%u\n %*s%u\n",
241  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
242  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
243  av_log(avctx, level, "bitrate tolerance\n"
244  " %*s%u\n %*s%u\n",
245  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
246  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
247  av_log(avctx, level, "decoder buffer model\n"
248  " %*s%u\n %*s%u\n %*s%u\n",
249  width, "rc_buf_sz:", cfg->rc_buf_sz,
250  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
251  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
252  av_log(avctx, level, "2 pass rate control settings\n"
253  " %*s%u\n %*s%u\n %*s%u\n",
254  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
255  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
256  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
257  av_log(avctx, level, "keyframing settings\n"
258  " %*s%d\n %*s%u\n %*s%u\n",
259  width, "kf_mode:", cfg->kf_mode,
260  width, "kf_min_dist:", cfg->kf_min_dist,
261  width, "kf_max_dist:", cfg->kf_max_dist);
262  av_log(avctx, level, "tile settings\n"
263  " %*s%d\n %*s%d\n",
264  width, "tile_width_count:", cfg->tile_width_count,
265  width, "tile_height_count:", cfg->tile_height_count);
266  av_log(avctx, level, "\n");
267 }
268 
269 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
270 {
271  struct FrameListData **p = list;
272 
273  while (*p)
274  p = &(*p)->next;
275  *p = cx_frame;
276  cx_frame->next = NULL;
277 }
278 
279 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
280 {
281  av_freep(&cx_frame->buf);
282  av_freep(&cx_frame);
283 }
284 
286 {
287  struct FrameListData *p = list;
288 
289  while (p) {
290  list = list->next;
291  free_coded_frame(p);
292  p = list;
293  }
294 }
295 
297 #ifdef UENUM1BYTE
298  aome_enc_control_id id,
299 #else
300  enum aome_enc_control_id id,
301 #endif
302  int val)
303 {
304  AOMContext *ctx = avctx->priv_data;
305  char buf[80];
306  int width = -30;
307  int res;
308 
309  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
310  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
311 
312  res = aom_codec_control(&ctx->encoder, id, val);
313  if (res != AOM_CODEC_OK) {
314  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
315  ctlidstr[id]);
316  log_encoder_error(avctx, buf);
317  return AVERROR(EINVAL);
318  }
319 
320  return 0;
321 }
322 
323 static av_cold int aom_free(AVCodecContext *avctx)
324 {
325  AOMContext *ctx = avctx->priv_data;
326 
327  aom_codec_destroy(&ctx->encoder);
328  av_freep(&ctx->twopass_stats.buf);
329  av_freep(&avctx->stats_out);
330  free_frame_list(ctx->coded_frame_list);
331  av_bsf_free(&ctx->bsf);
332  return 0;
333 }
334 
335 static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
336  struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
337  aom_img_fmt_t *img_fmt)
338 {
339  AOMContext av_unused *ctx = avctx->priv_data;
341  enccfg->g_bit_depth = enccfg->g_input_bit_depth = desc->comp[0].depth;
342  switch (avctx->pix_fmt) {
343  case AV_PIX_FMT_GRAY8:
344  enccfg->monochrome = 1;
345  /* Fall-through */
346  case AV_PIX_FMT_YUV420P:
347  enccfg->g_profile = FF_PROFILE_AV1_MAIN;
348  *img_fmt = AOM_IMG_FMT_I420;
349  return 0;
350  case AV_PIX_FMT_YUV422P:
351  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
352  *img_fmt = AOM_IMG_FMT_I422;
353  return 0;
354  case AV_PIX_FMT_YUV444P:
355  case AV_PIX_FMT_GBRP:
356  enccfg->g_profile = FF_PROFILE_AV1_HIGH;
357  *img_fmt = AOM_IMG_FMT_I444;
358  return 0;
359  case AV_PIX_FMT_GRAY10:
360  case AV_PIX_FMT_GRAY12:
361  enccfg->monochrome = 1;
362  /* Fall-through */
365  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
366  enccfg->g_profile =
367  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
368  *img_fmt = AOM_IMG_FMT_I42016;
369  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
370  return 0;
371  }
372  break;
375  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
376  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
377  *img_fmt = AOM_IMG_FMT_I42216;
378  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
379  return 0;
380  }
381  break;
384  case AV_PIX_FMT_GBRP10:
385  case AV_PIX_FMT_GBRP12:
386  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
387  enccfg->g_profile =
388  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
389  *img_fmt = AOM_IMG_FMT_I44416;
390  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
391  return 0;
392  }
393  break;
394  default:
395  break;
396  }
397  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
398  return AVERROR_INVALIDDATA;
399 }
400 
401 static void set_color_range(AVCodecContext *avctx)
402 {
403  aom_color_range_t aom_cr;
404  switch (avctx->color_range) {
406  case AVCOL_RANGE_MPEG: aom_cr = AOM_CR_STUDIO_RANGE; break;
407  case AVCOL_RANGE_JPEG: aom_cr = AOM_CR_FULL_RANGE; break;
408  default:
409  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
410  avctx->color_range);
411  return;
412  }
413 
414  codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
415 }
416 
417 static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
418 {
419  int sb_dim = (dim + sb_size - 1) / sb_size;
420  int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
421  av_assert0(tile_dim > 0);
422  return (sb_dim + tile_dim - 1) / tile_dim;
423 }
424 
425 static int choose_tiling(AVCodecContext *avctx,
426  struct aom_codec_enc_cfg *enccfg)
427 {
428  AOMContext *ctx = avctx->priv_data;
429  int sb_128x128_possible, sb_size, sb_width, sb_height;
430  int uniform_rows, uniform_cols;
431  int uniform_64x64_possible, uniform_128x128_possible;
432  int tile_size, rounding, i;
433 
434  if (ctx->tile_cols_log2 >= 0)
435  ctx->tile_cols = 1 << ctx->tile_cols_log2;
436  if (ctx->tile_rows_log2 >= 0)
437  ctx->tile_rows = 1 << ctx->tile_rows_log2;
438 
439  if (ctx->tile_cols == 0) {
440  ctx->tile_cols = (avctx->width + AV1_MAX_TILE_WIDTH - 1) /
442  if (ctx->tile_cols > 1) {
443  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
444  "columns to fill width.\n", ctx->tile_cols);
445  }
446  }
447  av_assert0(ctx->tile_cols > 0);
448  if (ctx->tile_rows == 0) {
449  int max_tile_width =
450  FFALIGN((FFALIGN(avctx->width, 128) +
451  ctx->tile_cols - 1) / ctx->tile_cols, 128);
452  ctx->tile_rows =
453  (max_tile_width * FFALIGN(avctx->height, 128) +
455  if (ctx->tile_rows > 1) {
456  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
457  "rows to fill area.\n", ctx->tile_rows);
458  }
459  }
460  av_assert0(ctx->tile_rows > 0);
461 
462  if ((avctx->width + 63) / 64 < ctx->tile_cols ||
463  (avctx->height + 63) / 64 < ctx->tile_rows) {
464  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: frame not "
465  "large enough to fit specified tile arrangement.\n");
466  return AVERROR(EINVAL);
467  }
468  if (ctx->tile_cols > AV1_MAX_TILE_COLS ||
469  ctx->tile_rows > AV1_MAX_TILE_ROWS) {
470  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
471  "not allow more than %dx%d tiles.\n",
473  return AVERROR(EINVAL);
474  }
475  if (avctx->width / ctx->tile_cols > AV1_MAX_TILE_WIDTH) {
476  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
477  "not allow tiles of width greater than %d.\n",
479  return AVERROR(EINVAL);
480  }
481 
482  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
483 
484  if (ctx->tile_cols == 1 && ctx->tile_rows == 1) {
485  av_log(avctx, AV_LOG_DEBUG, "Using a single tile.\n");
486  return 0;
487  }
488 
489  sb_128x128_possible =
490  (avctx->width + 127) / 128 >= ctx->tile_cols &&
491  (avctx->height + 127) / 128 >= ctx->tile_rows;
492 
493  ctx->tile_cols_log2 = ctx->tile_cols == 1 ? 0 :
494  av_log2(ctx->tile_cols - 1) + 1;
495  ctx->tile_rows_log2 = ctx->tile_rows == 1 ? 0 :
496  av_log2(ctx->tile_rows - 1) + 1;
497 
498  uniform_cols = count_uniform_tiling(avctx->width,
499  64, ctx->tile_cols_log2);
500  uniform_rows = count_uniform_tiling(avctx->height,
501  64, ctx->tile_rows_log2);
502  av_log(avctx, AV_LOG_DEBUG, "Uniform with 64x64 superblocks "
503  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
504  uniform_64x64_possible = uniform_cols == ctx->tile_cols &&
505  uniform_rows == ctx->tile_rows;
506 
507  if (sb_128x128_possible) {
508  uniform_cols = count_uniform_tiling(avctx->width,
509  128, ctx->tile_cols_log2);
510  uniform_rows = count_uniform_tiling(avctx->height,
511  128, ctx->tile_rows_log2);
512  av_log(avctx, AV_LOG_DEBUG, "Uniform with 128x128 superblocks "
513  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
514  uniform_128x128_possible = uniform_cols == ctx->tile_cols &&
515  uniform_rows == ctx->tile_rows;
516  } else {
517  av_log(avctx, AV_LOG_DEBUG, "128x128 superblocks not possible.\n");
518  uniform_128x128_possible = 0;
519  }
520 
521  ctx->uniform_tiles = 1;
522  if (uniform_64x64_possible && uniform_128x128_possible) {
523  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with dynamic "
524  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
525  ctx->tile_cols_log2, ctx->tile_rows_log2);
526  return 0;
527  }
528  if (uniform_64x64_possible && !sb_128x128_possible) {
529  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 64x64 "
530  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
531  ctx->tile_cols_log2, ctx->tile_rows_log2);
532  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
533  return 0;
534  }
535  if (uniform_128x128_possible) {
536  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 128x128 "
537  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
538  ctx->tile_cols_log2, ctx->tile_rows_log2);
539  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
540  return 0;
541  }
542  ctx->uniform_tiles = 0;
543 
544  if (sb_128x128_possible) {
545  sb_size = 128;
546  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
547  } else {
548  sb_size = 64;
549  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
550  }
551  av_log(avctx, AV_LOG_DEBUG, "Using fixed tiling with %dx%d "
552  "superblocks (tile_cols = %d, tile_rows = %d).\n",
553  sb_size, sb_size, ctx->tile_cols, ctx->tile_rows);
554 
555  enccfg->tile_width_count = ctx->tile_cols;
556  enccfg->tile_height_count = ctx->tile_rows;
557 
558  sb_width = (avctx->width + sb_size - 1) / sb_size;
559  sb_height = (avctx->height + sb_size - 1) / sb_size;
560 
561  tile_size = sb_width / ctx->tile_cols;
562  rounding = sb_width % ctx->tile_cols;
563  for (i = 0; i < ctx->tile_cols; i++) {
564  enccfg->tile_widths[i] = tile_size +
565  (i < rounding / 2 ||
566  i > ctx->tile_cols - 1 - (rounding + 1) / 2);
567  }
568 
569  tile_size = sb_height / ctx->tile_rows;
570  rounding = sb_height % ctx->tile_rows;
571  for (i = 0; i < ctx->tile_rows; i++) {
572  enccfg->tile_heights[i] = tile_size +
573  (i < rounding / 2 ||
574  i > ctx->tile_rows - 1 - (rounding + 1) / 2);
575  }
576 
577  return 0;
578 }
579 
580 static av_cold int aom_init(AVCodecContext *avctx,
581  const struct aom_codec_iface *iface)
582 {
583  AOMContext *ctx = avctx->priv_data;
585  struct aom_codec_enc_cfg enccfg = { 0 };
586 #ifdef AOM_FRAME_IS_INTRAONLY
587  aom_codec_flags_t flags =
588  (avctx->flags & AV_CODEC_FLAG_PSNR) ? AOM_CODEC_USE_PSNR : 0;
589 #else
590  aom_codec_flags_t flags = 0;
591 #endif
592  AVCPBProperties *cpb_props;
593  int res;
594  aom_img_fmt_t img_fmt;
595  aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
596 
597  av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
598  av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
599 
600  if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
601  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
602  aom_codec_err_to_string(res));
603  return AVERROR(EINVAL);
604  }
605 
606  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
607  return AVERROR(EINVAL);
608 
609  if(!avctx->bit_rate)
610  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
611  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
612  return AVERROR(EINVAL);
613  }
614 
615  dump_enc_cfg(avctx, &enccfg, AV_LOG_DEBUG);
616 
617  enccfg.g_w = avctx->width;
618  enccfg.g_h = avctx->height;
619  enccfg.g_timebase.num = avctx->time_base.num;
620  enccfg.g_timebase.den = avctx->time_base.den;
621  enccfg.g_threads =
622  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
623 
624  enccfg.g_usage = ctx->usage;
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:30
AOMEncoderContext::error_resilient
int error_resilient
Definition: libaomenc.c:75
AOMEncoderContext::usage
int usage
Definition: libaomenc.c:98
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:211
AOMEncoderContext::enable_filter_intra
int enable_filter_intra
Definition: libaomenc.c:109
AOMEncoderContext::enable_paeth_intra
int enable_paeth_intra
Definition: libaomenc.c:105
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:90
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AOMEncoderContext::enable_interintra_comp
int enable_interintra_comp
Definition: libaomenc.c:119
level
uint8_t level
Definition: svq3.c:204
FrameListData::pts
int64_t pts
time stamp to show frame (in timebase units)
Definition: libaomenc.c:51
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:914
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AOMEncoderContext::sse
uint64_t sse[4]
Definition: libaomenc.c:81
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:401
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:949
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1190
aom_init
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
Definition: libaomenc.c:580
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:97
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:106
AOMEncoderContext::enable_1to4_partitions
int enable_1to4_partitions
Definition: libaomenc.c:101
FF_AV1_PROFILE_OPTS
#define FF_AV1_PROFILE_OPTS
Definition: profiles.h:54
AOMEncoderContext::denoise_noise_level
int denoise_noise_level
Definition: libaomenc.c:79
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:74
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:942
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:269
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:83
AVOption
AVOption.
Definition: opt.h:248
encode.h
AOMEncoderContext::use_intra_default_tx_only
int use_intra_default_tx_only
Definition: libaomenc.c:115
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: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), 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:252
AOMEncoderContext::aom_params
AVDictionary * aom_params
Definition: libaomenc.c:128
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:1001
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1154
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: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:269
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:55
AOMEncoderContext::cpu_used
int cpu_used
Definition: libaomenc.c:69
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:102
AOMEncoderContext::coded_frame_list
struct FrameListData * coded_frame_list
Definition: libaomenc.c:68
AOMEncoderContext::static_thresh
int static_thresh
Definition: libaomenc.c:77
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:1429
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:405
AOMEncoderContext::minsection_pct
int minsection_pct
Definition: libaomenc.c:86
AOMEncoderContext::uniform_tiles
int uniform_tiles
Definition: libaomenc.c:92
AOMEncoderContext::enable_ref_frame_mvs
int enable_ref_frame_mvs
Definition: libaomenc.c:116
AOMEncoderContext::row_mt
int row_mt
Definition: libaomenc.c:93
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:921
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:464
AOMEncoderContext::denoise_block_size
int denoise_block_size
Definition: libaomenc.c:80
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:114
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:279
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:935
count_uniform_tiling
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
Definition: libaomenc.c:417
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:103
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:1211
AOMEncoderContext::enable_cdef
int enable_cdef
Definition: libaomenc.c:94
AOMEncoderContext::enable_smooth_interintra
int enable_smooth_interintra
Definition: libaomenc.c:124
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:67
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:1233
codecctl_int
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
Definition: libaomenc.c:296
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:516
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:56
AOMEncoderContext::enable_interintra_wedge
int enable_interintra_wedge
Definition: libaomenc.c:118
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1515
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:82
AOMEncoderContext::enable_obmc
int enable_obmc
Definition: libaomenc.c:121
FrameListData::frame_number
uint64_t frame_number
Definition: libaomenc.c:58
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:335
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:1183
AOMEncoderContext::superblock_size
aom_superblock_size_t superblock_size
Definition: libaomenc.c:91
AVCodecContext::error
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1366
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:126
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:370
AVCodecDefault
Definition: internal.h:212
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1168
AOMEncoderContext::drop_threshold
int drop_threshold
Definition: libaomenc.c:78
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:89
NULL
#define NULL
Definition: coverity.c:32
AOMEncoderContext
Definition: libaomenc.c:62
AOMEncoderContext::rc_overshoot_pct
int rc_overshoot_pct
Definition: libaomenc.c:85
AOMEncoderContext::enable_diff_wtd_comp
int enable_diff_wtd_comp
Definition: libaomenc.c:125
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:956
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
AOMEncoderContext::enable_palette
int enable_palette
Definition: libaomenc.c:108
AOMEncoderContext::arnr_max_frames
int arnr_max_frames
Definition: libaomenc.c:71
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:434
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:111
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:49
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:84
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:95
AOMEncoderContext::encoder
struct aom_codec_ctx encoder
Definition: libaomenc.c:65
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:122
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:1139
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:507
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:59
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1225
ctlidstr
static const char *const ctlidstr[]
Definition: libaomenc.c:131
FF_PROFILE_AV1_MAIN
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:1610
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: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:579
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:110
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:168
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:48
AOMEncoderContext::tile_cols_log2
int tile_cols_log2
Definition: libaomenc.c:90
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:240
AOMEncoderContext::tile_cols
int tile_cols
Definition: libaomenc.c:89
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:66
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:127
AOMEncoderContext::aq_mode
int aq_mode
Definition: libaomenc.c:73
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
AOMEncoderContext::enable_cfl_intra
int enable_cfl_intra
Definition: libaomenc.c:104
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:72
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:117
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:557
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:594
FrameListData::duration
unsigned long duration
duration to show frame (in timebase units)
Definition: libaomenc.c:53
AOMEncoderContext::auto_alt_ref
int auto_alt_ref
Definition: libaomenc.c:70
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:1612
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: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: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:64
log_encoder_error
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libaomenc.c:200
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:285
AVCodecContext
main external API structure.
Definition: avcodec.h:384
AOMEncoderContext::enable_rect_partitions
int enable_rect_partitions
Definition: libaomenc.c:100
AVBitStreamFilter
Definition: bsf.h:98
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:77
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1147
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:1514
choose_tiling
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
Definition: libaomenc.c:425
AOMEncoderContext::maxsection_pct
int maxsection_pct
Definition: libaomenc.c:87
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:107
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:70
AOMEncoderContext::enable_reduced_reference_set
int enable_reduced_reference_set
Definition: libaomenc.c:123
AVDictionaryEntry
Definition: dict.h:81
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AOMEncoderContext::frame_parallel
int frame_parallel
Definition: libaomenc.c:88
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
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: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:40
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:557
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:120
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FrameListData::sz
size_t sz
length of compressed data
Definition: libaomenc.c:50
AOMEncoderContext::reduced_tx_type_set
int reduced_tx_type_set
Definition: libaomenc.c:112
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:1611
AVDictionaryEntry::value
char * value
Definition: dict.h:83
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:96
aom_free
static av_cold int aom_free(AVCodecContext *avctx)
Definition: libaomenc.c:323
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:99
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AOMEncoderContext::crf
int crf
Definition: libaomenc.c:76
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:92
AOMEncoderContext::use_intra_dct_only
int use_intra_dct_only
Definition: libaomenc.c:113
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:236
FrameListData::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:57
av1_pix_fmts_highbd_with_gray
static enum AVPixelFormat av1_pix_fmts_highbd_with_gray[]
Definition: libaomenc.c:1213