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