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