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