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 #include <limits.h>
27 
28 #define AOM_DISABLE_CTRL_TYPECHECKS 1
29 #include <aom/aom_encoder.h>
30 #include <aom/aomcx.h>
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/base64.h"
34 #include "libavutil/common.h"
35 #include "libavutil/cpu.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/mem.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/pixdesc.h"
41 
42 #include "av1.h"
43 #include "avcodec.h"
44 #include "bsf.h"
45 #include "codec_internal.h"
46 #include "dovi_rpu.h"
47 #include "encode.h"
48 #include "internal.h"
49 #include "libaom.h"
50 #include "packet_internal.h"
51 #include "profiles.h"
52 
53 /*
54  * Portion of struct aom_codec_cx_pkt from aom_encoder.h.
55  * One encoded frame returned from the library.
56  */
57 struct FrameListData {
58  void *buf; /**< compressed data buffer */
59  size_t sz; /**< length of compressed data */
60  int64_t pts; /**< time stamp to show frame
61  (in timebase units) */
62  unsigned long duration; /**< duration to show frame
63  (in timebase units) */
64  uint32_t flags; /**< flags for this frame */
65  uint64_t sse[4];
66  int have_sse; /**< true if we have pending sse[] */
67  uint64_t frame_number;
68  struct FrameListData *next;
69 };
70 
71 typedef struct AOMEncoderContext {
72  AVClass *class;
73  AVBSFContext *bsf;
74  DOVIContext dovi;
75  struct aom_codec_ctx encoder;
76  struct aom_image rawimg;
77  struct aom_fixed_buf twopass_stats;
78  unsigned twopass_stats_size;
79  struct FrameListData *coded_frame_list;
80  int cpu_used;
81  int auto_alt_ref;
82  int arnr_max_frames;
83  int arnr_strength;
84  int aq_mode;
85  int lag_in_frames;
86  int error_resilient;
87  int crf;
88  int static_thresh;
89  int drop_threshold;
90  int denoise_noise_level;
91  int denoise_block_size;
92  uint64_t sse[4];
93  int have_sse; /**< true if we have pending sse[] */
94  uint64_t frame_number;
95  int rc_undershoot_pct;
96  int rc_overshoot_pct;
97  int minsection_pct;
98  int maxsection_pct;
99  int frame_parallel;
100  int tile_cols, tile_rows;
101  int tile_cols_log2, tile_rows_log2;
102  aom_superblock_size_t superblock_size;
103  int uniform_tiles;
104  int row_mt;
105  int enable_cdef;
106  int enable_global_motion;
107  int enable_intrabc;
108  int enable_restoration;
109  int usage;
110  int tune;
111  int still_picture;
112  int enable_rect_partitions;
113  int enable_1to4_partitions;
114  int enable_ab_partitions;
115  int enable_angle_delta;
116  int enable_cfl_intra;
117  int enable_paeth_intra;
118  int enable_smooth_intra;
119  int enable_intra_edge_filter;
120  int enable_palette;
121  int enable_filter_intra;
122  int enable_flip_idtx;
123  int enable_tx64;
124  int reduced_tx_type_set;
125  int use_intra_dct_only;
126  int use_inter_dct_only;
127  int use_intra_default_tx_only;
128  int enable_ref_frame_mvs;
129  int enable_interinter_wedge;
130  int enable_interintra_wedge;
131  int enable_interintra_comp;
132  int enable_masked_comp;
133  int enable_obmc;
134  int enable_onesided_comp;
135  int enable_reduced_reference_set;
136  int enable_smooth_interintra;
137  int enable_diff_wtd_comp;
138  int enable_dist_wtd_comp;
139  int enable_dual_filter;
140  AVDictionary *aom_params;
141 } AOMContext;
142 
143 #define OFFSET(x) offsetof(AOMContext, x)
144 
145 static const char *const ctlidstr[] = {
146  [AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
147  [AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
148  [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
149  [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
150  [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
151  [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
152  [AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
153  [AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
154  [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
155  [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
156  [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
157  [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
158  [AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
159  [AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
160  [AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
161  [AV1E_SET_ENABLE_RESTORATION] = "AV1E_SET_ENABLE_RESTORATION",
162  [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
163  [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
164  [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
165  [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
166  [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
167  [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
168  [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
169  [AOME_SET_TUNING] = "AOME_SET_TUNING",
170  [AV1E_SET_ENABLE_1TO4_PARTITIONS] = "AV1E_SET_ENABLE_1TO4_PARTITIONS",
171  [AV1E_SET_ENABLE_AB_PARTITIONS] = "AV1E_SET_ENABLE_AB_PARTITIONS",
172  [AV1E_SET_ENABLE_RECT_PARTITIONS] = "AV1E_SET_ENABLE_RECT_PARTITIONS",
173  [AV1E_SET_ENABLE_ANGLE_DELTA] = "AV1E_SET_ENABLE_ANGLE_DELTA",
174  [AV1E_SET_ENABLE_CFL_INTRA] = "AV1E_SET_ENABLE_CFL_INTRA",
175  [AV1E_SET_ENABLE_FILTER_INTRA] = "AV1E_SET_ENABLE_FILTER_INTRA",
176  [AV1E_SET_ENABLE_INTRA_EDGE_FILTER] = "AV1E_SET_ENABLE_INTRA_EDGE_FILTER",
177  [AV1E_SET_ENABLE_PAETH_INTRA] = "AV1E_SET_ENABLE_PAETH_INTRA",
178  [AV1E_SET_ENABLE_SMOOTH_INTRA] = "AV1E_SET_ENABLE_SMOOTH_INTRA",
179  [AV1E_SET_ENABLE_PALETTE] = "AV1E_SET_ENABLE_PALETTE",
180  [AV1E_SET_ENABLE_FLIP_IDTX] = "AV1E_SET_ENABLE_FLIP_IDTX",
181  [AV1E_SET_ENABLE_TX64] = "AV1E_SET_ENABLE_TX64",
182  [AV1E_SET_INTRA_DCT_ONLY] = "AV1E_SET_INTRA_DCT_ONLY",
183  [AV1E_SET_INTER_DCT_ONLY] = "AV1E_SET_INTER_DCT_ONLY",
184  [AV1E_SET_INTRA_DEFAULT_TX_ONLY] = "AV1E_SET_INTRA_DEFAULT_TX_ONLY",
185  [AV1E_SET_REDUCED_TX_TYPE_SET] = "AV1E_SET_REDUCED_TX_TYPE_SET",
186  [AV1E_SET_ENABLE_DIFF_WTD_COMP] = "AV1E_SET_ENABLE_DIFF_WTD_COMP",
187  [AV1E_SET_ENABLE_DIST_WTD_COMP] = "AV1E_SET_ENABLE_DIST_WTD_COMP",
188  [AV1E_SET_ENABLE_DUAL_FILTER] = "AV1E_SET_ENABLE_DUAL_FILTER",
189  [AV1E_SET_ENABLE_INTERINTER_WEDGE] = "AV1E_SET_ENABLE_INTERINTER_WEDGE",
190  [AV1E_SET_ENABLE_INTERINTRA_WEDGE] = "AV1E_SET_ENABLE_INTERINTRA_WEDGE",
191  [AV1E_SET_ENABLE_MASKED_COMP] = "AV1E_SET_ENABLE_MASKED_COMP",
192  [AV1E_SET_ENABLE_INTERINTRA_COMP] = "AV1E_SET_ENABLE_INTERINTRA_COMP",
193  [AV1E_SET_ENABLE_OBMC] = "AV1E_SET_ENABLE_OBMC",
194  [AV1E_SET_ENABLE_ONESIDED_COMP] = "AV1E_SET_ENABLE_ONESIDED_COMP",
195  [AV1E_SET_REDUCED_REFERENCE_SET] = "AV1E_SET_REDUCED_REFERENCE_SET",
196  [AV1E_SET_ENABLE_SMOOTH_INTERINTRA] = "AV1E_SET_ENABLE_SMOOTH_INTERINTRA",
197  [AV1E_SET_ENABLE_REF_FRAME_MVS] = "AV1E_SET_ENABLE_REF_FRAME_MVS",
198 #ifdef AOM_CTRL_AV1E_GET_NUM_OPERATING_POINTS
199  [AV1E_GET_NUM_OPERATING_POINTS] = "AV1E_GET_NUM_OPERATING_POINTS",
200 #endif
201  [AV1E_GET_SEQ_LEVEL_IDX] = "AV1E_GET_SEQ_LEVEL_IDX",
202 #ifdef AOM_CTRL_AV1E_GET_TARGET_SEQ_LEVEL_IDX
203  [AV1E_GET_TARGET_SEQ_LEVEL_IDX] = "AV1E_GET_TARGET_SEQ_LEVEL_IDX",
204 #endif
205  [AV1_GET_NEW_FRAME_IMAGE] = "AV1_GET_NEW_FRAME_IMAGE",
206 };
207 
208 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
209 {
210  AOMContext *ctx = avctx->priv_data;
211  const char *error = aom_codec_error(&ctx->encoder);
212  const char *detail = aom_codec_error_detail(&ctx->encoder);
213 
214  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
215  if (detail)
216  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
217 }
218 
219 static av_cold void dump_enc_cfg(AVCodecContext *avctx,
220  const struct aom_codec_enc_cfg *cfg,
221  int level)
222 {
223  int width = -30;
224 
225  av_log(avctx, level, "aom_codec_enc_cfg\n");
226  av_log(avctx, level, "generic settings\n"
227  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
228  " %*s%u\n %*s%u\n"
229  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
230  width, "g_usage:", cfg->g_usage,
231  width, "g_threads:", cfg->g_threads,
232  width, "g_profile:", cfg->g_profile,
233  width, "g_w:", cfg->g_w,
234  width, "g_h:", cfg->g_h,
235  width, "g_bit_depth:", cfg->g_bit_depth,
236  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
237  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
238  width, "g_error_resilient:", cfg->g_error_resilient,
239  width, "g_pass:", cfg->g_pass,
240  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
241  av_log(avctx, level, "rate control settings\n"
242  " %*s%u\n %*s%d\n %*s%p(%"SIZE_SPECIFIER")\n %*s%u\n",
243  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
244  width, "rc_end_usage:", cfg->rc_end_usage,
245  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
246  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
247  av_log(avctx, level, "quantizer settings\n"
248  " %*s%u\n %*s%u\n",
249  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
250  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
251  av_log(avctx, level, "bitrate tolerance\n"
252  " %*s%u\n %*s%u\n",
253  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
254  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
255  av_log(avctx, level, "decoder buffer model\n"
256  " %*s%u\n %*s%u\n %*s%u\n",
257  width, "rc_buf_sz:", cfg->rc_buf_sz,
258  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
259  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
260  av_log(avctx, level, "2 pass rate control settings\n"
261  " %*s%u\n %*s%u\n %*s%u\n",
262  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
263  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
264  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
265  av_log(avctx, level, "keyframing settings\n"
266  " %*s%d\n %*s%u\n %*s%u\n",
267  width, "kf_mode:", cfg->kf_mode,
268  width, "kf_min_dist:", cfg->kf_min_dist,
269  width, "kf_max_dist:", cfg->kf_max_dist);
270  av_log(avctx, level, "tile settings\n"
271  " %*s%d\n %*s%d\n",
272  width, "tile_width_count:", cfg->tile_width_count,
273  width, "tile_height_count:", cfg->tile_height_count);
274  av_log(avctx, level, "\n");
275 }
276 
277 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
278 {
279  struct FrameListData **p = list;
280 
281  while (*p)
282  p = &(*p)->next;
283  *p = cx_frame;
284  cx_frame->next = NULL;
285 }
286 
287 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
288 {
289  av_freep(&cx_frame->buf);
290  av_freep(&cx_frame);
291 }
292 
293 static av_cold void free_frame_list(struct FrameListData *list)
294 {
295  struct FrameListData *p = list;
296 
297  while (p) {
298  list = list->next;
299  free_coded_frame(p);
300  p = list;
301  }
302 }
303 
304 static av_cold int codecctl_int(AVCodecContext *avctx,
305 #ifdef UENUM1BYTE
306  aome_enc_control_id id,
307 #else
308  enum aome_enc_control_id id,
309 #endif
310  int val)
311 {
312  AOMContext *ctx = avctx->priv_data;
313  char buf[80];
314  int width = -30;
315  int res;
316 
317  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
318  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
319 
320  res = aom_codec_control(&ctx->encoder, id, val);
321  if (res != AOM_CODEC_OK) {
322  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
323  ctlidstr[id]);
324  log_encoder_error(avctx, buf);
325  return AVERROR(EINVAL);
326  }
327 
328  return 0;
329 }
330 
331 #if defined(AOM_CTRL_AV1E_GET_NUM_OPERATING_POINTS) && \
332  defined(AOM_CTRL_AV1E_GET_SEQ_LEVEL_IDX) && \
333  defined(AOM_CTRL_AV1E_GET_TARGET_SEQ_LEVEL_IDX)
334 static av_cold int codecctl_intp(AVCodecContext *avctx,
335 #ifdef UENUM1BYTE
336  aome_enc_control_id id,
337 #else
338  enum aome_enc_control_id id,
339 #endif
340  int* ptr)
341 {
342  AOMContext *ctx = avctx->priv_data;
343  char buf[80];
344  int width = -30;
345  int res;
346 
347  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
348  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, *ptr);
349 
350  res = aom_codec_control(&ctx->encoder, id, ptr);
351  if (res != AOM_CODEC_OK) {
352  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
353  ctlidstr[id]);
354  log_encoder_error(avctx, buf);
355  return AVERROR(EINVAL);
356  }
357 
358  return 0;
359 }
360 #endif
361 
362 static av_cold int codecctl_imgp(AVCodecContext *avctx,
363 #ifdef UENUM1BYTE
364  aome_enc_control_id id,
365 #else
366  enum aome_enc_control_id id,
367 #endif
368  struct aom_image *img)
369 {
370  AOMContext *ctx = avctx->priv_data;
371  char buf[80];
372  int res;
373 
374  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
375 
376  res = aom_codec_control(&ctx->encoder, id, img);
377  if (res != AOM_CODEC_OK) {
378  snprintf(buf, sizeof(buf), "Failed to get %s codec control",
379  ctlidstr[id]);
380  log_encoder_error(avctx, buf);
381  return AVERROR(EINVAL);
382  }
383 
384  return 0;
385 }
386 
387 static av_cold int aom_free(AVCodecContext *avctx)
388 {
389  AOMContext *ctx = avctx->priv_data;
390 
391 #if defined(AOM_CTRL_AV1E_GET_NUM_OPERATING_POINTS) && \
392  defined(AOM_CTRL_AV1E_GET_SEQ_LEVEL_IDX) && \
393  defined(AOM_CTRL_AV1E_GET_TARGET_SEQ_LEVEL_IDX)
394  if (ctx->encoder.iface && !(avctx->flags & AV_CODEC_FLAG_PASS1)) {
395  int num_operating_points;
396  int levels[32];
397  int target_levels[32];
398 
399  if (!codecctl_intp(avctx, AV1E_GET_NUM_OPERATING_POINTS,
400  &num_operating_points) &&
401  !codecctl_intp(avctx, AV1E_GET_SEQ_LEVEL_IDX, levels) &&
402  !codecctl_intp(avctx, AV1E_GET_TARGET_SEQ_LEVEL_IDX,
403  target_levels)) {
404  for (int i = 0; i < num_operating_points; i++) {
405  if (levels[i] > target_levels[i]) {
406  // Warn when the target level was not met
407  av_log(avctx, AV_LOG_WARNING,
408  "Could not encode to target level %d.%d for "
409  "operating point %d. The output level is %d.%d.\n",
410  2 + (target_levels[i] >> 2), target_levels[i] & 3,
411  i, 2 + (levels[i] >> 2), levels[i] & 3);
412  } else if (target_levels[i] < 31) {
413  // Log the encoded level if a target level was given
414  av_log(avctx, AV_LOG_INFO,
415  "Output level for operating point %d is %d.%d.\n",
416  i, 2 + (levels[i] >> 2), levels[i] & 3);
417  }
418  }
419  }
420  }
421 #endif
422 
423  aom_codec_destroy(&ctx->encoder);
424  aom_img_remove_metadata(&ctx->rawimg);
425  av_freep(&ctx->twopass_stats.buf);
426  av_freep(&avctx->stats_out);
427  free_frame_list(ctx->coded_frame_list);
428  av_bsf_free(&ctx->bsf);
429  ff_dovi_ctx_unref(&ctx->dovi);
430  return 0;
431 }
432 
433 static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
434  struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
435  aom_img_fmt_t *img_fmt)
436 {
437  AOMContext av_unused *ctx = avctx->priv_data;
438  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
439  enccfg->g_bit_depth = enccfg->g_input_bit_depth = desc->comp[0].depth;
440  switch (avctx->pix_fmt) {
441  case AV_PIX_FMT_GRAY8:
442  enccfg->monochrome = 1;
443  /* Fall-through */
444  case AV_PIX_FMT_YUV420P:
445  enccfg->g_profile = AV_PROFILE_AV1_MAIN;
446  *img_fmt = AOM_IMG_FMT_I420;
447  return 0;
448  case AV_PIX_FMT_YUV422P:
449  enccfg->g_profile = AV_PROFILE_AV1_PROFESSIONAL;
450  *img_fmt = AOM_IMG_FMT_I422;
451  return 0;
452  case AV_PIX_FMT_YUV444P:
453  case AV_PIX_FMT_GBRP:
454  enccfg->g_profile = AV_PROFILE_AV1_HIGH;
455  *img_fmt = AOM_IMG_FMT_I444;
456  return 0;
457  case AV_PIX_FMT_GRAY10:
458  case AV_PIX_FMT_GRAY12:
459  enccfg->monochrome = 1;
460  /* Fall-through */
461  case AV_PIX_FMT_YUV420P10:
462  case AV_PIX_FMT_YUV420P12:
463  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
464  enccfg->g_profile =
465  enccfg->g_bit_depth == 10 ? AV_PROFILE_AV1_MAIN : AV_PROFILE_AV1_PROFESSIONAL;
466  *img_fmt = AOM_IMG_FMT_I42016;
467  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
468  return 0;
469  }
470  break;
471  case AV_PIX_FMT_YUV422P10:
472  case AV_PIX_FMT_YUV422P12:
473  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
474  enccfg->g_profile = AV_PROFILE_AV1_PROFESSIONAL;
475  *img_fmt = AOM_IMG_FMT_I42216;
476  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
477  return 0;
478  }
479  break;
480  case AV_PIX_FMT_YUV444P10:
481  case AV_PIX_FMT_YUV444P12:
482  case AV_PIX_FMT_GBRP10:
483  case AV_PIX_FMT_GBRP12:
484  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
485  enccfg->g_profile =
486  enccfg->g_bit_depth == 10 ? AV_PROFILE_AV1_HIGH : AV_PROFILE_AV1_PROFESSIONAL;
487  *img_fmt = AOM_IMG_FMT_I44416;
488  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
489  return 0;
490  }
491  break;
492  default:
493  break;
494  }
495  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
496  return AVERROR_INVALIDDATA;
497 }
498 
499 static void set_color_range(AVCodecContext *avctx)
500 {
501  aom_color_range_t aom_cr;
502  switch (avctx->color_range) {
503  case AVCOL_RANGE_UNSPECIFIED:
504  case AVCOL_RANGE_MPEG: aom_cr = AOM_CR_STUDIO_RANGE; break;
505  case AVCOL_RANGE_JPEG: aom_cr = AOM_CR_FULL_RANGE; break;
506  default:
507  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
508  avctx->color_range);
509  return;
510  }
511 
512  codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
513 }
514 
515 static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
516 {
517  int sb_dim = (dim + sb_size - 1) / sb_size;
518  int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
519  av_assert0(tile_dim > 0);
520  return (sb_dim + tile_dim - 1) / tile_dim;
521 }
522 
523 static int choose_tiling(AVCodecContext *avctx,
524  struct aom_codec_enc_cfg *enccfg)
525 {
526  AOMContext *ctx = avctx->priv_data;
527  int sb_128x128_possible, sb_size, sb_width, sb_height;
528  int uniform_rows, uniform_cols;
529  int uniform_64x64_possible, uniform_128x128_possible;
530  int tile_size, rounding, i;
531 
532  if (ctx->tile_cols_log2 >= 0)
533  ctx->tile_cols = 1 << ctx->tile_cols_log2;
534  if (ctx->tile_rows_log2 >= 0)
535  ctx->tile_rows = 1 << ctx->tile_rows_log2;
536 
537  if (ctx->tile_cols == 0) {
538  ctx->tile_cols = (avctx->width + AV1_MAX_TILE_WIDTH - 1) /
539  AV1_MAX_TILE_WIDTH;
540  if (ctx->tile_cols > 1) {
541  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
542  "columns to fill width.\n", ctx->tile_cols);
543  }
544  }
545  av_assert0(ctx->tile_cols > 0);
546  if (ctx->tile_rows == 0) {
547  int max_tile_width =
548  FFALIGN((FFALIGN(avctx->width, 128) +
549  ctx->tile_cols - 1) / ctx->tile_cols, 128);
550  ctx->tile_rows =
551  (max_tile_width * FFALIGN(avctx->height, 128) +
552  AV1_MAX_TILE_AREA - 1) / AV1_MAX_TILE_AREA;
553  if (ctx->tile_rows > 1) {
554  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
555  "rows to fill area.\n", ctx->tile_rows);
556  }
557  }
558  av_assert0(ctx->tile_rows > 0);
559 
560  if ((avctx->width + 63) / 64 < ctx->tile_cols ||
561  (avctx->height + 63) / 64 < ctx->tile_rows) {
562  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: frame not "
563  "large enough to fit specified tile arrangement.\n");
564  return AVERROR(EINVAL);
565  }
566  if (ctx->tile_cols > AV1_MAX_TILE_COLS ||
567  ctx->tile_rows > AV1_MAX_TILE_ROWS) {
568  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
569  "not allow more than %dx%d tiles.\n",
570  AV1_MAX_TILE_COLS, AV1_MAX_TILE_ROWS);
571  return AVERROR(EINVAL);
572  }
573  if (avctx->width / ctx->tile_cols > AV1_MAX_TILE_WIDTH) {
574  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
575  "not allow tiles of width greater than %d.\n",
576  AV1_MAX_TILE_WIDTH);
577  return AVERROR(EINVAL);
578  }
579 
580  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
581 
582  if (ctx->tile_cols == 1 && ctx->tile_rows == 1) {
583  av_log(avctx, AV_LOG_DEBUG, "Using a single tile.\n");
584  return 0;
585  }
586 
587  sb_128x128_possible =
588  (avctx->width + 127) / 128 >= ctx->tile_cols &&
589  (avctx->height + 127) / 128 >= ctx->tile_rows;
590 
591  ctx->tile_cols_log2 = ctx->tile_cols == 1 ? 0 :
592  av_log2(ctx->tile_cols - 1) + 1;
593  ctx->tile_rows_log2 = ctx->tile_rows == 1 ? 0 :
594  av_log2(ctx->tile_rows - 1) + 1;
595 
596  uniform_cols = count_uniform_tiling(avctx->width,
597  64, ctx->tile_cols_log2);
598  uniform_rows = count_uniform_tiling(avctx->height,
599  64, ctx->tile_rows_log2);
600  av_log(avctx, AV_LOG_DEBUG, "Uniform with 64x64 superblocks "
601  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
602  uniform_64x64_possible = uniform_cols == ctx->tile_cols &&
603  uniform_rows == ctx->tile_rows;
604 
605  if (sb_128x128_possible) {
606  uniform_cols = count_uniform_tiling(avctx->width,
607  128, ctx->tile_cols_log2);
608  uniform_rows = count_uniform_tiling(avctx->height,
609  128, ctx->tile_rows_log2);
610  av_log(avctx, AV_LOG_DEBUG, "Uniform with 128x128 superblocks "
611  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
612  uniform_128x128_possible = uniform_cols == ctx->tile_cols &&
613  uniform_rows == ctx->tile_rows;
614  } else {
615  av_log(avctx, AV_LOG_DEBUG, "128x128 superblocks not possible.\n");
616  uniform_128x128_possible = 0;
617  }
618 
619  ctx->uniform_tiles = 1;
620  if (uniform_64x64_possible && uniform_128x128_possible) {
621  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with dynamic "
622  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
623  ctx->tile_cols_log2, ctx->tile_rows_log2);
624  return 0;
625  }
626  if (uniform_64x64_possible && !sb_128x128_possible) {
627  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 64x64 "
628  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
629  ctx->tile_cols_log2, ctx->tile_rows_log2);
630  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
631  return 0;
632  }
633  if (uniform_128x128_possible) {
634  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 128x128 "
635  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
636  ctx->tile_cols_log2, ctx->tile_rows_log2);
637  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
638  return 0;
639  }
640  ctx->uniform_tiles = 0;
641 
642  if (sb_128x128_possible) {
643  sb_size = 128;
644  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
645  } else {
646  sb_size = 64;
647  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
648  }
649  av_log(avctx, AV_LOG_DEBUG, "Using fixed tiling with %dx%d "
650  "superblocks (tile_cols = %d, tile_rows = %d).\n",
651  sb_size, sb_size, ctx->tile_cols, ctx->tile_rows);
652 
653  enccfg->tile_width_count = ctx->tile_cols;
654  enccfg->tile_height_count = ctx->tile_rows;
655 
656  sb_width = (avctx->width + sb_size - 1) / sb_size;
657  sb_height = (avctx->height + sb_size - 1) / sb_size;
658 
659  tile_size = sb_width / ctx->tile_cols;
660  rounding = sb_width % ctx->tile_cols;
661  for (i = 0; i < ctx->tile_cols; i++) {
662  enccfg->tile_widths[i] = tile_size +
663  (i < rounding / 2 ||
664  i > ctx->tile_cols - 1 - (rounding + 1) / 2);
665  }
666 
667  tile_size = sb_height / ctx->tile_rows;
668  rounding = sb_height % ctx->tile_rows;
669  for (i = 0; i < ctx->tile_rows; i++) {
670  enccfg->tile_heights[i] = tile_size +
671  (i < rounding / 2 ||
672  i > ctx->tile_rows - 1 - (rounding + 1) / 2);
673  }
674 
675  return 0;
676 }
677 
678 
679 static const struct {
680  int aom_enum;
681  unsigned offset;
682 } option_map[] = {
683  { AOME_SET_ENABLEAUTOALTREF, OFFSET(auto_alt_ref) },
684  { AOME_SET_ARNR_MAXFRAMES, OFFSET(arnr_max_frames) },
685  { AOME_SET_ARNR_STRENGTH, OFFSET(arnr_strength) },
686  { AV1E_SET_ENABLE_CDEF, OFFSET(enable_cdef) },
687  { AV1E_SET_ENABLE_RESTORATION, OFFSET(enable_restoration) },
688  { AV1E_SET_ENABLE_RECT_PARTITIONS, OFFSET(enable_rect_partitions) },
689  { AV1E_SET_ENABLE_1TO4_PARTITIONS, OFFSET(enable_1to4_partitions) },
690  { AV1E_SET_ENABLE_AB_PARTITIONS, OFFSET(enable_ab_partitions) },
691  { AV1E_SET_ENABLE_ANGLE_DELTA, OFFSET(enable_angle_delta) },
692  { AV1E_SET_ENABLE_CFL_INTRA, OFFSET(enable_cfl_intra) },
693  { AV1E_SET_ENABLE_FILTER_INTRA, OFFSET(enable_filter_intra) },
694  { AV1E_SET_ENABLE_INTRA_EDGE_FILTER, OFFSET(enable_intra_edge_filter) },
695  { AV1E_SET_ENABLE_PAETH_INTRA, OFFSET(enable_paeth_intra) },
696  { AV1E_SET_ENABLE_SMOOTH_INTRA, OFFSET(enable_smooth_intra) },
697  { AV1E_SET_ENABLE_PALETTE, OFFSET(enable_palette) },
698  { AV1E_SET_ENABLE_TX64, OFFSET(enable_tx64) },
699  { AV1E_SET_ENABLE_FLIP_IDTX, OFFSET(enable_flip_idtx) },
700  { AV1E_SET_INTRA_DCT_ONLY, OFFSET(use_intra_dct_only) },
701  { AV1E_SET_INTER_DCT_ONLY, OFFSET(use_inter_dct_only) },
702  { AV1E_SET_INTRA_DEFAULT_TX_ONLY, OFFSET(use_intra_default_tx_only) },
703  { AV1E_SET_REDUCED_TX_TYPE_SET, OFFSET(reduced_tx_type_set) },
704  { AV1E_SET_ENABLE_REF_FRAME_MVS, OFFSET(enable_ref_frame_mvs) },
705  { AV1E_SET_REDUCED_REFERENCE_SET, OFFSET(enable_reduced_reference_set) },
706  { AV1E_SET_ENABLE_DIFF_WTD_COMP, OFFSET(enable_diff_wtd_comp) },
707  { AV1E_SET_ENABLE_DIST_WTD_COMP, OFFSET(enable_dist_wtd_comp) },
708  { AV1E_SET_ENABLE_DUAL_FILTER, OFFSET(enable_dual_filter) },
709  { AV1E_SET_ENABLE_INTERINTER_WEDGE, OFFSET(enable_interinter_wedge) },
710  { AV1E_SET_ENABLE_MASKED_COMP, OFFSET(enable_masked_comp) },
711  { AV1E_SET_ENABLE_INTERINTRA_COMP, OFFSET(enable_interintra_comp) },
712  { AV1E_SET_ENABLE_INTERINTRA_WEDGE, OFFSET(enable_interintra_wedge) },
713  { AV1E_SET_ENABLE_OBMC, OFFSET(enable_obmc) },
714  { AV1E_SET_ENABLE_ONESIDED_COMP, OFFSET(enable_onesided_comp) },
715  { AV1E_SET_ENABLE_SMOOTH_INTERINTRA, OFFSET(enable_smooth_interintra) },
716 };
717 
718 static av_cold int aom_init(AVCodecContext *avctx,
719  const struct aom_codec_iface *iface)
720 {
721  AOMContext *ctx = avctx->priv_data;
722  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
723  struct aom_codec_enc_cfg enccfg = { 0 };
724  aom_codec_flags_t flags =
725  (avctx->flags & AV_CODEC_FLAG_PSNR) ? AOM_CODEC_USE_PSNR : 0;
726  int res;
727  aom_img_fmt_t img_fmt;
728  aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
729 
730  av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
731  av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
732 
733  if ((res = aom_codec_enc_config_default(iface, &enccfg, ctx->usage)) != AOM_CODEC_OK) {
734  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
735  aom_codec_err_to_string(res));
736  return AVERROR(EINVAL);
737  }
738 
739  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
740  return AVERROR(EINVAL);
741 
742  if(!avctx->bit_rate)
743  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
744  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
745  return AVERROR(EINVAL);
746  }
747 
748  dump_enc_cfg(avctx, &enccfg, AV_LOG_DEBUG);
749 
750  enccfg.g_w = avctx->width;
751  enccfg.g_h = avctx->height;
752  enccfg.g_timebase.num = avctx->time_base.num;
753  enccfg.g_timebase.den = avctx->time_base.den;
754  enccfg.g_threads =
755  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
756 
757  if (ctx->lag_in_frames >= 0)
758  enccfg.g_lag_in_frames = ctx->lag_in_frames;
759 
760  if (avctx->flags & AV_CODEC_FLAG_PASS1)
761  enccfg.g_pass = AOM_RC_FIRST_PASS;
762  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
763  enccfg.g_pass = AOM_RC_LAST_PASS;
764  else
765  enccfg.g_pass = AOM_RC_ONE_PASS;
766 
767  if (avctx->rc_min_rate == avctx->rc_max_rate &&
768  avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
769  enccfg.rc_end_usage = AOM_CBR;
770  } else if (ctx->crf >= 0) {
771  enccfg.rc_end_usage = AOM_CQ;
772  if (!avctx->bit_rate)
773  enccfg.rc_end_usage = AOM_Q;
774  }
775 
776  if (avctx->bit_rate) {
777  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
778  AV_ROUND_NEAR_INF);
779  } else if (enccfg.rc_end_usage != AOM_Q) {
780  enccfg.rc_end_usage = AOM_Q;
781  ctx->crf = 32;
782  av_log(avctx, AV_LOG_WARNING,
783  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
784  ctx->crf);
785  }
786 
787  if (avctx->qmin >= 0)
788  enccfg.rc_min_quantizer = avctx->qmin;
789  if (avctx->qmax >= 0) {
790  enccfg.rc_max_quantizer = avctx->qmax;
791  } else if (!ctx->crf) {
792  enccfg.rc_max_quantizer = 0;
793  }
794 
795  if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
796  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
797  av_log(avctx, AV_LOG_ERROR,
798  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
799  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
800  return AVERROR(EINVAL);
801  }
802  }
803 
804  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
805 
806  // 0-100 (0 => CBR, 100 => VBR)
807  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
808  if (ctx->minsection_pct >= 0)
809  enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
810  else if (avctx->bit_rate)
811  enccfg.rc_2pass_vbr_minsection_pct =
812  avctx->rc_min_rate * 100LL / avctx->bit_rate;
813  if (ctx->maxsection_pct >= 0)
814  enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
815  else if (avctx->rc_max_rate)
816  enccfg.rc_2pass_vbr_maxsection_pct =
817  avctx->rc_max_rate * 100LL / avctx->bit_rate;
818 
819  if (avctx->rc_buffer_size)
820  enccfg.rc_buf_sz =
821  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
822  if (avctx->rc_initial_buffer_occupancy)
823  enccfg.rc_buf_initial_sz =
824  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
825  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
826 
827  if (ctx->rc_undershoot_pct >= 0)
828  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
829  if (ctx->rc_overshoot_pct >= 0)
830  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
831 
832  // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
833  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
834  enccfg.kf_min_dist = avctx->keyint_min;
835  if (avctx->gop_size >= 0)
836  enccfg.kf_max_dist = avctx->gop_size;
837 
838  if (enccfg.g_pass == AOM_RC_FIRST_PASS)
839  enccfg.g_lag_in_frames = 0;
840  else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
841  int decode_size, ret;
842 
843  if (!avctx->stats_in) {
844  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
845  return AVERROR_INVALIDDATA;
846  }
847 
848  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
849  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
850  if (ret < 0) {
851  av_log(avctx, AV_LOG_ERROR,
852  "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
853  ctx->twopass_stats.sz);
854  ctx->twopass_stats.sz = 0;
855  return ret;
856  }
857  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
858  ctx->twopass_stats.sz);
859  if (decode_size < 0) {
860  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
861  return AVERROR_INVALIDDATA;
862  }
863 
864  ctx->twopass_stats.sz = decode_size;
865  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
866  }
867 
868  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
869  * complexity playback on low powered devices at the expense of encode
870  * quality. */
871  if (avctx->profile != AV_PROFILE_UNKNOWN)
872  enccfg.g_profile = avctx->profile;
873 
874  enccfg.g_error_resilient = ctx->error_resilient;
875 
876  res = choose_tiling(avctx, &enccfg);
877  if (res < 0)
878  return res;
879 
880  if (ctx->still_picture) {
881  // Set the maximum number of frames to 1. This will let libaom set
882  // still_picture and reduced_still_picture_header to 1 in the Sequence
883  // Header as required by AVIF still images.
884  enccfg.g_limit = 1;
885  // Reduce memory usage for still images.
886  enccfg.g_lag_in_frames = 0;
887  // All frames will be key frames.
888  enccfg.kf_max_dist = 0;
889  enccfg.kf_mode = AOM_KF_DISABLED;
890  }
891 
892  /* Construct Encoder Context */
893  res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
894  if (res != AOM_CODEC_OK) {
895  dump_enc_cfg(avctx, &enccfg, AV_LOG_WARNING);
896  log_encoder_error(avctx, "Failed to initialize encoder");
897  return AVERROR(EINVAL);
898  }
899  dump_enc_cfg(avctx, &enccfg, AV_LOG_DEBUG);
900 
901  // codec control failures are currently treated only as warnings
902  av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
903  codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
904 
905  for (size_t i = 0; i < FF_ARRAY_ELEMS(option_map); ++i) {
906  int val = *(int*)((char*)ctx + option_map[i].offset);
907  if (val >= 0)
908  codecctl_int(avctx, option_map[i].aom_enum, val);
909  }
910  codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
911  if (ctx->crf >= 0)
912  codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
913  if (ctx->tune >= 0)
914  codecctl_int(avctx, AOME_SET_TUNING, ctx->tune);
915 
916  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
917  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, AVCOL_PRI_BT709);
918  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, AVCOL_SPC_RGB);
919  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, AVCOL_TRC_IEC61966_2_1);
920  } else {
921  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
922  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
923  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
924  }
925  if (ctx->aq_mode >= 0)
926  codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
927  if (ctx->frame_parallel >= 0)
928  codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
929  set_color_range(avctx);
930 
931  codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
932  if (ctx->uniform_tiles) {
933  codecctl_int(avctx, AV1E_SET_TILE_COLUMNS, ctx->tile_cols_log2);
934  codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
935  }
936 
937  if (ctx->denoise_noise_level >= 0)
938  codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
939  if (ctx->denoise_block_size >= 0)
940  codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
941  if (ctx->enable_global_motion >= 0)
942  codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
943  if (avctx->refs >= 3) {
944  codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
945  }
946  if (ctx->row_mt >= 0)
947  codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
948  if (ctx->enable_intrabc >= 0)
949  codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
950 
951 #if AOM_ENCODER_ABI_VERSION >= 23
952  {
953  const AVDictionaryEntry *en = NULL;
954 
955  while ((en = av_dict_iterate(ctx->aom_params, en))) {
956  int ret = aom_codec_set_option(&ctx->encoder, en->key, en->value);
957  if (ret != AOM_CODEC_OK) {
958  log_encoder_error(avctx, en->key);
959  return AVERROR_EXTERNAL;
960  }
961  }
962  }
963 #endif
964 
965  // provide dummy value to initialize wrapper, values will be updated each _encode()
966  aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
967  (unsigned char*)1);
968 
969  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
970  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
971 
972  ctx->dovi.logctx = avctx;
973  if ((res = ff_dovi_configure(&ctx->dovi, avctx)) < 0)
974  return res;
975 
976  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
977  const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
978  int ret;
979 
980  if (!filter) {
981  av_log(avctx, AV_LOG_ERROR, "extract_extradata bitstream filter "
982  "not found. This is a bug, please report it.\n");
983  return AVERROR_BUG;
984  }
985  ret = av_bsf_alloc(filter, &ctx->bsf);
986  if (ret < 0)
987  return ret;
988 
989  ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx);
990  if (ret < 0)
991  return ret;
992 
993  ret = av_bsf_init(ctx->bsf);
994  if (ret < 0)
995  return ret;
996  }
997 
998  AVCPBProperties *cpb_props = ff_encode_add_cpb_side_data(avctx);
999  if (!cpb_props)
1000  return AVERROR(ENOMEM);
1001 
1002  if (enccfg.rc_end_usage == AOM_CBR ||
1003  enccfg.g_pass != AOM_RC_ONE_PASS) {
1004  cpb_props->max_bitrate = avctx->rc_max_rate;
1005  cpb_props->min_bitrate = avctx->rc_min_rate;
1006  cpb_props->avg_bitrate = avctx->bit_rate;
1007  }
1008  cpb_props->buffer_size = avctx->rc_buffer_size;
1009 
1010  return 0;
1011 }
1012 
1013 static inline void cx_pktcpy(AOMContext *ctx,
1014  struct FrameListData *dst,
1015  const struct aom_codec_cx_pkt *src)
1016 {
1017  dst->pts = src->data.frame.pts;
1018  dst->duration = src->data.frame.duration;
1019  dst->flags = src->data.frame.flags;
1020  dst->sz = src->data.frame.sz;
1021  dst->buf = src->data.frame.buf;
1022  dst->frame_number = ++ctx->frame_number;
1023  dst->have_sse = ctx->have_sse;
1024  if (ctx->have_sse) {
1025  /* associate last-seen SSE to the frame. */
1026  /* Transfers ownership from ctx to dst. */
1027  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
1028  ctx->have_sse = 0;
1029  }
1030 }
1031 
1032 /**
1033  * Store coded frame information in format suitable for return from encode2().
1034  *
1035  * Write information from @a cx_frame to @a pkt
1036  * @return packet data size on success
1037  * @return a negative AVERROR on error
1038  */
1039 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
1040  AVPacket *pkt)
1041 {
1042  AOMContext *ctx = avctx->priv_data;
1043  int av_unused pict_type;
1044  int ret = ff_get_encode_buffer(avctx, pkt, cx_frame->sz, 0);
1045  if (ret < 0) {
1046  av_log(avctx, AV_LOG_ERROR,
1047  "Error getting output packet of size %"SIZE_SPECIFIER".\n", cx_frame->sz);
1048  return ret;
1049  }
1050  memcpy(pkt->data, cx_frame->buf, pkt->size);
1051  pkt->pts = pkt->dts = cx_frame->pts;
1052  pkt->duration = cx_frame->duration;
1053 
1054  if (!!(cx_frame->flags & AOM_FRAME_IS_KEY)) {
1055  pkt->flags |= AV_PKT_FLAG_KEY;
1056  pict_type = AV_PICTURE_TYPE_I;
1057  } else if (cx_frame->flags & AOM_FRAME_IS_INTRAONLY) {
1058  pict_type = AV_PICTURE_TYPE_I;
1059  } else {
1060  pict_type = AV_PICTURE_TYPE_P;
1061  }
1062 
1063  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
1064  cx_frame->have_sse ? 3 : 0, pict_type);
1065 
1066  if (cx_frame->have_sse) {
1067  int i;
1068  for (i = 0; i < 3; ++i) {
1069  avctx->error[i] += cx_frame->sse[i + 1];
1070  }
1071  cx_frame->have_sse = 0;
1072  }
1073 
1074  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1075  ret = av_bsf_send_packet(ctx->bsf, pkt);
1076  if (ret < 0) {
1077  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
1078  "failed to send input packet\n");
1079  return ret;
1080  }
1081  ret = av_bsf_receive_packet(ctx->bsf, pkt);
1082 
1083  if (ret < 0) {
1084  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
1085  "failed to receive output packet\n");
1086  return ret;
1087  }
1088  }
1089  return pkt->size;
1090 }
1091 
1092 /**
1093  * Queue multiple output frames from the encoder, returning the front-most.
1094  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
1095  * the frame queue. Return the head frame if available.
1096  * @return Stored frame size
1097  * @return AVERROR(EINVAL) on output size error
1098  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
1099  */
1100 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
1101 {
1102  AOMContext *ctx = avctx->priv_data;
1103  const struct aom_codec_cx_pkt *pkt;
1104  const void *iter = NULL;
1105  int size = 0;
1106 
1107  if (ctx->coded_frame_list) {
1108  struct FrameListData *cx_frame = ctx->coded_frame_list;
1109  /* return the leading frame if we've already begun queueing */
1110  size = storeframe(avctx, cx_frame, pkt_out);
1111  if (size < 0)
1112  return size;
1113  ctx->coded_frame_list = cx_frame->next;
1114  free_coded_frame(cx_frame);
1115  }
1116 
1117  /* consume all available output from the encoder before returning. buffers
1118  * are only good through the next aom_codec call */
1119  while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
1120  switch (pkt->kind) {
1121  case AOM_CODEC_CX_FRAME_PKT:
1122  if (!size) {
1123  struct FrameListData cx_frame;
1124 
1125  /* avoid storing the frame when the list is empty and we haven't yet
1126  * provided a frame for output */
1127  av_assert0(!ctx->coded_frame_list);
1128  cx_pktcpy(ctx, &cx_frame, pkt);
1129  size = storeframe(avctx, &cx_frame, pkt_out);
1130  if (size < 0)
1131  return size;
1132  } else {
1133  struct FrameListData *cx_frame =
1134  av_malloc(sizeof(struct FrameListData));
1135 
1136  if (!cx_frame) {
1137  av_log(avctx, AV_LOG_ERROR,
1138  "Frame queue element alloc failed\n");
1139  return AVERROR(ENOMEM);
1140  }
1141  cx_pktcpy(ctx, cx_frame, pkt);
1142  cx_frame->buf = av_malloc(cx_frame->sz);
1143 
1144  if (!cx_frame->buf) {
1145  av_log(avctx, AV_LOG_ERROR,
1146  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1147  cx_frame->sz);
1148  av_freep(&cx_frame);
1149  return AVERROR(ENOMEM);
1150  }
1151  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
1152  coded_frame_add(&ctx->coded_frame_list, cx_frame);
1153  }
1154  break;
1155  case AOM_CODEC_STATS_PKT:
1156  {
1157  struct aom_fixed_buf *stats = &ctx->twopass_stats;
1158  uint8_t *tmp = av_fast_realloc(stats->buf,
1159  &ctx->twopass_stats_size,
1160  stats->sz +
1161  pkt->data.twopass_stats.sz);
1162  if (!tmp) {
1163  av_freep(&stats->buf);
1164  stats->sz = 0;
1165  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
1166  return AVERROR(ENOMEM);
1167  }
1168  stats->buf = tmp;
1169  memcpy((uint8_t *)stats->buf + stats->sz,
1170  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1171  stats->sz += pkt->data.twopass_stats.sz;
1172  break;
1173  }
1174  case AOM_CODEC_PSNR_PKT:
1175  {
1176  av_assert0(!ctx->have_sse);
1177  ctx->sse[0] = pkt->data.psnr.sse[0];
1178  ctx->sse[1] = pkt->data.psnr.sse[1];
1179  ctx->sse[2] = pkt->data.psnr.sse[2];
1180  ctx->sse[3] = pkt->data.psnr.sse[3];
1181  ctx->have_sse = 1;
1182  break;
1183  }
1184  case AOM_CODEC_CUSTOM_PKT:
1185  // ignore unsupported/unrecognized packet types
1186  break;
1187  }
1188  }
1189 
1190  return size;
1191 }
1192 
1193 static enum AVPixelFormat aomfmt_to_pixfmt(struct aom_image *img)
1194 {
1195  switch (img->fmt) {
1196  case AOM_IMG_FMT_I420:
1197  case AOM_IMG_FMT_I42016:
1198  if (img->bit_depth == 8)
1199  return img->monochrome ? AV_PIX_FMT_GRAY8 : AV_PIX_FMT_YUV420P;
1200  else if (img->bit_depth == 10)
1201  return img->monochrome ? AV_PIX_FMT_GRAY10 : AV_PIX_FMT_YUV420P10;
1202  else
1203  return img->monochrome ? AV_PIX_FMT_GRAY12 : AV_PIX_FMT_YUV420P12;
1204  case AOM_IMG_FMT_I422:
1205  case AOM_IMG_FMT_I42216:
1206  if (img->bit_depth == 8)
1207  return AV_PIX_FMT_YUV422P;
1208  else if (img->bit_depth == 10)
1209  return AV_PIX_FMT_YUV422P10;
1210  else
1211  return AV_PIX_FMT_YUV422P12;
1212  case AOM_IMG_FMT_I444:
1213  case AOM_IMG_FMT_I44416:
1214  if (img->bit_depth == 8)
1215  return AV_PIX_FMT_YUV444P;
1216  else if (img->bit_depth == 10)
1217  return AV_PIX_FMT_YUV444P10;
1218  else
1219  return AV_PIX_FMT_YUV444P12;
1220  };
1221  return AV_PIX_FMT_NONE;
1222 }
1223 
1224 static int aom_encode(AVCodecContext *avctx, AVPacket *pkt,
1225  const AVFrame *frame, int *got_packet)
1226 {
1227  AOMContext *ctx = avctx->priv_data;
1228  struct aom_image *rawimg = NULL;
1229  int64_t timestamp = 0;
1230  unsigned long duration = 0;
1231  int res, coded_size;
1232  aom_enc_frame_flags_t flags = 0;
1233  AVFrameSideData *sd;
1234 
1235  if (frame) {
1236  rawimg = &ctx->rawimg;
1237  rawimg->planes[AOM_PLANE_Y] = frame->data[0];
1238  rawimg->planes[AOM_PLANE_U] = frame->data[1];
1239  rawimg->planes[AOM_PLANE_V] = frame->data[2];
1240  rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
1241  rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
1242  rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
1243  timestamp = frame->pts;
1244 
1245  if (frame->duration > ULONG_MAX) {
1246  av_log(avctx, AV_LOG_WARNING,
1247  "Frame duration too large: %"PRId64"\n", frame->duration);
1248  } else if (frame->duration)
1249  duration = frame->duration;
1250  else if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1251  duration = av_rescale_q(1, av_inv_q(avctx->framerate), avctx->time_base);
1252  else {
1253  duration = 1;
1254  }
1255 
1256  switch (frame->color_range) {
1257  case AVCOL_RANGE_MPEG:
1258  rawimg->range = AOM_CR_STUDIO_RANGE;
1259  break;
1260  case AVCOL_RANGE_JPEG:
1261  rawimg->range = AOM_CR_FULL_RANGE;
1262  break;
1263  }
1264 
1265  aom_img_remove_metadata(rawimg);
1266  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DOVI_METADATA);
1267  if (ctx->dovi.cfg.dv_profile && sd) {
1268  const AVDOVIMetadata *metadata = (const AVDOVIMetadata *)sd->data;
1269  uint8_t *t35;
1270  int size;
1271  if ((res = ff_dovi_rpu_generate(&ctx->dovi, metadata, FF_DOVI_WRAP_T35,
1272  &t35, &size)) < 0)
1273  return res;
1274  res = aom_img_add_metadata(rawimg, OBU_METADATA_TYPE_ITUT_T35,
1275  t35, size, AOM_MIF_ANY_FRAME);
1276  av_free(t35);
1277  if (res != AOM_CODEC_OK)
1278  return AVERROR(ENOMEM);
1279  } else if (ctx->dovi.cfg.dv_profile) {
1280  av_log(avctx, AV_LOG_ERROR, "Dolby Vision enabled, but received frame "
1281  "without AV_FRAME_DATA_DOVI_METADATA\n");
1282  return AVERROR_INVALIDDATA;
1283  }
1284 
1285  if (frame->pict_type == AV_PICTURE_TYPE_I)
1286  flags |= AOM_EFLAG_FORCE_KF;
1287  }
1288 
1289  res = aom_codec_encode(&ctx->encoder, rawimg, timestamp, duration, flags);
1290  if (res != AOM_CODEC_OK) {
1291  log_encoder_error(avctx, "Error encoding frame");
1292  return AVERROR_INVALIDDATA;
1293  }
1294  coded_size = queue_frames(avctx, pkt);
1295  if (coded_size < 0)
1296  return coded_size;
1297 
1298  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1299  size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1300 
1301  avctx->stats_out = av_malloc(b64_size);
1302  if (!avctx->stats_out) {
1303  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1304  b64_size);
1305  return AVERROR(ENOMEM);
1306  }
1307  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1308  ctx->twopass_stats.sz);
1309  }
1310 
1311  *got_packet = !!coded_size;
1312 
1313  if (*got_packet && avctx->flags & AV_CODEC_FLAG_RECON_FRAME) {
1314  AVCodecInternal *avci = avctx->internal;
1315  struct aom_image img;
1316 
1317  av_frame_unref(avci->recon_frame);
1318 
1319  res = codecctl_imgp(avctx, AV1_GET_NEW_FRAME_IMAGE, &img);
1320  if (res < 0)
1321  return res;
1322 
1323  avci->recon_frame->format = aomfmt_to_pixfmt(&img);
1324  if (avci->recon_frame->format == AV_PIX_FMT_NONE) {
1325  av_log(ctx, AV_LOG_ERROR,
1326  "Unhandled reconstructed frame colorspace: %d\n",
1327  img.fmt);
1328  return AVERROR(ENOSYS);
1329  }
1330 
1331  avci->recon_frame->width = img.d_w;
1332  avci->recon_frame->height = img.d_h;
1333 
1334  res = av_frame_get_buffer(avci->recon_frame, 0);
1335  if (res < 0)
1336  return res;
1337 
1338  if ((img.fmt & AOM_IMG_FMT_HIGHBITDEPTH) && img.bit_depth == 8)
1339  ff_aom_image_copy_16_to_8(avci->recon_frame, &img);
1340  else {
1341  const uint8_t *planes[4] = { img.planes[0], img.planes[1], img.planes[2] };
1342  const int stride[4] = { img.stride[0], img.stride[1], img.stride[2] };
1343 
1344  av_image_copy(avci->recon_frame->data, avci->recon_frame->linesize, planes,
1345  stride, avci->recon_frame->format, img.d_w, img.d_h);
1346  }
1347  }
1348 
1349  return 0;
1350 }
1351 
1352 static const enum AVPixelFormat av1_pix_fmts[] = {
1353  AV_PIX_FMT_YUV420P,
1354  AV_PIX_FMT_YUV422P,
1355  AV_PIX_FMT_YUV444P,
1356  AV_PIX_FMT_GBRP,
1357  AV_PIX_FMT_NONE
1358 };
1359 
1360 static const enum AVPixelFormat av1_pix_fmts_with_gray[] = {
1361  AV_PIX_FMT_YUV420P,
1362  AV_PIX_FMT_YUV422P,
1363  AV_PIX_FMT_YUV444P,
1364  AV_PIX_FMT_GBRP,
1365  AV_PIX_FMT_GRAY8,
1366  AV_PIX_FMT_NONE
1367 };
1368 
1369 static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
1370  AV_PIX_FMT_YUV420P,
1371  AV_PIX_FMT_YUV422P,
1372  AV_PIX_FMT_YUV444P,
1373  AV_PIX_FMT_GBRP,
1374  AV_PIX_FMT_YUV420P10,
1375  AV_PIX_FMT_YUV422P10,
1376  AV_PIX_FMT_YUV444P10,
1377  AV_PIX_FMT_YUV420P12,
1378  AV_PIX_FMT_YUV422P12,
1379  AV_PIX_FMT_YUV444P12,
1380  AV_PIX_FMT_GBRP10,
1381  AV_PIX_FMT_GBRP12,
1382  AV_PIX_FMT_NONE
1383 };
1384 
1385 static const enum AVPixelFormat av1_pix_fmts_highbd_with_gray[] = {
1386  AV_PIX_FMT_YUV420P,
1387  AV_PIX_FMT_YUV422P,
1388  AV_PIX_FMT_YUV444P,
1389  AV_PIX_FMT_GBRP,
1390  AV_PIX_FMT_YUV420P10,
1391  AV_PIX_FMT_YUV422P10,
1392  AV_PIX_FMT_YUV444P10,
1393  AV_PIX_FMT_YUV420P12,
1394  AV_PIX_FMT_YUV422P12,
1395  AV_PIX_FMT_YUV444P12,
1396  AV_PIX_FMT_GBRP10,
1397  AV_PIX_FMT_GBRP12,
1398  AV_PIX_FMT_GRAY8,
1399  AV_PIX_FMT_GRAY10,
1400  AV_PIX_FMT_GRAY12,
1401  AV_PIX_FMT_NONE
1402 };
1403 
1404 static int av1_get_supported_config(const AVCodecContext *avctx,
1405  const AVCodec *codec,
1406  enum AVCodecConfig config,
1407  unsigned flags, const void **out,
1408  int *out_num)
1409 {
1410  if (config == AV_CODEC_CONFIG_PIX_FORMAT) {
1411  int supports_monochrome = aom_codec_version() >= 20001;
1412  aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1413  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
1414  if (supports_monochrome) {
1415  *out = av1_pix_fmts_highbd_with_gray;
1416  *out_num = FF_ARRAY_ELEMS(av1_pix_fmts_highbd_with_gray) - 1;
1417  } else {
1418  *out = av1_pix_fmts_highbd;
1419  *out_num = FF_ARRAY_ELEMS(av1_pix_fmts_highbd) - 1;
1420  }
1421  } else {
1422  if (supports_monochrome) {
1423  *out = av1_pix_fmts_with_gray;
1424  *out_num = FF_ARRAY_ELEMS(av1_pix_fmts_with_gray) - 1;
1425  } else {
1426  *out = av1_pix_fmts;
1427  *out_num = FF_ARRAY_ELEMS(av1_pix_fmts) - 1;
1428  }
1429  }
1430  return 0;
1431  }
1432 
1433  return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num);
1434 }
1435 
1436 static av_cold int av1_init(AVCodecContext *avctx)
1437 {
1438  return aom_init(avctx, aom_codec_av1_cx());
1439 }
1440 
1441 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1442 static const AVOption options[] = {
1443  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 8, VE},
1444  { "auto-alt-ref", "Enable use of alternate reference "
1445  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1446  { "lag-in-frames", "Number of frames to look ahead at for "
1447  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1448  { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1449  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1450  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, .unit = "aq_mode"},
1451  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, .unit = "aq_mode"},
1452  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, .unit = "aq_mode"},
1453  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, .unit = "aq_mode"},
1454  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, .unit = "aq_mode"},
1455  { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, .unit = "er"},
1456  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, .unit = "er"},
1457  { "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1458  { "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 },
1459  { "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1460  { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1461  { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1462  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1463  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1464  { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1465  { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1466  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1467  { "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
1468  { "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1469  { "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1470  { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1471  { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1472  { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1473  { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1474  { "enable-restoration", "Enable Loop Restoration filtering", OFFSET(enable_restoration), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1475  { "usage", "Quality and compression efficiency vs speed trade-off", OFFSET(usage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, .unit = "usage"},
1476  { "good", "Good quality", 0, AV_OPT_TYPE_CONST, {.i64 = 0 /* AOM_USAGE_GOOD_QUALITY */}, 0, 0, VE, .unit = "usage"},
1477  { "realtime", "Realtime encoding", 0, AV_OPT_TYPE_CONST, {.i64 = 1 /* AOM_USAGE_REALTIME */}, 0, 0, VE, .unit = "usage"},
1478  { "allintra", "All Intra encoding", 0, AV_OPT_TYPE_CONST, {.i64 = 2 /* AOM_USAGE_ALL_INTRA */}, 0, 0, VE, .unit = "usage"},
1479  { "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, .unit = "tune"},
1480  { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AOM_TUNE_PSNR}, 0, 0, VE, .unit = "tune"},
1481  { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AOM_TUNE_SSIM}, 0, 0, VE, .unit = "tune"},
1482  FF_AV1_PROFILE_OPTS
1483  { "still-picture", "Encode in single frame mode (typically used for still AVIF images).", OFFSET(still_picture), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, VE },
1484  { "dolbyvision", "Enable Dolby Vision RPU coding", OFFSET(dovi.enable), AV_OPT_TYPE_BOOL, {.i64 = FF_DOVI_AUTOMATIC }, -1, 1, VE, .unit = "dovi" },
1485  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DOVI_AUTOMATIC}, .flags = VE, .unit = "dovi" },
1486  { "enable-rect-partitions", "Enable rectangular partitions", OFFSET(enable_rect_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1487  { "enable-1to4-partitions", "Enable 1:4/4:1 partitions", OFFSET(enable_1to4_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1488  { "enable-ab-partitions", "Enable ab shape partitions", OFFSET(enable_ab_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1489  { "enable-angle-delta", "Enable angle delta intra prediction", OFFSET(enable_angle_delta), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1490  { "enable-cfl-intra", "Enable chroma predicted from luma intra prediction", OFFSET(enable_cfl_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1491  { "enable-filter-intra", "Enable filter intra predictor", OFFSET(enable_filter_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1492  { "enable-intra-edge-filter", "Enable intra edge filter", OFFSET(enable_intra_edge_filter), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1493  { "enable-smooth-intra", "Enable smooth intra prediction mode", OFFSET(enable_smooth_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1494  { "enable-paeth-intra", "Enable paeth predictor in intra prediction", OFFSET(enable_paeth_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1495  { "enable-palette", "Enable palette prediction mode", OFFSET(enable_palette), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1496  { "enable-flip-idtx", "Enable extended transform type", OFFSET(enable_flip_idtx), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1497  { "enable-tx64", "Enable 64-pt transform", OFFSET(enable_tx64), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1498  { "reduced-tx-type-set", "Use reduced set of transform types", OFFSET(reduced_tx_type_set), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1499  { "use-intra-dct-only", "Use DCT only for INTRA modes", OFFSET(use_intra_dct_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1500  { "use-inter-dct-only", "Use DCT only for INTER modes", OFFSET(use_inter_dct_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1501  { "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},
1502  { "enable-ref-frame-mvs", "Enable temporal mv prediction", OFFSET(enable_ref_frame_mvs), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1503  { "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},
1504  { "enable-obmc", "Enable obmc", OFFSET(enable_obmc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1505  { "enable-dual-filter", "Enable dual filter", OFFSET(enable_dual_filter), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1506  { "enable-diff-wtd-comp", "Enable difference-weighted compound", OFFSET(enable_diff_wtd_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1507  { "enable-dist-wtd-comp", "Enable distance-weighted compound", OFFSET(enable_dist_wtd_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1508  { "enable-onesided-comp", "Enable one sided compound", OFFSET(enable_onesided_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1509  { "enable-interinter-wedge", "Enable interinter wedge compound", OFFSET(enable_interinter_wedge), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1510  { "enable-interintra-wedge", "Enable interintra wedge compound", OFFSET(enable_interintra_wedge), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1511  { "enable-masked-comp", "Enable masked compound", OFFSET(enable_masked_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1512  { "enable-interintra-comp", "Enable interintra compound", OFFSET(enable_interintra_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1513  { "enable-smooth-interintra", "Enable smooth interintra mode", OFFSET(enable_smooth_interintra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1514 #if AOM_ENCODER_ABI_VERSION >= 23
1515  { "aom-params", "Set libaom options using a :-separated list of key=value pairs", OFFSET(aom_params), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
1516 #endif
1517  { NULL },
1518 };
1519 
1520 static const FFCodecDefault defaults[] = {
1521  { "b", "0" },
1522  { "qmin", "-1" },
1523  { "qmax", "-1" },
1524  { "g", "-1" },
1525  { "keyint_min", "-1" },
1526  { NULL },
1527 };
1528 
1529 static const AVClass class_aom = {
1530  .class_name = "libaom-av1 encoder",
1531  .item_name = av_default_item_name,
1532  .option = options,
1533  .version = LIBAVUTIL_VERSION_INT,
1534 };
1535 
1536 FFCodec ff_libaom_av1_encoder = {
1537  .p.name = "libaom-av1",
1538  CODEC_LONG_NAME("libaom AV1"),
1539  .p.type = AVMEDIA_TYPE_VIDEO,
1540  .p.id = AV_CODEC_ID_AV1,
1541  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1542  AV_CODEC_CAP_ENCODER_RECON_FRAME |
1543  AV_CODEC_CAP_OTHER_THREADS,
1544  .color_ranges = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG,
1545  .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1546  .p.priv_class = &class_aom,
1547  .p.wrapper_name = "libaom",
1548  .priv_data_size = sizeof(AOMContext),
1549  .init = av1_init,
1550  FF_CODEC_ENCODE_CB(aom_encode),
1551  .close = aom_free,
1552  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
1553  FF_CODEC_CAP_INIT_CLEANUP |
1554  FF_CODEC_CAP_AUTO_THREADS,
1555  .defaults = defaults,
1556  .get_supported_config = av1_get_supported_config,
1557 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
flags
const SwsFlags flags[]
Definition: swscale.c:61
AOMEncoderContext::error_resilient
int error_resilient
Definition: libaomenc.c:86
AOMEncoderContext::usage
int usage
Definition: libaomenc.c:109
AVCodec
AVCodec.
Definition: codec.h:172
dump_enc_cfg
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct aom_codec_enc_cfg *cfg, int level)
Definition: libaomenc.c:219
AOMEncoderContext::enable_filter_intra
int enable_filter_intra
Definition: libaomenc.c:121
AOMEncoderContext::enable_paeth_intra
int enable_paeth_intra
Definition: libaomenc.c:117
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AOMEncoderContext::tile_rows_log2
int tile_rows_log2
Definition: libaomenc.c:101
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AOMEncoderContext::enable_interintra_comp
int enable_interintra_comp
Definition: libaomenc.c:131
level
uint8_t level
Definition: svq3.c:208
FrameListData::pts
int64_t pts
time stamp to show frame (in timebase units)
Definition: libaomenc.c:60
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:998
AOMEncoderContext::sse
uint64_t sse[4]
Definition: libaomenc.c:92
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:499
ff_dovi_ctx_unref
void ff_dovi_ctx_unref(DOVIContext *s)
Completely reset a DOVIContext, preserving only logctx.
Definition: dovi_rpu.c:29
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:659
out
FILE * out
Definition: movenc.c:55
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:205
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:657
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1277
defaults
static const FFCodecDefault defaults[]
Definition: libaomenc.c:1520
aom_init
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
Definition: libaomenc.c:718
AOMEncoderContext::enable_restoration
int enable_restoration
Definition: libaomenc.c:108
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3341
AOMEncoderContext::enable_smooth_intra
int enable_smooth_intra
Definition: libaomenc.c:118
AOMEncoderContext::enable_1to4_partitions
int enable_1to4_partitions
Definition: libaomenc.c:113
AV_FRAME_DATA_DOVI_METADATA
@ AV_FRAME_DATA_DOVI_METADATA
Parsed Dolby Vision metadata, suitable for passing to a software implementation.
Definition: frame.h:208
int64_t
long long int64_t
Definition: coverity.c:34
metadata
Stream codec metadata
Definition: ogg-flac-chained-meta.txt:2
FF_AV1_PROFILE_OPTS
#define FF_AV1_PROFILE_OPTS
Definition: profiles.h:56
AV_CODEC_CAP_ENCODER_RECON_FRAME
#define AV_CODEC_CAP_ENCODER_RECON_FRAME
The encoder is able to output reconstructed frame data, i.e.
Definition: codec.h:159
AOMEncoderContext::denoise_noise_level
int denoise_noise_level
Definition: libaomenc.c:90
av_unused
#define av_unused
Definition: attributes.h:131
AOMEncoderContext::still_picture
int still_picture
Definition: libaomenc.c:111
AOMEncoderContext::lag_in_frames
int lag_in_frames
Definition: libaomenc.c:85
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:652
AVFrame::width
int width
Definition: frame.h:482
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:750
coded_frame_add
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libaomenc.c:277
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:535
AOMEncoderContext::frame_number
uint64_t frame_number
Definition: libaomenc.c:94
AVOption
AVOption.
Definition: opt.h:429
encode.h
AOMEncoderContext::use_intra_default_tx_only
int use_intra_default_tx_only
Definition: libaomenc.c:127
cx_pktcpy
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
Definition: libaomenc.c:1013
option_map
static const struct @167 option_map[]
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:528
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
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:674
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:553
mathematics.h
AVDictionary
Definition: dict.c:32
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:306
AV_CODEC_CONFIG_PIX_FORMAT
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
Definition: avcodec.h:2524
AOMEncoderContext::aom_params
AVDictionary * aom_params
Definition: libaomenc.c:140
AV_PROFILE_AV1_PROFESSIONAL
#define AV_PROFILE_AV1_PROFESSIONAL
Definition: defs.h:171
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1241
options
static const AVOption options[]
Definition: libaomenc.c:1442
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:52
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:590
AOMEncoderContext::twopass_stats_size
unsigned twopass_stats_size
Definition: libaomenc.c:78
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
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:318
FF_DOVI_WRAP_T35
@ FF_DOVI_WRAP_T35
wrap inside T.35+EMDF
Definition: dovi_rpu.h:160
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:1039
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:551
FrameListData::flags
uint32_t flags
flags for this frame
Definition: libaomenc.c:64
AOMEncoderContext::cpu_used
int cpu_used
Definition: libaomenc.c:80
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:658
bsf.h
AOMEncoderContext::enable_ab_partitions
int enable_ab_partitions
Definition: libaomenc.c:114
DOVIContext
Definition: dovi_rpu.h:42
AOMEncoderContext::coded_frame_list
struct FrameListData * coded_frame_list
Definition: libaomenc.c:79
AOMEncoderContext::static_thresh
int static_thresh
Definition: libaomenc.c:88
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1561
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:544
AOMEncoderContext::minsection_pct
int minsection_pct
Definition: libaomenc.c:97
AOMEncoderContext::uniform_tiles
int uniform_tiles
Definition: libaomenc.c:103
AOMEncoderContext::enable_ref_frame_mvs
int enable_ref_frame_mvs
Definition: libaomenc.c:128
AOMEncoderContext::row_mt
int row_mt
Definition: libaomenc.c:104
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:689
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
AOMEncoderContext::denoise_block_size
int denoise_block_size
Definition: libaomenc.c:91
val
static double val(void *priv, double ch)
Definition: aeval.c:77
dovi_rpu.h
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_dovi_configure
int ff_dovi_configure(DOVIContext *s, AVCodecContext *avctx)
Variant of ff_dovi_configure_from_codedpar which infers the codec parameters from an AVCodecContext.
Definition: dovi_rpuenc.c:260
AOMEncoderContext::use_inter_dct_only
int use_inter_dct_only
Definition: libaomenc.c:126
FF_DOVI_AUTOMATIC
#define FF_DOVI_AUTOMATIC
Enable tri-state.
Definition: dovi_rpu.h:49
ff_libaom_av1_encoder
FFCodec ff_libaom_av1_encoder
Definition: libaomenc.c:1536
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:531
free_coded_frame
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libaomenc.c:287
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:645
count_uniform_tiling
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
Definition: libaomenc.c:515
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AOMEncoderContext::enable_angle_delta
int enable_angle_delta
Definition: libaomenc.c:115
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
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:1298
duration
int64_t duration
Definition: movenc.c:65
AOMEncoderContext::enable_cdef
int enable_cdef
Definition: libaomenc.c:105
AOMEncoderContext::enable_smooth_interintra
int enable_smooth_interintra
Definition: libaomenc.c:136
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:497
AOMEncoderContext::twopass_stats
struct aom_fixed_buf twopass_stats
Definition: libaomenc.c:77
AVDOVIMetadata
Combined struct representing a combination of header, mapping and color metadata, for attaching to fr...
Definition: dovi_meta.h:337
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:1100
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:1320
codecctl_int
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
Definition: libaomenc.c:304
AVDictionaryEntry::key
char * key
Definition: dict.h:91
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:109
FrameListData::sse
uint64_t sse[4]
Definition: libaomenc.c:65
AOMEncoderContext::enable_interintra_wedge
int enable_interintra_wedge
Definition: libaomenc.c:130
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AOMEncoderContext::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:93
tile_cols
int tile_cols
Definition: av1_levels.c:73
AOMEncoderContext::enable_obmc
int enable_obmc
Definition: libaomenc.c:133
FrameListData::frame_number
uint64_t frame_number
Definition: libaomenc.c:67
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
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:433
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:163
limits.h
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:104
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:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1270
AOMEncoderContext::superblock_size
aom_superblock_size_t superblock_size
Definition: libaomenc.c:102
AVCodecContext::error
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1505
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:135
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:279
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
AOMEncoderContext::enable_dist_wtd_comp
int enable_dist_wtd_comp
Definition: libaomenc.c:138
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:508
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1255
AOMEncoderContext::drop_threshold
int drop_threshold
Definition: libaomenc.c:89
AOMEncoderContext::dovi
DOVIContext dovi
Definition: libaomenc.c:74
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:149
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
AOMEncoderContext::tile_rows
int tile_rows
Definition: libaomenc.c:100
NULL
#define NULL
Definition: coverity.c:32
AOMEncoderContext
Definition: libaomenc.c:71
AOMEncoderContext::rc_overshoot_pct
int rc_overshoot_pct
Definition: libaomenc.c:96
AOMEncoderContext::enable_diff_wtd_comp
int enable_diff_wtd_comp
Definition: libaomenc.c:137
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:669
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:284
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
ff_dovi_rpu_generate
int ff_dovi_rpu_generate(DOVIContext *s, const AVDOVIMetadata *metadata, int flags, uint8_t **out_rpu, int *out_size)
Synthesize a Dolby Vision RPU reflecting the current state.
Definition: dovi_rpuenc.c:567
AOMEncoderContext::enable_palette
int enable_palette
Definition: libaomenc.c:120
AOMEncoderContext::arnr_max_frames
int arnr_max_frames
Definition: libaomenc.c:82
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:466
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:303
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Underlying C type is AVDictionary*.
Definition: opt.h:290
AOMEncoderContext::enable_tx64
int enable_tx64
Definition: libaomenc.c:123
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:621
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
profiles.h
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
options
Definition: swscale.c:43
FrameListData::buf
void * buf
compressed data buffer
Definition: libaomenc.c:58
AV1_MAX_TILE_WIDTH
@ AV1_MAX_TILE_WIDTH
Definition: av1.h:79
AOMEncoderContext::rc_undershoot_pct
int rc_undershoot_pct
Definition: libaomenc.c:95
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:529
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:81
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
codecctl_imgp
static av_cold int codecctl_imgp(AVCodecContext *avctx, enum aome_enc_control_id id, struct aom_image *img)
Definition: libaomenc.c:362
base64.h
stats
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
Definition: vp9_superframe.c:34
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:716
AOMEncoderContext::enable_global_motion
int enable_global_motion
Definition: libaomenc.c:106
AOMEncoderContext::encoder
struct aom_codec_ctx encoder
Definition: libaomenc.c:75
av1_init
static av_cold int av1_init(AVCodecContext *avctx)
Definition: libaomenc.c:1436
aom_enum
int aom_enum
Definition: libaomenc.c:680
AOMEncoderContext::enable_onesided_comp
int enable_onesided_comp
Definition: libaomenc.c:134
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:221
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:1226
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:535
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:68
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1312
ctlidstr
static const char *const ctlidstr[]
Definition: libaomenc.c:145
av1_get_supported_config
static int av1_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out, int *out_num)
Definition: libaomenc.c:1404
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:536
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:94
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1005
codec_internal.h
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
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
AOMEncoderContext::enable_flip_idtx
int enable_flip_idtx
Definition: libaomenc.c:122
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
cpu.h
offset
unsigned offset
Definition: libaomenc.c:681
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:533
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:188
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:535
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
aom_encode
static int aom_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libaomenc.c:1224
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:497
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:289
av1.h
FrameListData
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libaomenc.c:57
AOMEncoderContext::tile_cols_log2
int tile_cols_log2
Definition: libaomenc.c:101
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:534
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:294
AOMEncoderContext::tile_cols
int tile_cols
Definition: libaomenc.c:100
img
#define img
Definition: vf_colormatrix.c:114
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AV_PROFILE_AV1_HIGH
#define AV_PROFILE_AV1_HIGH
Definition: defs.h:170
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:541
AVCodecInternal
Definition: internal.h:49
AOMEncoderContext::rawimg
struct aom_image rawimg
Definition: libaomenc.c:76
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:294
AOMEncoderContext::enable_dual_filter
int enable_dual_filter
Definition: libaomenc.c:139
AOMEncoderContext::aq_mode
int aq_mode
Definition: libaomenc.c:84
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
AOMEncoderContext::enable_cfl_intra
int enable_cfl_intra
Definition: libaomenc.c:116
planes
static const struct @509 planes[]
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
AV_CODEC_FLAG_RECON_FRAME
#define AV_CODEC_FLAG_RECON_FRAME
Request the encoder to output reconstructed frames, i.e. frames that would be produced by decoding th...
Definition: avcodec.h:244
ff_default_get_supported_config
int ff_default_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out_configs, int *out_num_configs)
Definition: avcodec.c:749
AOMEncoderContext::arnr_strength
int arnr_strength
Definition: libaomenc.c:83
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:528
round
static av_always_inline av_const double round(double x)
Definition: libm.h:446
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:545
AOMEncoderContext::enable_interinter_wedge
int enable_interinter_wedge
Definition: libaomenc.c:129
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:284
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:494
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
FrameListData::duration
unsigned long duration
duration to show frame (in timebase units)
Definition: libaomenc.c:62
AOMEncoderContext::auto_alt_ref
int auto_alt_ref
Definition: libaomenc.c:81
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
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:81
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:1360
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:300
AOMEncoderContext::bsf
AVBSFContext * bsf
Definition: libaomenc.c:73
log_encoder_error
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libaomenc.c:208
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:114
VE
#define VE
Definition: libaomenc.c:1441
AV1_MAX_TILE_COLS
@ AV1_MAX_TILE_COLS
Definition: av1.h:82
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:532
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
free_frame_list
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libaomenc.c:293
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVFrame::height
int height
Definition: frame.h:482
AOMEncoderContext::enable_rect_partitions
int enable_rect_partitions
Definition: libaomenc.c:112
AVBitStreamFilter
Definition: bsf.h:111
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:106
aomfmt_to_pixfmt
static enum AVPixelFormat aomfmt_to_pixfmt(struct aom_image *img)
Definition: libaomenc.c:1193
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1234
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1618
choose_tiling
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
Definition: libaomenc.c:523
AV1_MAX_TILE_AREA
@ AV1_MAX_TILE_AREA
Definition: av1.h:80
AOMEncoderContext::maxsection_pct
int maxsection_pct
Definition: libaomenc.c:98
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:147
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:76
AOMEncoderContext::enable_intra_edge_filter
int enable_intra_edge_filter
Definition: libaomenc.c:119
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:78
class_aom
static const AVClass class_aom
Definition: libaomenc.c:1529
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
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:77
mem.h
packet_internal.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:72
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
av1_pix_fmts
static enum AVPixelFormat av1_pix_fmts[]
Definition: libaomenc.c:1352
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:135
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
ff_aom_image_copy_16_to_8
void ff_aom_image_copy_16_to_8(AVFrame *pic, struct aom_image *img)
Definition: libaom.c:27
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AOMEncoderContext::frame_parallel
int frame_parallel
Definition: libaomenc.c:99
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av1_pix_fmts_highbd
static enum AVPixelFormat av1_pix_fmts_highbd[]
Definition: libaomenc.c:1369
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
imgutils.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:455
AOMEncoderContext::enable_masked_comp
int enable_masked_comp
Definition: libaomenc.c:132
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FrameListData::sz
size_t sz
length of compressed data
Definition: libaomenc.c:59
AOMEncoderContext::reduced_tx_type_set
int reduced_tx_type_set
Definition: libaomenc.c:124
AV1_MAX_TILE_ROWS
@ AV1_MAX_TILE_ROWS
Definition: av1.h:81
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
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: packet.c:610
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:880
AVDictionaryEntry::value
char * value
Definition: dict.h:92
width
#define width
Definition: dsp.h:89
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:509
av_image_copy
void av_image_copy(uint8_t *const dst_data[4], const int dst_linesizes[4], const uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:422
libaom.h
AV_PROFILE_AV1_MAIN
#define AV_PROFILE_AV1_MAIN
Definition: defs.h:169
AOMEncoderContext::enable_intrabc
int enable_intrabc
Definition: libaomenc.c:107
aom_free
static av_cold int aom_free(AVCodecContext *avctx)
Definition: libaomenc.c:387
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
AOMEncoderContext::tune
int tune
Definition: libaomenc.c:110
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AOMEncoderContext::crf
int crf
Definition: libaomenc.c:87
OFFSET
#define OFFSET(x)
Definition: libaomenc.c:143
AVCodecConfig
AVCodecConfig
Definition: avcodec.h:2523
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
src
#define src
Definition: vp8dsp.c:248
AOMEncoderContext::use_intra_dct_only
int use_intra_dct_only
Definition: libaomenc.c:125
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:290
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:88
FrameListData::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:66
av1_pix_fmts_highbd_with_gray
static enum AVPixelFormat av1_pix_fmts_highbd_with_gray[]
Definition: libaomenc.c:1385
Generated on Mon Jun 30 2025 19:22:31 for FFmpeg by   doxygen 1.8.17