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