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