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