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