FFmpeg: libavcodec/libaomenc.c Source File

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  #define AOM_DISABLE_CTRL_TYPECHECKS 1
27 #include <aom/aom_encoder.h>
28 #include <aom/aomcx.h>
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/base64.h"
32 #include "libavutil/common.h"
33 #include "libavutil/cpu.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 
38 #include "av1.h"
39 #include "avcodec.h"
40 #include "bsf.h"
41 #include "encode.h"
42 #include "internal.h"
43 #include "packet_internal.h"
44 #include "profiles.h"
45 
46 /*
47  * Portion of struct aom_codec_cx_pkt from aom_encoder.h.
48  * One encoded frame returned from the library.
49  */
50  struct FrameListData {
51   void *buf; /**< compressed data buffer */
52   size_t sz; /**< length of compressed data */
53   int64_t pts; /**< time stamp to show frame
54  (in timebase units) */
55   unsigned long duration; /**< duration to show frame
56  (in timebase units) */
57   uint32_t flags; /**< flags for this frame */
58   uint64_t sse[4];
59   int have_sse; /**< true if we have pending sse[] */
60   uint64_t frame_number;
61   struct FrameListData *next;
62 };
63 
64  typedef struct AOMEncoderContext {
65   AVClass *class;
66   AVBSFContext *bsf;
67   struct aom_codec_ctx encoder;
68   struct aom_image rawimg;
69   struct aom_fixed_buf twopass_stats;
70   struct FrameListData *coded_frame_list;
71   int cpu_used;
72   int auto_alt_ref;
73   int arnr_max_frames;
74   int arnr_strength;
75   int aq_mode;
76   int lag_in_frames;
77   int error_resilient;
78   int crf;
79   int static_thresh;
80   int drop_threshold;
81   int denoise_noise_level;
82   int denoise_block_size;
83   uint64_t sse[4];
84   int have_sse; /**< true if we have pending sse[] */
85   uint64_t frame_number;
86   int rc_undershoot_pct;
87   int rc_overshoot_pct;
88   int minsection_pct;
89   int maxsection_pct;
90   int frame_parallel;
91   int tile_cols, tile_rows;
92   int tile_cols_log2, tile_rows_log2;
93   aom_superblock_size_t superblock_size;
94   int uniform_tiles;
95   int row_mt;
96   int enable_cdef;
97   int enable_global_motion;
98   int enable_intrabc;
99   int enable_restoration;
100   int usage;
101   int tune;
102   int enable_rect_partitions;
103   int enable_1to4_partitions;
104   int enable_ab_partitions;
105   int enable_angle_delta;
106   int enable_cfl_intra;
107   int enable_paeth_intra;
108   int enable_smooth_intra;
109   int enable_intra_edge_filter;
110   int enable_palette;
111   int enable_filter_intra;
112   int enable_flip_idtx;
113   int enable_tx64;
114   int reduced_tx_type_set;
115   int use_intra_dct_only;
116   int use_inter_dct_only;
117   int use_intra_default_tx_only;
118   int enable_ref_frame_mvs;
119   int enable_interinter_wedge;
120   int enable_interintra_wedge;
121   int enable_interintra_comp;
122   int enable_masked_comp;
123   int enable_obmc;
124   int enable_onesided_comp;
125   int enable_reduced_reference_set;
126   int enable_smooth_interintra;
127   int enable_diff_wtd_comp;
128   int enable_dist_wtd_comp;
129   int enable_dual_filter;
130   AVDictionary *aom_params;
131 } AOMContext;
132 
133  static const char *const ctlidstr[] = {
134  [AOME_SET_CPUUSED] = "AOME_SET_CPUUSED",
135  [AOME_SET_CQ_LEVEL] = "AOME_SET_CQ_LEVEL",
136  [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
137  [AOME_SET_ARNR_MAXFRAMES] = "AOME_SET_ARNR_MAXFRAMES",
138  [AOME_SET_ARNR_STRENGTH] = "AOME_SET_ARNR_STRENGTH",
139  [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
140  [AV1E_SET_COLOR_RANGE] = "AV1E_SET_COLOR_RANGE",
141  [AV1E_SET_COLOR_PRIMARIES] = "AV1E_SET_COLOR_PRIMARIES",
142  [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
143  [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
144  [AV1E_SET_AQ_MODE] = "AV1E_SET_AQ_MODE",
145  [AV1E_SET_FRAME_PARALLEL_DECODING] = "AV1E_SET_FRAME_PARALLEL_DECODING",
146  [AV1E_SET_SUPERBLOCK_SIZE] = "AV1E_SET_SUPERBLOCK_SIZE",
147  [AV1E_SET_TILE_COLUMNS] = "AV1E_SET_TILE_COLUMNS",
148  [AV1E_SET_TILE_ROWS] = "AV1E_SET_TILE_ROWS",
149  [AV1E_SET_ENABLE_RESTORATION] = "AV1E_SET_ENABLE_RESTORATION",
150 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
151  [AV1E_SET_ROW_MT] = "AV1E_SET_ROW_MT",
152 #endif
153 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
154  [AV1E_SET_DENOISE_NOISE_LEVEL] = "AV1E_SET_DENOISE_NOISE_LEVEL",
155 #endif
156 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
157  [AV1E_SET_DENOISE_BLOCK_SIZE] = "AV1E_SET_DENOISE_BLOCK_SIZE",
158 #endif
159 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
160  [AV1E_SET_MAX_REFERENCE_FRAMES] = "AV1E_SET_MAX_REFERENCE_FRAMES",
161 #endif
162 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
163  [AV1E_SET_ENABLE_GLOBAL_MOTION] = "AV1E_SET_ENABLE_GLOBAL_MOTION",
164 #endif
165 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
166  [AV1E_SET_ENABLE_INTRABC] = "AV1E_SET_ENABLE_INTRABC",
167 #endif
168  [AV1E_SET_ENABLE_CDEF] = "AV1E_SET_ENABLE_CDEF",
169  [AOME_SET_TUNING] = "AOME_SET_TUNING",
170 #if AOM_ENCODER_ABI_VERSION >= 22
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 #endif
200 };
201 
202  static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
203 {
204  AOMContext *ctx = avctx->priv_data;
205  const char *error = aom_codec_error(&ctx->encoder);
206  const char *detail = aom_codec_error_detail(&ctx->encoder);
207 
208  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
209  if (detail)
210  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
211 }
212 
213  static av_cold void dump_enc_cfg(AVCodecContext *avctx,
214  const struct aom_codec_enc_cfg *cfg,
215  int level)
216 {
217  int width = -30;
218 
219  av_log(avctx, level, "aom_codec_enc_cfg\n");
220  av_log(avctx, level, "generic settings\n"
221  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
222  " %*s%u\n %*s%u\n"
223  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
224  width, "g_usage:", cfg->g_usage,
225  width, "g_threads:", cfg->g_threads,
226  width, "g_profile:", cfg->g_profile,
227  width, "g_w:", cfg->g_w,
228  width, "g_h:", cfg->g_h,
229  width, "g_bit_depth:", cfg->g_bit_depth,
230  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
231  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
232  width, "g_error_resilient:", cfg->g_error_resilient,
233  width, "g_pass:", cfg->g_pass,
234  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
235  av_log(avctx, level, "rate control settings\n"
236  " %*s%u\n %*s%d\n %*s%p(%"SIZE_SPECIFIER ")\n %*s%u\n",
237  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
238  width, "rc_end_usage:", cfg->rc_end_usage,
239  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
240  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
241  av_log(avctx, level, "quantizer settings\n"
242  " %*s%u\n %*s%u\n",
243  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
244  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
245  av_log(avctx, level, "bitrate tolerance\n"
246  " %*s%u\n %*s%u\n",
247  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
248  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
249  av_log(avctx, level, "decoder buffer model\n"
250  " %*s%u\n %*s%u\n %*s%u\n",
251  width, "rc_buf_sz:", cfg->rc_buf_sz,
252  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
253  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
254  av_log(avctx, level, "2 pass rate control settings\n"
255  " %*s%u\n %*s%u\n %*s%u\n",
256  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
257  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
258  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
259  av_log(avctx, level, "keyframing settings\n"
260  " %*s%d\n %*s%u\n %*s%u\n",
261  width, "kf_mode:", cfg->kf_mode,
262  width, "kf_min_dist:", cfg->kf_min_dist,
263  width, "kf_max_dist:", cfg->kf_max_dist);
264  av_log(avctx, level, "tile settings\n"
265  " %*s%d\n %*s%d\n",
266  width, "tile_width_count:", cfg->tile_width_count,
267  width, "tile_height_count:", cfg->tile_height_count);
268  av_log(avctx, level, "\n");
269 }
270 
271  static void coded_frame_add(void *list, struct FrameListData *cx_frame)
272 {
273  struct FrameListData **p = list;
274 
275  while (*p)
276  p = &(*p)->next;
277  *p = cx_frame;
278  cx_frame->next = NULL;
279 }
280 
281  static av_cold void free_coded_frame(struct FrameListData *cx_frame)
282 {
283  av_freep(&cx_frame->buf);
284  av_freep(&cx_frame);
285 }
286 
287  static av_cold void free_frame_list(struct FrameListData *list)
288 {
289  struct FrameListData *p = list;
290 
291  while (p) {
292  list = list->next;
293  free_coded_frame(p);
294  p = list;
295  }
296 }
297 
298  static av_cold int codecctl_int(AVCodecContext *avctx,
299 #ifdef UENUM1BYTE
300  aome_enc_control_id id,
301 #else
302  enum aome_enc_control_id id,
303 #endif
304  int val)
305 {
306  AOMContext *ctx = avctx->priv_data;
307  char buf[80];
308  int width = -30;
309  int res;
310 
311  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
312  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
313 
314  res = aom_codec_control(&ctx->encoder, id, val);
315  if (res != AOM_CODEC_OK) {
316  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
317  ctlidstr[id]);
318  log_encoder_error(avctx, buf);
319  return AVERROR(EINVAL);
320  }
321 
322  return 0;
323 }
324 
325  static av_cold int aom_free(AVCodecContext *avctx)
326 {
327  AOMContext *ctx = avctx->priv_data;
328 
329  aom_codec_destroy(&ctx->encoder);
330  av_freep(&ctx->twopass_stats.buf);
331  av_freep(&avctx->stats_out);
332  free_frame_list(ctx->coded_frame_list);
333  av_bsf_free(&ctx->bsf);
334  return 0;
335 }
336 
337  static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
338  struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
339  aom_img_fmt_t *img_fmt)
340 {
341  AOMContext av_unused *ctx = avctx->priv_data;
342  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
343  enccfg->g_bit_depth = enccfg->g_input_bit_depth = desc->comp[0].depth;
344  switch (avctx->pix_fmt) {
345  case AV_PIX_FMT_GRAY8:
346  enccfg->monochrome = 1;
347  /* Fall-through */
348  case AV_PIX_FMT_YUV420P:
349  enccfg->g_profile = FF_PROFILE_AV1_MAIN;
350  *img_fmt = AOM_IMG_FMT_I420;
351  return 0;
352  case AV_PIX_FMT_YUV422P:
353  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
354  *img_fmt = AOM_IMG_FMT_I422;
355  return 0;
356  case AV_PIX_FMT_YUV444P:
357  case AV_PIX_FMT_GBRP:
358  enccfg->g_profile = FF_PROFILE_AV1_HIGH;
359  *img_fmt = AOM_IMG_FMT_I444;
360  return 0;
361  case AV_PIX_FMT_GRAY10:
362  case AV_PIX_FMT_GRAY12:
363  enccfg->monochrome = 1;
364  /* Fall-through */
365  case AV_PIX_FMT_YUV420P10:
366  case AV_PIX_FMT_YUV420P12:
367  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
368  enccfg->g_profile =
369  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
370  *img_fmt = AOM_IMG_FMT_I42016;
371  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
372  return 0;
373  }
374  break;
375  case AV_PIX_FMT_YUV422P10:
376  case AV_PIX_FMT_YUV422P12:
377  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
378  enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
379  *img_fmt = AOM_IMG_FMT_I42216;
380  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
381  return 0;
382  }
383  break;
384  case AV_PIX_FMT_YUV444P10:
385  case AV_PIX_FMT_YUV444P12:
386  case AV_PIX_FMT_GBRP10:
387  case AV_PIX_FMT_GBRP12:
388  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
389  enccfg->g_profile =
390  enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
391  *img_fmt = AOM_IMG_FMT_I44416;
392  *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
393  return 0;
394  }
395  break;
396  default:
397  break;
398  }
399  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
400  return AVERROR_INVALIDDATA;
401 }
402 
403  static void set_color_range(AVCodecContext *avctx)
404 {
405  aom_color_range_t aom_cr;
406  switch (avctx->color_range) {
407  case AVCOL_RANGE_UNSPECIFIED:
408  case AVCOL_RANGE_MPEG: aom_cr = AOM_CR_STUDIO_RANGE; break;
409  case AVCOL_RANGE_JPEG: aom_cr = AOM_CR_FULL_RANGE; break;
410  default:
411  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
412  avctx->color_range);
413  return;
414  }
415 
416  codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
417 }
418 
419  static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
420 {
421  int sb_dim = (dim + sb_size - 1) / sb_size;
422  int tile_dim = (sb_dim + (1 << tiles_log2) - 1) >> tiles_log2;
423  av_assert0(tile_dim > 0);
424  return (sb_dim + tile_dim - 1) / tile_dim;
425 }
426 
427  static int choose_tiling(AVCodecContext *avctx,
428  struct aom_codec_enc_cfg *enccfg)
429 {
430  AOMContext *ctx = avctx->priv_data;
431  int sb_128x128_possible, sb_size, sb_width, sb_height;
432  int uniform_rows, uniform_cols;
433  int uniform_64x64_possible, uniform_128x128_possible;
434  int tile_size, rounding, i;
435 
436  if (ctx->tile_cols_log2 >= 0)
437  ctx->tile_cols = 1 << ctx->tile_cols_log2;
438  if (ctx->tile_rows_log2 >= 0)
439  ctx->tile_rows = 1 << ctx->tile_rows_log2;
440 
441  if (ctx->tile_cols == 0) {
442  ctx->tile_cols = (avctx->width + AV1_MAX_TILE_WIDTH - 1) /
443  AV1_MAX_TILE_WIDTH;
444  if (ctx->tile_cols > 1) {
445  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
446  "columns to fill width.\n", ctx->tile_cols);
447  }
448  }
449  av_assert0(ctx->tile_cols > 0);
450  if (ctx->tile_rows == 0) {
451  int max_tile_width =
452  FFALIGN((FFALIGN(avctx->width, 128) +
453  ctx->tile_cols - 1) / ctx->tile_cols, 128);
454  ctx->tile_rows =
455  (max_tile_width * FFALIGN(avctx->height, 128) +
456  AV1_MAX_TILE_AREA - 1) / AV1_MAX_TILE_AREA;
457  if (ctx->tile_rows > 1) {
458  av_log(avctx, AV_LOG_DEBUG, "Automatically using %d tile "
459  "rows to fill area.\n", ctx->tile_rows);
460  }
461  }
462  av_assert0(ctx->tile_rows > 0);
463 
464  if ((avctx->width + 63) / 64 < ctx->tile_cols ||
465  (avctx->height + 63) / 64 < ctx->tile_rows) {
466  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: frame not "
467  "large enough to fit specified tile arrangement.\n");
468  return AVERROR(EINVAL);
469  }
470  if (ctx->tile_cols > AV1_MAX_TILE_COLS ||
471  ctx->tile_rows > AV1_MAX_TILE_ROWS) {
472  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
473  "not allow more than %dx%d tiles.\n",
474  AV1_MAX_TILE_COLS, AV1_MAX_TILE_ROWS);
475  return AVERROR(EINVAL);
476  }
477  if (avctx->width / ctx->tile_cols > AV1_MAX_TILE_WIDTH) {
478  av_log(avctx, AV_LOG_ERROR, "Invalid tile sizing: AV1 does "
479  "not allow tiles of width greater than %d.\n",
480  AV1_MAX_TILE_WIDTH);
481  return AVERROR(EINVAL);
482  }
483 
484  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_DYNAMIC;
485 
486  if (ctx->tile_cols == 1 && ctx->tile_rows == 1) {
487  av_log(avctx, AV_LOG_DEBUG, "Using a single tile.\n");
488  return 0;
489  }
490 
491  sb_128x128_possible =
492  (avctx->width + 127) / 128 >= ctx->tile_cols &&
493  (avctx->height + 127) / 128 >= ctx->tile_rows;
494 
495  ctx->tile_cols_log2 = ctx->tile_cols == 1 ? 0 :
496  av_log2(ctx->tile_cols - 1) + 1;
497  ctx->tile_rows_log2 = ctx->tile_rows == 1 ? 0 :
498  av_log2(ctx->tile_rows - 1) + 1;
499 
500  uniform_cols = count_uniform_tiling(avctx->width,
501  64, ctx->tile_cols_log2);
502  uniform_rows = count_uniform_tiling(avctx->height,
503  64, ctx->tile_rows_log2);
504  av_log(avctx, AV_LOG_DEBUG, "Uniform with 64x64 superblocks "
505  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
506  uniform_64x64_possible = uniform_cols == ctx->tile_cols &&
507  uniform_rows == ctx->tile_rows;
508 
509  if (sb_128x128_possible) {
510  uniform_cols = count_uniform_tiling(avctx->width,
511  128, ctx->tile_cols_log2);
512  uniform_rows = count_uniform_tiling(avctx->height,
513  128, ctx->tile_rows_log2);
514  av_log(avctx, AV_LOG_DEBUG, "Uniform with 128x128 superblocks "
515  "-> %dx%d tiles.\n", uniform_cols, uniform_rows);
516  uniform_128x128_possible = uniform_cols == ctx->tile_cols &&
517  uniform_rows == ctx->tile_rows;
518  } else {
519  av_log(avctx, AV_LOG_DEBUG, "128x128 superblocks not possible.\n");
520  uniform_128x128_possible = 0;
521  }
522 
523  ctx->uniform_tiles = 1;
524  if (uniform_64x64_possible && uniform_128x128_possible) {
525  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with dynamic "
526  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
527  ctx->tile_cols_log2, ctx->tile_rows_log2);
528  return 0;
529  }
530  if (uniform_64x64_possible && !sb_128x128_possible) {
531  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 64x64 "
532  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
533  ctx->tile_cols_log2, ctx->tile_rows_log2);
534  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
535  return 0;
536  }
537  if (uniform_128x128_possible) {
538  av_log(avctx, AV_LOG_DEBUG, "Using uniform tiling with 128x128 "
539  "superblocks (tile_cols_log2 = %d, tile_rows_log2 = %d).\n",
540  ctx->tile_cols_log2, ctx->tile_rows_log2);
541  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
542  return 0;
543  }
544  ctx->uniform_tiles = 0;
545 
546  if (sb_128x128_possible) {
547  sb_size = 128;
548  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_128X128;
549  } else {
550  sb_size = 64;
551  ctx->superblock_size = AOM_SUPERBLOCK_SIZE_64X64;
552  }
553  av_log(avctx, AV_LOG_DEBUG, "Using fixed tiling with %dx%d "
554  "superblocks (tile_cols = %d, tile_rows = %d).\n",
555  sb_size, sb_size, ctx->tile_cols, ctx->tile_rows);
556 
557  enccfg->tile_width_count = ctx->tile_cols;
558  enccfg->tile_height_count = ctx->tile_rows;
559 
560  sb_width = (avctx->width + sb_size - 1) / sb_size;
561  sb_height = (avctx->height + sb_size - 1) / sb_size;
562 
563  tile_size = sb_width / ctx->tile_cols;
564  rounding = sb_width % ctx->tile_cols;
565  for (i = 0; i < ctx->tile_cols; i++) {
566  enccfg->tile_widths[i] = tile_size +
567  (i < rounding / 2 ||
568  i > ctx->tile_cols - 1 - (rounding + 1) / 2);
569  }
570 
571  tile_size = sb_height / ctx->tile_rows;
572  rounding = sb_height % ctx->tile_rows;
573  for (i = 0; i < ctx->tile_rows; i++) {
574  enccfg->tile_heights[i] = tile_size +
575  (i < rounding / 2 ||
576  i > ctx->tile_rows - 1 - (rounding + 1) / 2);
577  }
578 
579  return 0;
580 }
581 
582  static av_cold int aom_init(AVCodecContext *avctx,
583  const struct aom_codec_iface *iface)
584 {
585  AOMContext *ctx = avctx->priv_data;
586  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
587  struct aom_codec_enc_cfg enccfg = { 0 };
588 #ifdef AOM_FRAME_IS_INTRAONLY
589  aom_codec_flags_t flags =
590  (avctx->flags & AV_CODEC_FLAG_PSNR) ? AOM_CODEC_USE_PSNR : 0;
591 #else
592  aom_codec_flags_t flags = 0;
593 #endif
594  AVCPBProperties *cpb_props;
595  int res;
596  aom_img_fmt_t img_fmt;
597  aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
598 
599  av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
600  av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
601 
602  if ((res = aom_codec_enc_config_default(iface, &enccfg, ctx->usage)) != AOM_CODEC_OK) {
603  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
604  aom_codec_err_to_string(res));
605  return AVERROR(EINVAL);
606  }
607 
608  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
609  return AVERROR(EINVAL);
610 
611  if(!avctx->bit_rate)
612  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
613  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
614  return AVERROR(EINVAL);
615  }
616 
617  dump_enc_cfg(avctx, &enccfg, AV_LOG_DEBUG);
618 
619  enccfg.g_w = avctx->width;
620  enccfg.g_h = avctx->height;
621  enccfg.g_timebase.num = avctx->time_base.num;
622  enccfg.g_timebase.den = avctx->time_base.den;
623  enccfg.g_threads =
624  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 64);
625 
626  if (ctx->lag_in_frames >= 0)
627  enccfg.g_lag_in_frames = ctx->lag_in_frames;
628 
629  if (avctx->flags & AV_CODEC_FLAG_PASS1)
630  enccfg.g_pass = AOM_RC_FIRST_PASS;
631  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
632  enccfg.g_pass = AOM_RC_LAST_PASS;
633  else
634  enccfg.g_pass = AOM_RC_ONE_PASS;
635 
636  if (avctx->rc_min_rate == avctx->rc_max_rate &&
637  avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
638  enccfg.rc_end_usage = AOM_CBR;
639  } else if (ctx->crf >= 0) {
640  enccfg.rc_end_usage = AOM_CQ;
641  if (!avctx->bit_rate)
642  enccfg.rc_end_usage = AOM_Q;
643  }
644 
645  if (avctx->bit_rate) {
646  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
647  AV_ROUND_NEAR_INF);
648  } else if (enccfg.rc_end_usage != AOM_Q) {
649  enccfg.rc_end_usage = AOM_Q;
650  ctx->crf = 32;
651  av_log(avctx, AV_LOG_WARNING,
652  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
653  ctx->crf);
654  }
655 
656  if (avctx->qmin >= 0)
657  enccfg.rc_min_quantizer = avctx->qmin;
658  if (avctx->qmax >= 0) {
659  enccfg.rc_max_quantizer = avctx->qmax;
660  } else if (!ctx->crf) {
661  enccfg.rc_max_quantizer = 0;
662  }
663 
664  if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
665  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
666  av_log(avctx, AV_LOG_ERROR,
667  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
668  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
669  return AVERROR(EINVAL);
670  }
671  }
672 
673  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
674 
675  // 0-100 (0 => CBR, 100 => VBR)
676  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
677  if (ctx->minsection_pct >= 0)
678  enccfg.rc_2pass_vbr_minsection_pct = ctx->minsection_pct;
679  else if (avctx->bit_rate)
680  enccfg.rc_2pass_vbr_minsection_pct =
681  avctx->rc_min_rate * 100LL / avctx->bit_rate;
682  if (ctx->maxsection_pct >= 0)
683  enccfg.rc_2pass_vbr_maxsection_pct = ctx->maxsection_pct;
684  else if (avctx->rc_max_rate)
685  enccfg.rc_2pass_vbr_maxsection_pct =
686  avctx->rc_max_rate * 100LL / avctx->bit_rate;
687 
688  if (avctx->rc_buffer_size)
689  enccfg.rc_buf_sz =
690  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
691  if (avctx->rc_initial_buffer_occupancy)
692  enccfg.rc_buf_initial_sz =
693  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
694  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
695 
696  if (ctx->rc_undershoot_pct >= 0)
697  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
698  if (ctx->rc_overshoot_pct >= 0)
699  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
700 
701  // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
702  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
703  enccfg.kf_min_dist = avctx->keyint_min;
704  if (avctx->gop_size >= 0)
705  enccfg.kf_max_dist = avctx->gop_size;
706 
707  if (enccfg.g_pass == AOM_RC_FIRST_PASS)
708  enccfg.g_lag_in_frames = 0;
709  else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
710  int decode_size, ret;
711 
712  if (!avctx->stats_in) {
713  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
714  return AVERROR_INVALIDDATA;
715  }
716 
717  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
718  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
719  if (ret < 0) {
720  av_log(avctx, AV_LOG_ERROR,
721  "Stat buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",
722  ctx->twopass_stats.sz);
723  ctx->twopass_stats.sz = 0;
724  return ret;
725  }
726  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
727  ctx->twopass_stats.sz);
728  if (decode_size < 0) {
729  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
730  return AVERROR_INVALIDDATA;
731  }
732 
733  ctx->twopass_stats.sz = decode_size;
734  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
735  }
736 
737  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
738  * complexity playback on low powered devices at the expense of encode
739  * quality. */
740  if (avctx->profile != FF_PROFILE_UNKNOWN)
741  enccfg.g_profile = avctx->profile;
742 
743  enccfg.g_error_resilient = ctx->error_resilient;
744 
745  res = choose_tiling(avctx, &enccfg);
746  if (res < 0)
747  return res;
748 
749  /* Construct Encoder Context */
750  res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
751  if (res != AOM_CODEC_OK) {
752  dump_enc_cfg(avctx, &enccfg, AV_LOG_WARNING);
753  log_encoder_error(avctx, "Failed to initialize encoder");
754  return AVERROR(EINVAL);
755  }
756  dump_enc_cfg(avctx, &enccfg, AV_LOG_DEBUG);
757 
758  // codec control failures are currently treated only as warnings
759  av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
760  codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
761  if (ctx->auto_alt_ref >= 0)
762  codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
763  if (ctx->arnr_max_frames >= 0)
764  codecctl_int(avctx, AOME_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
765  if (ctx->arnr_strength >= 0)
766  codecctl_int(avctx, AOME_SET_ARNR_STRENGTH, ctx->arnr_strength);
767  if (ctx->enable_cdef >= 0)
768  codecctl_int(avctx, AV1E_SET_ENABLE_CDEF, ctx->enable_cdef);
769  if (ctx->enable_restoration >= 0)
770  codecctl_int(avctx, AV1E_SET_ENABLE_RESTORATION, ctx->enable_restoration);
771 #if AOM_ENCODER_ABI_VERSION >= 22
772  if (ctx->enable_rect_partitions >= 0)
773  codecctl_int(avctx, AV1E_SET_ENABLE_RECT_PARTITIONS, ctx->enable_rect_partitions);
774  if (ctx->enable_1to4_partitions >= 0)
775  codecctl_int(avctx, AV1E_SET_ENABLE_1TO4_PARTITIONS, ctx->enable_1to4_partitions);
776  if (ctx->enable_ab_partitions >= 0)
777  codecctl_int(avctx, AV1E_SET_ENABLE_AB_PARTITIONS, ctx->enable_ab_partitions);
778  if (ctx->enable_angle_delta >= 0)
779  codecctl_int(avctx, AV1E_SET_ENABLE_ANGLE_DELTA, ctx->enable_angle_delta);
780  if (ctx->enable_cfl_intra >= 0)
781  codecctl_int(avctx, AV1E_SET_ENABLE_CFL_INTRA, ctx->enable_cfl_intra);
782  if (ctx->enable_filter_intra >= 0)
783  codecctl_int(avctx, AV1E_SET_ENABLE_FILTER_INTRA, ctx->enable_filter_intra);
784  if (ctx->enable_intra_edge_filter >= 0)
785  codecctl_int(avctx, AV1E_SET_ENABLE_INTRA_EDGE_FILTER, ctx->enable_intra_edge_filter);
786  if (ctx->enable_paeth_intra >= 0)
787  codecctl_int(avctx, AV1E_SET_ENABLE_PAETH_INTRA, ctx->enable_paeth_intra);
788  if (ctx->enable_smooth_intra >= 0)
789  codecctl_int(avctx, AV1E_SET_ENABLE_SMOOTH_INTRA, ctx->enable_smooth_intra);
790  if (ctx->enable_palette >= 0)
791  codecctl_int(avctx, AV1E_SET_ENABLE_PALETTE, ctx->enable_palette);
792  if (ctx->enable_tx64 >= 0)
793  codecctl_int(avctx, AV1E_SET_ENABLE_TX64, ctx->enable_tx64);
794  if (ctx->enable_flip_idtx >= 0)
795  codecctl_int(avctx, AV1E_SET_ENABLE_FLIP_IDTX, ctx->enable_flip_idtx);
796  if (ctx->use_intra_dct_only >= 0)
797  codecctl_int(avctx, AV1E_SET_INTRA_DCT_ONLY, ctx->use_intra_dct_only);
798  if (ctx->use_inter_dct_only >= 0)
799  codecctl_int(avctx, AV1E_SET_INTER_DCT_ONLY, ctx->use_inter_dct_only);
800  if (ctx->use_intra_default_tx_only >= 0)
801  codecctl_int(avctx, AV1E_SET_INTRA_DEFAULT_TX_ONLY, ctx->use_intra_default_tx_only);
802  if (ctx->reduced_tx_type_set >= 0)
803  codecctl_int(avctx, AV1E_SET_REDUCED_TX_TYPE_SET, ctx->reduced_tx_type_set);
804  if (ctx->enable_ref_frame_mvs >= 0)
805  codecctl_int(avctx, AV1E_SET_ENABLE_REF_FRAME_MVS, ctx->enable_ref_frame_mvs);
806  if (ctx->enable_reduced_reference_set >= 0)
807  codecctl_int(avctx, AV1E_SET_REDUCED_REFERENCE_SET, ctx->enable_reduced_reference_set);
808  if (ctx->enable_diff_wtd_comp >= 0)
809  codecctl_int(avctx, AV1E_SET_ENABLE_DIFF_WTD_COMP, ctx->enable_diff_wtd_comp);
810  if (ctx->enable_dist_wtd_comp >= 0)
811  codecctl_int(avctx, AV1E_SET_ENABLE_DIST_WTD_COMP, ctx->enable_dist_wtd_comp);
812  if (ctx->enable_dual_filter >= 0)
813  codecctl_int(avctx, AV1E_SET_ENABLE_DUAL_FILTER, ctx->enable_dual_filter);
814  if (ctx->enable_interinter_wedge >= 0)
815  codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTER_WEDGE, ctx->enable_interinter_wedge);
816  if (ctx->enable_masked_comp >= 0)
817  codecctl_int(avctx, AV1E_SET_ENABLE_MASKED_COMP, ctx->enable_masked_comp);
818  if (ctx->enable_interintra_comp >= 0)
819  codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTRA_COMP, ctx->enable_interintra_comp);
820  if (ctx->enable_interintra_wedge >= 0)
821  codecctl_int(avctx, AV1E_SET_ENABLE_INTERINTRA_WEDGE, ctx->enable_interintra_wedge);
822  if (ctx->enable_obmc >= 0)
823  codecctl_int(avctx, AV1E_SET_ENABLE_OBMC, ctx->enable_obmc);
824  if (ctx->enable_onesided_comp >= 0)
825  codecctl_int(avctx, AV1E_SET_ENABLE_ONESIDED_COMP, ctx->enable_onesided_comp);
826  if (ctx->enable_smooth_interintra >= 0)
827  codecctl_int(avctx, AV1E_SET_ENABLE_SMOOTH_INTERINTRA, ctx->enable_smooth_interintra);
828 #endif
829 
830  codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
831  if (ctx->crf >= 0)
832  codecctl_int(avctx, AOME_SET_CQ_LEVEL, ctx->crf);
833  if (ctx->tune >= 0)
834  codecctl_int(avctx, AOME_SET_TUNING, ctx->tune);
835 
836  if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
837  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, AVCOL_PRI_BT709);
838  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, AVCOL_SPC_RGB);
839  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, AVCOL_TRC_IEC61966_2_1);
840  } else {
841  codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
842  codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
843  codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
844  }
845  if (ctx->aq_mode >= 0)
846  codecctl_int(avctx, AV1E_SET_AQ_MODE, ctx->aq_mode);
847  if (ctx->frame_parallel >= 0)
848  codecctl_int(avctx, AV1E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
849  set_color_range(avctx);
850 
851  codecctl_int(avctx, AV1E_SET_SUPERBLOCK_SIZE, ctx->superblock_size);
852  if (ctx->uniform_tiles) {
853  codecctl_int(avctx, AV1E_SET_TILE_COLUMNS, ctx->tile_cols_log2);
854  codecctl_int(avctx, AV1E_SET_TILE_ROWS, ctx->tile_rows_log2);
855  }
856 
857 #ifdef AOM_CTRL_AV1E_SET_DENOISE_NOISE_LEVEL
858  if (ctx->denoise_noise_level >= 0)
859  codecctl_int(avctx, AV1E_SET_DENOISE_NOISE_LEVEL, ctx->denoise_noise_level);
860 #endif
861 #ifdef AOM_CTRL_AV1E_SET_DENOISE_BLOCK_SIZE
862  if (ctx->denoise_block_size >= 0)
863  codecctl_int(avctx, AV1E_SET_DENOISE_BLOCK_SIZE, ctx->denoise_block_size);
864 #endif
865 #ifdef AOM_CTRL_AV1E_SET_ENABLE_GLOBAL_MOTION
866  if (ctx->enable_global_motion >= 0)
867  codecctl_int(avctx, AV1E_SET_ENABLE_GLOBAL_MOTION, ctx->enable_global_motion);
868 #endif
869 #ifdef AOM_CTRL_AV1E_SET_MAX_REFERENCE_FRAMES
870  if (avctx->refs >= 3) {
871  codecctl_int(avctx, AV1E_SET_MAX_REFERENCE_FRAMES, avctx->refs);
872  }
873 #endif
874 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
875  if (ctx->row_mt >= 0)
876  codecctl_int(avctx, AV1E_SET_ROW_MT, ctx->row_mt);
877 #endif
878 #ifdef AOM_CTRL_AV1E_SET_ENABLE_INTRABC
879  if (ctx->enable_intrabc >= 0)
880  codecctl_int(avctx, AV1E_SET_ENABLE_INTRABC, ctx->enable_intrabc);
881 #endif
882 
883 #if AOM_ENCODER_ABI_VERSION >= 23
884  {
885  AVDictionaryEntry *en = NULL;
886 
887  while ((en = av_dict_get(ctx->aom_params, "", en, AV_DICT_IGNORE_SUFFIX))) {
888  int ret = aom_codec_set_option(&ctx->encoder, en->key, en->value);
889  if (ret != AOM_CODEC_OK) {
890  log_encoder_error(avctx, en->key);
891  return AVERROR_EXTERNAL;
892  }
893  }
894  }
895 #endif
896 
897  // provide dummy value to initialize wrapper, values will be updated each _encode()
898  aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
899  (unsigned char*)1);
900 
901  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
902  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
903 
904  cpb_props = ff_add_cpb_side_data(avctx);
905  if (!cpb_props)
906  return AVERROR(ENOMEM);
907 
908  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
909  const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
910  int ret;
911 
912  if (!filter) {
913  av_log(avctx, AV_LOG_ERROR, "extract_extradata bitstream filter "
914  "not found. This is a bug, please report it.\n");
915  return AVERROR_BUG;
916  }
917  ret = av_bsf_alloc(filter, &ctx->bsf);
918  if (ret < 0)
919  return ret;
920 
921  ret = avcodec_parameters_from_context(ctx->bsf->par_in, avctx);
922  if (ret < 0)
923  return ret;
924 
925  ret = av_bsf_init(ctx->bsf);
926  if (ret < 0)
927  return ret;
928  }
929 
930  if (enccfg.rc_end_usage == AOM_CBR ||
931  enccfg.g_pass != AOM_RC_ONE_PASS) {
932  cpb_props->max_bitrate = avctx->rc_max_rate;
933  cpb_props->min_bitrate = avctx->rc_min_rate;
934  cpb_props->avg_bitrate = avctx->bit_rate;
935  }
936  cpb_props->buffer_size = avctx->rc_buffer_size;
937 
938  return 0;
939 }
940 
941  static inline void cx_pktcpy(AOMContext *ctx,
942  struct FrameListData *dst,
943  const struct aom_codec_cx_pkt *src)
944 {
945  dst->pts = src->data.frame.pts;
946  dst->duration = src->data.frame.duration;
947  dst->flags = src->data.frame.flags;
948  dst->sz = src->data.frame.sz;
949  dst->buf = src->data.frame.buf;
950 #ifdef AOM_FRAME_IS_INTRAONLY
951  dst->frame_number = ++ctx->frame_number;
952  dst->have_sse = ctx->have_sse;
953  if (ctx->have_sse) {
954  /* associate last-seen SSE to the frame. */
955  /* Transfers ownership from ctx to dst. */
956  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
957  ctx->have_sse = 0;
958  }
959 #endif
960 }
961 
962 /**
963  * Store coded frame information in format suitable for return from encode2().
964  *
965  * Write information from @a cx_frame to @a pkt
966  * @return packet data size on success
967  * @return a negative AVERROR on error
968  */
969  static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
970  AVPacket *pkt)
971 {
972  AOMContext *ctx = avctx->priv_data;
973  int av_unused pict_type;
974  int ret = ff_get_encode_buffer(avctx, pkt, cx_frame->sz, 0);
975  if (ret < 0) {
976  av_log(avctx, AV_LOG_ERROR,
977  "Error getting output packet of size %"SIZE_SPECIFIER ".\n", cx_frame->sz);
978  return ret;
979  }
980  memcpy(pkt->data, cx_frame->buf, pkt->size);
981  pkt->pts = pkt->dts = cx_frame->pts;
982 
983  if (!!(cx_frame->flags & AOM_FRAME_IS_KEY)) {
984  pkt->flags |= AV_PKT_FLAG_KEY;
985 #ifdef AOM_FRAME_IS_INTRAONLY
986  pict_type = AV_PICTURE_TYPE_I;
987  } else if (cx_frame->flags & AOM_FRAME_IS_INTRAONLY) {
988  pict_type = AV_PICTURE_TYPE_I;
989  } else {
990  pict_type = AV_PICTURE_TYPE_P;
991  }
992 
993  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
994  cx_frame->have_sse ? 3 : 0, pict_type);
995 
996  if (cx_frame->have_sse) {
997  int i;
998  for (i = 0; i < 3; ++i) {
999  avctx->error[i] += cx_frame->sse[i + 1];
1000  }
1001  cx_frame->have_sse = 0;
1002 #endif
1003  }
1004 
1005  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1006  ret = av_bsf_send_packet(ctx->bsf, pkt);
1007  if (ret < 0) {
1008  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
1009  "failed to send input packet\n");
1010  return ret;
1011  }
1012  ret = av_bsf_receive_packet(ctx->bsf, pkt);
1013 
1014  if (ret < 0) {
1015  av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
1016  "failed to receive output packet\n");
1017  return ret;
1018  }
1019  }
1020  return pkt->size;
1021 }
1022 
1023 /**
1024  * Queue multiple output frames from the encoder, returning the front-most.
1025  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
1026  * the frame queue. Return the head frame if available.
1027  * @return Stored frame size
1028  * @return AVERROR(EINVAL) on output size error
1029  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
1030  */
1031  static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
1032 {
1033  AOMContext *ctx = avctx->priv_data;
1034  const struct aom_codec_cx_pkt *pkt;
1035  const void *iter = NULL;
1036  int size = 0;
1037 
1038  if (ctx->coded_frame_list) {
1039  struct FrameListData *cx_frame = ctx->coded_frame_list;
1040  /* return the leading frame if we've already begun queueing */
1041  size = storeframe(avctx, cx_frame, pkt_out);
1042  if (size < 0)
1043  return size;
1044  ctx->coded_frame_list = cx_frame->next;
1045  free_coded_frame(cx_frame);
1046  }
1047 
1048  /* consume all available output from the encoder before returning. buffers
1049  * are only good through the next aom_codec call */
1050  while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
1051  switch (pkt->kind) {
1052  case AOM_CODEC_CX_FRAME_PKT:
1053  if (!size) {
1054  struct FrameListData cx_frame;
1055 
1056  /* avoid storing the frame when the list is empty and we haven't yet
1057  * provided a frame for output */
1058  av_assert0(!ctx->coded_frame_list);
1059  cx_pktcpy(ctx, &cx_frame, pkt);
1060  size = storeframe(avctx, &cx_frame, pkt_out);
1061  if (size < 0)
1062  return size;
1063  } else {
1064  struct FrameListData *cx_frame =
1065  av_malloc(sizeof(struct FrameListData));
1066 
1067  if (!cx_frame) {
1068  av_log(avctx, AV_LOG_ERROR,
1069  "Frame queue element alloc failed\n");
1070  return AVERROR(ENOMEM);
1071  }
1072  cx_pktcpy(ctx, cx_frame, pkt);
1073  cx_frame->buf = av_malloc(cx_frame->sz);
1074 
1075  if (!cx_frame->buf) {
1076  av_log(avctx, AV_LOG_ERROR,
1077  "Data buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",
1078  cx_frame->sz);
1079  av_freep(&cx_frame);
1080  return AVERROR(ENOMEM);
1081  }
1082  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
1083  coded_frame_add(&ctx->coded_frame_list, cx_frame);
1084  }
1085  break;
1086  case AOM_CODEC_STATS_PKT:
1087  {
1088  struct aom_fixed_buf *stats = &ctx->twopass_stats;
1089  int err;
1090  if ((err = av_reallocp(&stats->buf,
1091  stats->sz +
1092  pkt->data.twopass_stats.sz)) < 0) {
1093  stats->sz = 0;
1094  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
1095  return err;
1096  }
1097  memcpy((uint8_t *)stats->buf + stats->sz,
1098  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1099  stats->sz += pkt->data.twopass_stats.sz;
1100  break;
1101  }
1102 #ifdef AOM_FRAME_IS_INTRAONLY
1103  case AOM_CODEC_PSNR_PKT:
1104  {
1105  av_assert0(!ctx->have_sse);
1106  ctx->sse[0] = pkt->data.psnr.sse[0];
1107  ctx->sse[1] = pkt->data.psnr.sse[1];
1108  ctx->sse[2] = pkt->data.psnr.sse[2];
1109  ctx->sse[3] = pkt->data.psnr.sse[3];
1110  ctx->have_sse = 1;
1111  break;
1112  }
1113 #endif
1114  case AOM_CODEC_CUSTOM_PKT:
1115  // ignore unsupported/unrecognized packet types
1116  break;
1117  }
1118  }
1119 
1120  return size;
1121 }
1122 
1123  static int aom_encode(AVCodecContext *avctx, AVPacket *pkt,
1124  const AVFrame *frame, int *got_packet)
1125 {
1126  AOMContext *ctx = avctx->priv_data;
1127  struct aom_image *rawimg = NULL;
1128  int64_t timestamp = 0;
1129  int res, coded_size;
1130  aom_enc_frame_flags_t flags = 0;
1131 
1132  if (frame) {
1133  rawimg = &ctx->rawimg;
1134  rawimg->planes[AOM_PLANE_Y] = frame->data[0];
1135  rawimg->planes[AOM_PLANE_U] = frame->data[1];
1136  rawimg->planes[AOM_PLANE_V] = frame->data[2];
1137  rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
1138  rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
1139  rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
1140  timestamp = frame->pts;
1141  switch (frame->color_range) {
1142  case AVCOL_RANGE_MPEG:
1143  rawimg->range = AOM_CR_STUDIO_RANGE;
1144  break;
1145  case AVCOL_RANGE_JPEG:
1146  rawimg->range = AOM_CR_FULL_RANGE;
1147  break;
1148  }
1149 
1150  if (frame->pict_type == AV_PICTURE_TYPE_I)
1151  flags |= AOM_EFLAG_FORCE_KF;
1152  }
1153 
1154  res = aom_codec_encode(&ctx->encoder, rawimg, timestamp,
1155  avctx->ticks_per_frame, flags);
1156  if (res != AOM_CODEC_OK) {
1157  log_encoder_error(avctx, "Error encoding frame");
1158  return AVERROR_INVALIDDATA;
1159  }
1160  coded_size = queue_frames(avctx, pkt);
1161 
1162  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1163  size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1164 
1165  avctx->stats_out = av_malloc(b64_size);
1166  if (!avctx->stats_out) {
1167  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER " bytes) failed\n",
1168  b64_size);
1169  return AVERROR(ENOMEM);
1170  }
1171  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1172  ctx->twopass_stats.sz);
1173  }
1174 
1175  *got_packet = !!coded_size;
1176  return 0;
1177 }
1178 
1179  static const enum AVPixelFormat av1_pix_fmts[] = {
1180  AV_PIX_FMT_YUV420P,
1181  AV_PIX_FMT_YUV422P,
1182  AV_PIX_FMT_YUV444P,
1183  AV_PIX_FMT_GBRP,
1184  AV_PIX_FMT_NONE
1185 };
1186 
1187  static const enum AVPixelFormat av1_pix_fmts_with_gray[] = {
1188  AV_PIX_FMT_YUV420P,
1189  AV_PIX_FMT_YUV422P,
1190  AV_PIX_FMT_YUV444P,
1191  AV_PIX_FMT_GBRP,
1192  AV_PIX_FMT_GRAY8,
1193  AV_PIX_FMT_NONE
1194 };
1195 
1196  static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
1197  AV_PIX_FMT_YUV420P,
1198  AV_PIX_FMT_YUV422P,
1199  AV_PIX_FMT_YUV444P,
1200  AV_PIX_FMT_GBRP,
1201  AV_PIX_FMT_YUV420P10,
1202  AV_PIX_FMT_YUV422P10,
1203  AV_PIX_FMT_YUV444P10,
1204  AV_PIX_FMT_YUV420P12,
1205  AV_PIX_FMT_YUV422P12,
1206  AV_PIX_FMT_YUV444P12,
1207  AV_PIX_FMT_GBRP10,
1208  AV_PIX_FMT_GBRP12,
1209  AV_PIX_FMT_NONE
1210 };
1211 
1212  static const enum AVPixelFormat av1_pix_fmts_highbd_with_gray[] = {
1213  AV_PIX_FMT_YUV420P,
1214  AV_PIX_FMT_YUV422P,
1215  AV_PIX_FMT_YUV444P,
1216  AV_PIX_FMT_GBRP,
1217  AV_PIX_FMT_YUV420P10,
1218  AV_PIX_FMT_YUV422P10,
1219  AV_PIX_FMT_YUV444P10,
1220  AV_PIX_FMT_YUV420P12,
1221  AV_PIX_FMT_YUV422P12,
1222  AV_PIX_FMT_YUV444P12,
1223  AV_PIX_FMT_GBRP10,
1224  AV_PIX_FMT_GBRP12,
1225  AV_PIX_FMT_GRAY8,
1226  AV_PIX_FMT_GRAY10,
1227  AV_PIX_FMT_GRAY12,
1228  AV_PIX_FMT_NONE
1229 };
1230 
1231  static av_cold void av1_init_static(AVCodec *codec)
1232 {
1233  int supports_monochrome = aom_codec_version() >= 20001;
1234  aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
1235  if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
1236  codec->pix_fmts = supports_monochrome ? av1_pix_fmts_highbd_with_gray :
1237  av1_pix_fmts_highbd;
1238  else
1239  codec->pix_fmts = supports_monochrome ? av1_pix_fmts_with_gray :
1240  av1_pix_fmts;
1241 
1242  if (aom_codec_version_major() < 2)
1243  codec->capabilities |= AV_CODEC_CAP_EXPERIMENTAL;
1244 }
1245 
1246  static av_cold int av1_init(AVCodecContext *avctx)
1247 {
1248  return aom_init(avctx, aom_codec_av1_cx());
1249 }
1250 
1251  #define OFFSET(x) offsetof(AOMContext, x)
1252  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1253  static const AVOption options[] = {
1254  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 8, VE},
1255  { "auto-alt-ref", "Enable use of alternate reference "
1256  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1257  { "lag-in-frames", "Number of frames to look ahead at for "
1258  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1259  { "arnr-max-frames", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1260  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1261  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
1262  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode"},
1263  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode"},
1264  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode"},
1265  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode"},
1266  { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
1267  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
1268  { "crf", "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
1269  { "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 },
1270  { "drop-threshold", "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
1271  { "denoise-noise-level", "Amount of noise to be removed", OFFSET(denoise_noise_level), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1272  { "denoise-block-size", "Denoise block size ", OFFSET(denoise_block_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
1273  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1274  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1000, VE},
1275  { "minsection-pct", "GOP min bitrate (% of target)", OFFSET(minsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 100, VE},
1276  { "maxsection-pct", "GOP max bitrate (% of target)", OFFSET(maxsection_pct), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 5000, VE},
1277  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1278  { "tiles", "Tile columns x rows", OFFSET(tile_cols), AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, 0, VE },
1279  { "tile-columns", "Log2 of number of tile columns to use", OFFSET(tile_cols_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1280  { "tile-rows", "Log2 of number of tile rows to use", OFFSET(tile_rows_log2), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1281  { "row-mt", "Enable row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1282  { "enable-cdef", "Enable CDEF filtering", OFFSET(enable_cdef), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1283  { "enable-global-motion", "Enable global motion", OFFSET(enable_global_motion), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1284  { "enable-intrabc", "Enable intra block copy prediction mode", OFFSET(enable_intrabc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1285  { "enable-restoration", "Enable Loop Restoration filtering", OFFSET(enable_restoration), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1286  { "usage", "Quality and compression efficiency vs speed trade-off", OFFSET(usage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, "usage"},
1287  { "good", "Good quality", 0, AV_OPT_TYPE_CONST, {.i64 = 0 /* AOM_USAGE_GOOD_QUALITY */}, 0, 0, VE, "usage"},
1288  { "realtime", "Realtime encoding", 0, AV_OPT_TYPE_CONST, {.i64 = 1 /* AOM_USAGE_REALTIME */}, 0, 0, VE, "usage"},
1289  { "tune", "The metric that the encoder tunes for. Automatically chosen by the encoder by default", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, AOM_TUNE_SSIM, VE, "tune"},
1290  { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AOM_TUNE_PSNR}, 0, 0, VE, "tune"},
1291  { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AOM_TUNE_SSIM}, 0, 0, VE, "tune"},
1292  FF_AV1_PROFILE_OPTS
1293  { "enable-rect-partitions", "Enable rectangular partitions", OFFSET(enable_rect_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1294  { "enable-1to4-partitions", "Enable 1:4/4:1 partitions", OFFSET(enable_1to4_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1295  { "enable-ab-partitions", "Enable ab shape partitions", OFFSET(enable_ab_partitions), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1296  { "enable-angle-delta", "Enable angle delta intra prediction", OFFSET(enable_angle_delta), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1297  { "enable-cfl-intra", "Enable chroma predicted from luma intra prediction", OFFSET(enable_cfl_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1298  { "enable-filter-intra", "Enable filter intra predictor", OFFSET(enable_filter_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1299  { "enable-intra-edge-filter", "Enable intra edge filter", OFFSET(enable_intra_edge_filter), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1300  { "enable-smooth-intra", "Enable smooth intra prediction mode", OFFSET(enable_smooth_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1301  { "enable-paeth-intra", "Enable paeth predictor in intra prediction", OFFSET(enable_paeth_intra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1302  { "enable-palette", "Enable palette prediction mode", OFFSET(enable_palette), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1303  { "enable-flip-idtx", "Enable extended transform type", OFFSET(enable_flip_idtx), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1304  { "enable-tx64", "Enable 64-pt transform", OFFSET(enable_tx64), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1305  { "reduced-tx-type-set", "Use reduced set of transform types", OFFSET(reduced_tx_type_set), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1306  { "use-intra-dct-only", "Use DCT only for INTRA modes", OFFSET(use_intra_dct_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1307  { "use-inter-dct-only", "Use DCT only for INTER modes", OFFSET(use_inter_dct_only), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1308  { "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},
1309  { "enable-ref-frame-mvs", "Enable temporal mv prediction", OFFSET(enable_ref_frame_mvs), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1310  { "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},
1311  { "enable-obmc", "Enable obmc", OFFSET(enable_obmc), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1312  { "enable-dual-filter", "Enable dual filter", OFFSET(enable_dual_filter), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1313  { "enable-diff-wtd-comp", "Enable difference-weighted compound", OFFSET(enable_diff_wtd_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1314  { "enable-dist-wtd-comp", "Enable distance-weighted compound", OFFSET(enable_dist_wtd_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1315  { "enable-onesided-comp", "Enable one sided compound", OFFSET(enable_onesided_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1316  { "enable-interinter-wedge", "Enable interinter wedge compound", OFFSET(enable_interinter_wedge), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1317  { "enable-interintra-wedge", "Enable interintra wedge compound", OFFSET(enable_interintra_wedge), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1318  { "enable-masked-comp", "Enable masked compound", OFFSET(enable_masked_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1319  { "enable-interintra-comp", "Enable interintra compound", OFFSET(enable_interintra_comp), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1320  { "enable-smooth-interintra", "Enable smooth interintra mode", OFFSET(enable_smooth_interintra), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1321 #if AOM_ENCODER_ABI_VERSION >= 23
1322  { "aom-params", "Set libaom options using a :-separated list of key=value pairs", OFFSET(aom_params), AV_OPT_TYPE_DICT, { 0 }, 0, 0, VE },
1323 #endif
1324  { NULL },
1325 };
1326 
1327  static const AVCodecDefault defaults[] = {
1328  { "b", "0" },
1329  { "qmin", "-1" },
1330  { "qmax", "-1" },
1331  { "g", "-1" },
1332  { "keyint_min", "-1" },
1333  { NULL },
1334 };
1335 
1336  static const AVClass class_aom = {
1337  .class_name = "libaom-av1 encoder",
1338  .item_name = av_default_item_name,
1339  .option = options,
1340  .version = LIBAVUTIL_VERSION_INT,
1341 };
1342 
1343  AVCodec ff_libaom_av1_encoder = {
1344  .name = "libaom-av1",
1345  .long_name = NULL_IF_CONFIG_SMALL("libaom AV1"),
1346  .type = AVMEDIA_TYPE_VIDEO,
1347  .id = AV_CODEC_ID_AV1,
1348  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1349  AV_CODEC_CAP_OTHER_THREADS,
1350  .priv_data_size = sizeof(AOMContext),
1351  .init = av1_init,
1352  .encode2 = aom_encode,
1353  .close = aom_free,
1354  .caps_internal = FF_CODEC_CAP_AUTO_THREADS,
1355  .profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
1356  .priv_class = &class_aom,
1357  .defaults = defaults,
1358  .init_static_data = av1_init_static,
1359  .wrapper_name = "libaom",
1360 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AOMEncoderContext::error_resilient
int error_resilient
Definition: libaomenc.c:77
AOMEncoderContext::usage
int usage
Definition: libaomenc.c:100
AVCodec
AVCodec.
Definition: codec.h:202
dump_enc_cfg
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct aom_codec_enc_cfg *cfg, int level)
Definition: libaomenc.c:213
AOMEncoderContext::enable_filter_intra
int enable_filter_intra
Definition: libaomenc.c:111
AOMEncoderContext::enable_paeth_intra
int enable_paeth_intra
Definition: libaomenc.c:107
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AOMEncoderContext::tile_rows_log2
int tile_rows_log2
Definition: libaomenc.c:92
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AOMEncoderContext::enable_interintra_comp
int enable_interintra_comp
Definition: libaomenc.c:121
level
uint8_t level
Definition: svq3.c:204
FrameListData::pts
int64_t pts
time stamp to show frame (in timebase units)
Definition: libaomenc.c:53
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:925
AOMEncoderContext::sse
uint64_t sse[4]
Definition: libaomenc.c:83
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:403
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1201
aom_init
static av_cold int aom_init(AVCodecContext *avctx, const struct aom_codec_iface *iface)
Definition: libaomenc.c:582
ff_libaom_av1_encoder
AVCodec ff_libaom_av1_encoder
Definition: libaomenc.c:1343
stats
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
Definition: vp9_superframe_bsf.c:34
AOMEncoderContext::enable_restoration
int enable_restoration
Definition: libaomenc.c:99
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:604
avcodec_parameters_from_context
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:90
AOMEncoderContext::enable_smooth_intra
int enable_smooth_intra
Definition: libaomenc.c:108
AOMEncoderContext::enable_1to4_partitions
int enable_1to4_partitions
Definition: libaomenc.c:103
FF_AV1_PROFILE_OPTS
#define FF_AV1_PROFILE_OPTS
Definition: profiles.h:54
AOMEncoderContext::denoise_noise_level
int denoise_noise_level
Definition: libaomenc.c:81
av_unused
#define av_unused
Definition: attributes.h:131
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:224
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:145
AOMEncoderContext::lag_in_frames
int lag_in_frames
Definition: libaomenc.c:76
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:953
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:221
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:597
coded_frame_add
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libaomenc.c:271
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AV1_MAX_TILE_ROWS
@ AV1_MAX_TILE_ROWS
Definition: av1.h:80
AOMEncoderContext::frame_number
uint64_t frame_number
Definition: libaomenc.c:85
AVOption
AVOption.
Definition: opt.h:247
encode.h
AOMEncoderContext::use_intra_default_tx_only
int use_intra_default_tx_only
Definition: libaomenc.c:117
cx_pktcpy
static void cx_pktcpy(AOMContext *ctx, struct FrameListData *dst, const struct aom_codec_cx_pkt *src)
Definition: libaomenc.c:941
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:404
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:524
mathematics.h
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
AVDictionary
Definition: dict.c:30
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:247
AOMEncoderContext::aom_params
AVDictionary * aom_params
Definition: libaomenc.c:130
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:990
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1165
options
static const AVOption options[]
Definition: libaomenc.c:1253
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
AVBSFContext
The bitstream filter state.
Definition: bsf.h:47
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:268
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:78
init
static int init
Definition: av_tx.c:47
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:969
FrameListData::flags
uint32_t flags
flags for this frame
Definition: libaomenc.c:57
AOMEncoderContext::cpu_used
int cpu_used
Definition: libaomenc.c:71
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:508
bsf.h
AOMEncoderContext::enable_ab_partitions
int enable_ab_partitions
Definition: libaomenc.c:104
AOMEncoderContext::coded_frame_list
struct FrameListData * coded_frame_list
Definition: libaomenc.c:70
AOMEncoderContext::static_thresh
int static_thresh
Definition: libaomenc.c:79
AV1_MAX_TILE_AREA
@ AV1_MAX_TILE_AREA
Definition: av1.h:79
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:420
AOMEncoderContext::minsection_pct
int minsection_pct
Definition: libaomenc.c:88
AOMEncoderContext::uniform_tiles
int uniform_tiles
Definition: libaomenc.c:94
AOMEncoderContext::enable_ref_frame_mvs
int enable_ref_frame_mvs
Definition: libaomenc.c:118
AOMEncoderContext::row_mt
int row_mt
Definition: libaomenc.c:95
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:932
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
AOMEncoderContext::denoise_block_size
int denoise_block_size
Definition: libaomenc.c:82
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVRational::num
int num
Numerator.
Definition: rational.h:59
AOMEncoderContext::use_inter_dct_only
int use_inter_dct_only
Definition: libaomenc.c:116
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:407
free_coded_frame
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libaomenc.c:281
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:946
count_uniform_tiling
static int count_uniform_tiling(int dim, int sb_size, int tiles_log2)
Definition: libaomenc.c:419
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:105
av_cold
#define av_cold
Definition: attributes.h:90
AOMEncoderContext::enable_angle_delta
int enable_angle_delta
Definition: libaomenc.c:105
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:1222
AOMEncoderContext::enable_cdef
int enable_cdef
Definition: libaomenc.c:96
AOMEncoderContext::enable_smooth_interintra
int enable_smooth_interintra
Definition: libaomenc.c:126
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
AOMEncoderContext::twopass_stats
struct aom_fixed_buf twopass_stats
Definition: libaomenc.c:69
width
#define width
queue_frames
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
Definition: libaomenc.c:1031
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:1244
codecctl_int
static av_cold int codecctl_int(AVCodecContext *avctx, enum aome_enc_control_id id, int val)
Definition: libaomenc.c:298
AVDictionaryEntry::key
char * key
Definition: dict.h:80
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:515
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:127
FrameListData::sse
uint64_t sse[4]
Definition: libaomenc.c:58
AOMEncoderContext::enable_interintra_wedge
int enable_interintra_wedge
Definition: libaomenc.c:120
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1526
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AOMEncoderContext::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:84
AOMEncoderContext::enable_obmc
int enable_obmc
Definition: libaomenc.c:123
FrameListData::frame_number
uint64_t frame_number
Definition: libaomenc.c:60
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
set_pix_fmt
static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps, struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags, aom_img_fmt_t *img_fmt)
Definition: libaomenc.c:337
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_av1_profiles
const AVProfile ff_av1_profiles[]
Definition: profiles.c:147
tile_cols
int tile_cols
Definition: h265_levels.c:218
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1194
AOMEncoderContext::superblock_size
aom_superblock_size_t superblock_size
Definition: libaomenc.c:93
AVCodecContext::error
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1377
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
AOMEncoderContext::enable_dist_wtd_comp
int enable_dist_wtd_comp
Definition: libaomenc.c:128
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:385
AVCodecDefault
Definition: internal.h:215
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1179
AOMEncoderContext::drop_threshold
int drop_threshold
Definition: libaomenc.c:80
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AOMEncoderContext::tile_rows
int tile_rows
Definition: libaomenc.c:91
NULL
#define NULL
Definition: coverity.c:32
AOMEncoderContext
Definition: libaomenc.c:64
AOMEncoderContext::rc_overshoot_pct
int rc_overshoot_pct
Definition: libaomenc.c:87
AOMEncoderContext::enable_diff_wtd_comp
int enable_diff_wtd_comp
Definition: libaomenc.c:127
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:279
AOMEncoderContext::enable_palette
int enable_palette
Definition: libaomenc.c:110
AOMEncoderContext::arnr_max_frames
int arnr_max_frames
Definition: libaomenc.c:73
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:234
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:231
AOMEncoderContext::enable_tx64
int enable_tx64
Definition: libaomenc.c:113
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:471
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
profiles.h
src
#define src
Definition: vp8dsp.c:255
list
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
FrameListData::buf
void * buf
compressed data buffer
Definition: libaomenc.c:51
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
AOMEncoderContext::rc_undershoot_pct
int rc_undershoot_pct
Definition: libaomenc.c:86
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:405
AV1_MAX_TILE_COLS
@ AV1_MAX_TILE_COLS
Definition: av1.h:81
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:79
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
defaults
static const AVCodecDefault defaults[]
Definition: libaomenc.c:1327
base64.h
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:563
AOMEncoderContext::enable_global_motion
int enable_global_motion
Definition: libaomenc.c:97
AOMEncoderContext::encoder
struct aom_codec_ctx encoder
Definition: libaomenc.c:67
av1_init
static av_cold int av1_init(AVCodecContext *avctx)
Definition: libaomenc.c:1246
AOMEncoderContext::enable_onesided_comp
int enable_onesided_comp
Definition: libaomenc.c:124
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:191
usage
const char * usage
Definition: floatimg_cmp.c:60
AVCodecContext::qcompress
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1150
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:506
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:81
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:57
FrameListData::next
struct FrameListData * next
Definition: libaomenc.c:61
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1236
ctlidstr
static const char *const ctlidstr[]
Definition: libaomenc.c:133
FF_PROFILE_AV1_MAIN
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:1621
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:374
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:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:578
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
AOMEncoderContext::enable_flip_idtx
int enable_flip_idtx
Definition: libaomenc.c:112
cpu.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:409
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:185
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:411
aom_encode
static int aom_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libaomenc.c:1123
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:114
av1.h
FrameListData
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libaomenc.c:50
AOMEncoderContext::tile_cols_log2
int tile_cols_log2
Definition: libaomenc.c:92
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:235
AOMEncoderContext::tile_cols
int tile_cols
Definition: libaomenc.c:91
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
AOMEncoderContext::rawimg
struct aom_image rawimg
Definition: libaomenc.c:68
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:119
AOMEncoderContext::enable_dual_filter
int enable_dual_filter
Definition: libaomenc.c:129
AOMEncoderContext::aq_mode
int aq_mode
Definition: libaomenc.c:75
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AOMEncoderContext::enable_cfl_intra
int enable_cfl_intra
Definition: libaomenc.c:106
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
AOMEncoderContext::arnr_strength
int arnr_strength
Definition: libaomenc.c:74
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:226
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:421
AOMEncoderContext::enable_interinter_wedge
int enable_interinter_wedge
Definition: libaomenc.c:119
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
FrameListData::duration
unsigned long duration
duration to show frame (in timebase units)
Definition: libaomenc.c:55
AOMEncoderContext::auto_alt_ref
int auto_alt_ref
Definition: libaomenc.c:72
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:580
FF_PROFILE_AV1_PROFESSIONAL
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1623
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:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
av1_pix_fmts_with_gray
static enum AVPixelFormat av1_pix_fmts_with_gray[]
Definition: libaomenc.c:1187
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:125
AOMEncoderContext::bsf
AVBSFContext * bsf
Definition: libaomenc.c:66
log_encoder_error
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libaomenc.c:202
AV1_MAX_TILE_WIDTH
@ AV1_MAX_TILE_WIDTH
Definition: av1.h:78
VE
#define VE
Definition: libaomenc.c:1252
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:408
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:198
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
free_frame_list
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libaomenc.c:287
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AOMEncoderContext::enable_rect_partitions
int enable_rect_partitions
Definition: libaomenc.c:102
AVBitStreamFilter
Definition: bsf.h:90
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:78
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1158
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
choose_tiling
static int choose_tiling(AVCodecContext *avctx, struct aom_codec_enc_cfg *enccfg)
Definition: libaomenc.c:427
AOMEncoderContext::maxsection_pct
int maxsection_pct
Definition: libaomenc.c:89
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:143
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
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:82
AOMEncoderContext::enable_intra_edge_filter
int enable_intra_edge_filter
Definition: libaomenc.c:109
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
class_aom
static const AVClass class_aom
Definition: libaomenc.c:1336
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
desc
const char * desc
Definition: libsvtav1.c:79
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
packet_internal.h
av1_pix_fmts
static enum AVPixelFormat av1_pix_fmts[]
Definition: libaomenc.c:1179
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:125
AVDictionaryEntry
Definition: dict.h:79
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AOMEncoderContext::frame_parallel
int frame_parallel
Definition: libaomenc.c:90
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
av1_pix_fmts_highbd
static enum AVPixelFormat av1_pix_fmts_highbd[]
Definition: libaomenc.c:1196
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:48
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:223
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AOMEncoderContext::enable_masked_comp
int enable_masked_comp
Definition: libaomenc.c:122
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FrameListData::sz
size_t sz
length of compressed data
Definition: libaomenc.c:52
AOMEncoderContext::reduced_tx_type_set
int reduced_tx_type_set
Definition: libaomenc.c:114
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
FF_PROFILE_AV1_HIGH
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1622
AVDictionaryEntry::value
char * value
Definition: dict.h:81
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:386
av1_init_static
static av_cold void av1_init_static(AVCodec *codec)
Definition: libaomenc.c:1231
AOMEncoderContext::enable_intrabc
int enable_intrabc
Definition: libaomenc.c:98
aom_free
static av_cold int aom_free(AVCodecContext *avctx)
Definition: libaomenc.c:325
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
snprintf
#define snprintf
Definition: snprintf.h:34
AOMEncoderContext::tune
int tune
Definition: libaomenc.c:101
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AOMEncoderContext::crf
int crf
Definition: libaomenc.c:78
OFFSET
#define OFFSET(x)
Definition: libaomenc.c:1251
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:100
AOMEncoderContext::use_intra_dct_only
int use_intra_dct_only
Definition: libaomenc.c:115
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:231
FrameListData::have_sse
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:59
av1_pix_fmts_highbd_with_gray
static enum AVPixelFormat av1_pix_fmts_highbd_with_gray[]
Definition: libaomenc.c:1212
Generated on Wed Aug 24 2022 21:37:39 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /