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