FFmpeg
libvpxenc.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  * VP8/9 encoder support via libvpx
24  */
25 
26 #define VPX_DISABLE_CTRL_TYPECHECKS 1
27 #define VPX_CODEC_DISABLE_COMPAT 1
28 #include <vpx/vpx_encoder.h>
29 #include <vpx/vp8cx.h>
30 
31 #include "avcodec.h"
32 #include "internal.h"
33 #include "libavutil/avassert.h"
34 #include "libvpx.h"
35 #include "packet_internal.h"
36 #include "profiles.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/base64.h"
39 #include "libavutil/common.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/opt.h"
44 #include "libavutil/pixdesc.h"
45 
46 /**
47  * Portion of struct vpx_codec_cx_pkt from vpx_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  void *buf_alpha;
54  size_t sz_alpha;
55  int64_t pts; /**< time stamp to show frame
56  (in timebase units) */
57  unsigned long duration; /**< duration to show frame
58  (in timebase units) */
59  uint32_t flags; /**< flags for this frame */
60  uint64_t sse[4];
61  int have_sse; /**< true if we have pending sse[] */
62  uint64_t frame_number;
63  struct FrameListData *next;
64 };
65 
66 typedef struct VPxEncoderContext {
67  AVClass *class;
68  struct vpx_codec_ctx encoder;
69  struct vpx_image rawimg;
70  struct vpx_codec_ctx encoder_alpha;
71  struct vpx_image rawimg_alpha;
73  struct vpx_fixed_buf twopass_stats;
74  int deadline; //i.e., RT/GOOD/BEST
75  uint64_t sse[4];
76  int have_sse; /**< true if we have pending sse[] */
77  uint64_t frame_number;
79 
80  int cpu_used;
81  int sharpness;
82  /**
83  * VP8 specific flags, see VP8F_* below.
84  */
85  int flags;
86 #define VP8F_ERROR_RESILIENT 0x00000001 ///< Enable measures appropriate for streaming over lossy links
87 #define VP8F_AUTO_ALT_REF 0x00000002 ///< Enable automatic alternate reference frame generation
88 
90 
93  int arnr_type;
94 
95  int tune;
96 
99  int crf;
104 
108 
109  // VP9-only
110  int lossless;
114  int aq_mode;
117  int vpx_cs;
118  float level;
119  int row_mt;
123  /**
124  * If the driver does not support ROI then warn the first time we
125  * encounter a frame with ROI side data.
126  */
128 } VPxContext;
129 
130 /** String mappings for enum vp8e_enc_control_id */
131 static const char *const ctlidstr[] = {
132  [VP8E_SET_CPUUSED] = "VP8E_SET_CPUUSED",
133  [VP8E_SET_ENABLEAUTOALTREF] = "VP8E_SET_ENABLEAUTOALTREF",
134  [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",
135  [VP8E_SET_STATIC_THRESHOLD] = "VP8E_SET_STATIC_THRESHOLD",
136  [VP8E_SET_TOKEN_PARTITIONS] = "VP8E_SET_TOKEN_PARTITIONS",
137  [VP8E_SET_ARNR_MAXFRAMES] = "VP8E_SET_ARNR_MAXFRAMES",
138  [VP8E_SET_ARNR_STRENGTH] = "VP8E_SET_ARNR_STRENGTH",
139  [VP8E_SET_ARNR_TYPE] = "VP8E_SET_ARNR_TYPE",
140  [VP8E_SET_TUNING] = "VP8E_SET_TUNING",
141  [VP8E_SET_CQ_LEVEL] = "VP8E_SET_CQ_LEVEL",
142  [VP8E_SET_MAX_INTRA_BITRATE_PCT] = "VP8E_SET_MAX_INTRA_BITRATE_PCT",
143  [VP8E_SET_SHARPNESS] = "VP8E_SET_SHARPNESS",
144  [VP8E_SET_TEMPORAL_LAYER_ID] = "VP8E_SET_TEMPORAL_LAYER_ID",
145 #if CONFIG_LIBVPX_VP9_ENCODER
146  [VP9E_SET_LOSSLESS] = "VP9E_SET_LOSSLESS",
147  [VP9E_SET_TILE_COLUMNS] = "VP9E_SET_TILE_COLUMNS",
148  [VP9E_SET_TILE_ROWS] = "VP9E_SET_TILE_ROWS",
149  [VP9E_SET_FRAME_PARALLEL_DECODING] = "VP9E_SET_FRAME_PARALLEL_DECODING",
150  [VP9E_SET_AQ_MODE] = "VP9E_SET_AQ_MODE",
151  [VP9E_SET_COLOR_SPACE] = "VP9E_SET_COLOR_SPACE",
152  [VP9E_SET_SVC_LAYER_ID] = "VP9E_SET_SVC_LAYER_ID",
153 #if VPX_ENCODER_ABI_VERSION >= 12
154  [VP9E_SET_SVC_PARAMETERS] = "VP9E_SET_SVC_PARAMETERS",
155 #endif
156  [VP9E_SET_SVC] = "VP9E_SET_SVC",
157 #if VPX_ENCODER_ABI_VERSION >= 11
158  [VP9E_SET_COLOR_RANGE] = "VP9E_SET_COLOR_RANGE",
159 #endif
160 #if VPX_ENCODER_ABI_VERSION >= 12
161  [VP9E_SET_TARGET_LEVEL] = "VP9E_SET_TARGET_LEVEL",
162  [VP9E_GET_LEVEL] = "VP9E_GET_LEVEL",
163 #endif
164 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
165  [VP9E_SET_ROW_MT] = "VP9E_SET_ROW_MT",
166 #endif
167 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
168  [VP9E_SET_TUNE_CONTENT] = "VP9E_SET_TUNE_CONTENT",
169 #endif
170 #ifdef VPX_CTRL_VP9E_SET_TPL
171  [VP9E_SET_TPL] = "VP9E_SET_TPL",
172 #endif
173 #endif
174 };
175 
176 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
177 {
178  VPxContext *ctx = avctx->priv_data;
179  const char *error = vpx_codec_error(&ctx->encoder);
180  const char *detail = vpx_codec_error_detail(&ctx->encoder);
181 
182  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
183  if (detail)
184  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
185 }
186 
188  const struct vpx_codec_enc_cfg *cfg)
189 {
190  int width = -30;
191  int level = AV_LOG_DEBUG;
192  int i;
193 
194  av_log(avctx, level, "vpx_codec_enc_cfg\n");
195  av_log(avctx, level, "generic settings\n"
196  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
197 #if CONFIG_LIBVPX_VP9_ENCODER
198  " %*s%u\n %*s%u\n"
199 #endif
200  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
201  width, "g_usage:", cfg->g_usage,
202  width, "g_threads:", cfg->g_threads,
203  width, "g_profile:", cfg->g_profile,
204  width, "g_w:", cfg->g_w,
205  width, "g_h:", cfg->g_h,
206 #if CONFIG_LIBVPX_VP9_ENCODER
207  width, "g_bit_depth:", cfg->g_bit_depth,
208  width, "g_input_bit_depth:", cfg->g_input_bit_depth,
209 #endif
210  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
211  width, "g_error_resilient:", cfg->g_error_resilient,
212  width, "g_pass:", cfg->g_pass,
213  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
214  av_log(avctx, level, "rate control settings\n"
215  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
216  " %*s%d\n %*s%p(%"SIZE_SPECIFIER")\n %*s%u\n",
217  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
218  width, "rc_resize_allowed:", cfg->rc_resize_allowed,
219  width, "rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
220  width, "rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
221  width, "rc_end_usage:", cfg->rc_end_usage,
222  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
223  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
224  av_log(avctx, level, "quantizer settings\n"
225  " %*s%u\n %*s%u\n",
226  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
227  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
228  av_log(avctx, level, "bitrate tolerance\n"
229  " %*s%u\n %*s%u\n",
230  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
231  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
232  av_log(avctx, level, "temporal layering settings\n"
233  " %*s%u\n", width, "ts_number_layers:", cfg->ts_number_layers);
234  if (avctx->codec_id == AV_CODEC_ID_VP8) {
235  av_log(avctx, level,
236  "\n %*s", width, "ts_target_bitrate:");
237  for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
238  av_log(avctx, level,
239  "%u ", cfg->ts_target_bitrate[i]);
240  }
241 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
242  if (avctx->codec_id == AV_CODEC_ID_VP9) {
243  av_log(avctx, level,
244  "\n %*s", width, "layer_target_bitrate:");
245  for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
246  av_log(avctx, level,
247  "%u ", cfg->layer_target_bitrate[i]);
248  }
249 #endif
250  av_log(avctx, level, "\n");
251  av_log(avctx, level,
252  "\n %*s", width, "ts_rate_decimator:");
253  for (i = 0; i < VPX_TS_MAX_LAYERS; i++)
254  av_log(avctx, level, "%u ", cfg->ts_rate_decimator[i]);
255  av_log(avctx, level, "\n");
256  av_log(avctx, level,
257  "\n %*s%u\n", width, "ts_periodicity:", cfg->ts_periodicity);
258  av_log(avctx, level,
259  "\n %*s", width, "ts_layer_id:");
260  for (i = 0; i < VPX_TS_MAX_PERIODICITY; i++)
261  av_log(avctx, level, "%u ", cfg->ts_layer_id[i]);
262  av_log(avctx, level, "\n");
263  av_log(avctx, level, "decoder buffer model\n"
264  " %*s%u\n %*s%u\n %*s%u\n",
265  width, "rc_buf_sz:", cfg->rc_buf_sz,
266  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
267  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
268  av_log(avctx, level, "2 pass rate control settings\n"
269  " %*s%u\n %*s%u\n %*s%u\n",
270  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
271  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
272  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
273 #if VPX_ENCODER_ABI_VERSION >= 14
274  av_log(avctx, level, " %*s%u\n",
275  width, "rc_2pass_vbr_corpus_complexity:", cfg->rc_2pass_vbr_corpus_complexity);
276 #endif
277  av_log(avctx, level, "keyframing settings\n"
278  " %*s%d\n %*s%u\n %*s%u\n",
279  width, "kf_mode:", cfg->kf_mode,
280  width, "kf_min_dist:", cfg->kf_min_dist,
281  width, "kf_max_dist:", cfg->kf_max_dist);
282  av_log(avctx, level, "\n");
283 }
284 
285 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
286 {
287  struct FrameListData **p = list;
288 
289  while (*p)
290  p = &(*p)->next;
291  *p = cx_frame;
292  cx_frame->next = NULL;
293 }
294 
295 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
296 {
297  av_freep(&cx_frame->buf);
298  if (cx_frame->buf_alpha)
299  av_freep(&cx_frame->buf_alpha);
300  av_freep(&cx_frame);
301 }
302 
304 {
305  struct FrameListData *p = list;
306 
307  while (p) {
308  list = list->next;
309  free_coded_frame(p);
310  p = list;
311  }
312 }
313 
315  enum vp8e_enc_control_id id, int val)
316 {
317  VPxContext *ctx = avctx->priv_data;
318  char buf[80];
319  int width = -30;
320  int res;
321 
322  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
323  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
324 
325  res = vpx_codec_control(&ctx->encoder, id, val);
326  if (res != VPX_CODEC_OK) {
327  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
328  ctlidstr[id]);
329  log_encoder_error(avctx, buf);
330  }
331 
332  return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
333 }
334 
335 #if VPX_ENCODER_ABI_VERSION >= 12
336 static av_cold int codecctl_intp(AVCodecContext *avctx,
337  enum vp8e_enc_control_id id, int *val)
338 {
339  VPxContext *ctx = avctx->priv_data;
340  char buf[80];
341  int width = -30;
342  int res;
343 
344  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
345  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, *val);
346 
347  res = vpx_codec_control(&ctx->encoder, id, val);
348  if (res != VPX_CODEC_OK) {
349  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
350  ctlidstr[id]);
351  log_encoder_error(avctx, buf);
352  }
353 
354  return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
355 }
356 #endif
357 
358 static av_cold int vpx_free(AVCodecContext *avctx)
359 {
360  VPxContext *ctx = avctx->priv_data;
361 
362 #if VPX_ENCODER_ABI_VERSION >= 12
363  if (avctx->codec_id == AV_CODEC_ID_VP9 && ctx->level >= 0 &&
364  !(avctx->flags & AV_CODEC_FLAG_PASS1)) {
365  int level_out = 0;
366  if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
367  av_log(avctx, AV_LOG_INFO, "Encoded level %.1f\n", level_out * 0.1);
368  }
369 #endif
370 
371  av_freep(&ctx->ts_layer_flags);
372 
373  vpx_codec_destroy(&ctx->encoder);
374  if (ctx->is_alpha) {
375  vpx_codec_destroy(&ctx->encoder_alpha);
376  av_freep(&ctx->rawimg_alpha.planes[VPX_PLANE_U]);
377  av_freep(&ctx->rawimg_alpha.planes[VPX_PLANE_V]);
378  }
379  av_freep(&ctx->twopass_stats.buf);
380  av_freep(&avctx->stats_out);
382  return 0;
383 }
384 
385 static void vp8_ts_parse_int_array(int *dest, char *value, size_t value_len, int max_entries)
386 {
387  int dest_idx = 0;
388  char *saveptr = NULL;
389  char *token = av_strtok(value, ",", &saveptr);
390 
391  while (token && dest_idx < max_entries) {
392  dest[dest_idx++] = strtoul(token, NULL, 10);
393  token = av_strtok(NULL, ",", &saveptr);
394  }
395 }
396 
397 static void set_temporal_layer_pattern(int layering_mode, vpx_codec_enc_cfg_t *cfg,
398  int *layer_flags, int *flag_periodicity)
399 {
400  switch (layering_mode) {
401  case 2: {
402  /**
403  * 2-layers, 2-frame period.
404  */
405  static const int ids[2] = { 0, 1 };
406  cfg->ts_periodicity = 2;
407  *flag_periodicity = 2;
408  cfg->ts_number_layers = 2;
409  cfg->ts_rate_decimator[0] = 2;
410  cfg->ts_rate_decimator[1] = 1;
411  memcpy(cfg->ts_layer_id, ids, sizeof(ids));
412 
413  layer_flags[0] =
414  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
415  VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
416  layer_flags[1] =
417  VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_GF |
418  VP8_EFLAG_NO_UPD_LAST |
419  VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF;
420  break;
421  }
422  case 3: {
423  /**
424  * 3-layers structure with one reference frame.
425  * This works same as temporal_layering_mode 3.
426  *
427  * 3-layers, 4-frame period.
428  */
429  static const int ids[4] = { 0, 2, 1, 2 };
430  cfg->ts_periodicity = 4;
431  *flag_periodicity = 4;
432  cfg->ts_number_layers = 3;
433  cfg->ts_rate_decimator[0] = 4;
434  cfg->ts_rate_decimator[1] = 2;
435  cfg->ts_rate_decimator[2] = 1;
436  memcpy(cfg->ts_layer_id, ids, sizeof(ids));
437 
438  /**
439  * 0=L, 1=GF, 2=ARF,
440  * Intra-layer prediction disabled.
441  */
442  layer_flags[0] =
443  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
444  VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
445  layer_flags[1] =
446  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
447  VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
448  VP8_EFLAG_NO_UPD_ARF;
449  layer_flags[2] =
450  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
451  VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
452  layer_flags[3] =
453  VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_ARF |
454  VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
455  VP8_EFLAG_NO_UPD_ARF;
456  break;
457  }
458  case 4: {
459  /**
460  * 3-layers structure.
461  * added dependency between the two TL2 frames (on top of case 3).
462  * 3-layers, 4-frame period.
463  */
464  static const int ids[4] = { 0, 2, 1, 2 };
465  cfg->ts_periodicity = 4;
466  *flag_periodicity = 4;
467  cfg->ts_number_layers = 3;
468  cfg->ts_rate_decimator[0] = 4;
469  cfg->ts_rate_decimator[1] = 2;
470  cfg->ts_rate_decimator[2] = 1;
471  memcpy(cfg->ts_layer_id, ids, sizeof(ids));
472 
473  /**
474  * 0=L, 1=GF, 2=ARF, Intra-layer prediction disabled.
475  */
476  layer_flags[0] =
477  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
478  VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
479  layer_flags[1] =
480  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
481  VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF;
482  layer_flags[2] =
483  VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF |
484  VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
485  layer_flags[3] =
486  VP8_EFLAG_NO_REF_LAST |
487  VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
488  VP8_EFLAG_NO_UPD_ARF;
489  break;
490  }
491  default:
492  /**
493  * do not change the layer_flags or the flag_periodicity in this case;
494  * it might be that the code is using external flags to be used.
495  */
496  break;
497 
498  }
499 }
500 
501 static int vpx_ts_param_parse(VPxContext *ctx, struct vpx_codec_enc_cfg *enccfg,
502  char *key, char *value, enum AVCodecID codec_id)
503 {
504  size_t value_len = strlen(value);
505  int ts_layering_mode = 0;
506 
507  if (!value_len)
508  return -1;
509 
510  if (!strcmp(key, "ts_number_layers"))
511  enccfg->ts_number_layers = strtoul(value, &value, 10);
512  else if (!strcmp(key, "ts_target_bitrate")) {
513  if (codec_id == AV_CODEC_ID_VP8)
514  vp8_ts_parse_int_array(enccfg->ts_target_bitrate, value, value_len, VPX_TS_MAX_LAYERS);
515 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
516  if (codec_id == AV_CODEC_ID_VP9)
517  vp8_ts_parse_int_array(enccfg->layer_target_bitrate, value, value_len, VPX_TS_MAX_LAYERS);
518 #endif
519  } else if (!strcmp(key, "ts_rate_decimator")) {
520  vp8_ts_parse_int_array(enccfg->ts_rate_decimator, value, value_len, VPX_TS_MAX_LAYERS);
521  } else if (!strcmp(key, "ts_periodicity")) {
522  enccfg->ts_periodicity = strtoul(value, &value, 10);
523  } else if (!strcmp(key, "ts_layer_id")) {
524  vp8_ts_parse_int_array(enccfg->ts_layer_id, value, value_len, VPX_TS_MAX_PERIODICITY);
525  } else if (!strcmp(key, "ts_layering_mode")) {
526  /* option for pre-defined temporal structures in function set_temporal_layer_pattern. */
527  ts_layering_mode = strtoul(value, &value, 4);
528  }
529 
530 #if (VPX_ENCODER_ABI_VERSION >= 12) && CONFIG_LIBVPX_VP9_ENCODER
531  enccfg->temporal_layering_mode = VP9E_TEMPORAL_LAYERING_MODE_BYPASS; // only bypass mode is supported for now.
532  enccfg->ss_number_layers = 1; // TODO: add spatial scalability support.
533 #endif
534  if (ts_layering_mode) {
535  // make sure the ts_layering_mode comes at the end of the ts_parameter string to ensure that
536  // correct configuration is done.
537  ctx->ts_layer_flags = av_malloc_array(VPX_TS_MAX_PERIODICITY, sizeof(*ctx->ts_layer_flags));
538  set_temporal_layer_pattern(ts_layering_mode, enccfg, ctx->ts_layer_flags, &enccfg->ts_periodicity);
539  }
540 
541  return 0;
542 }
543 
544 #if CONFIG_LIBVPX_VP9_ENCODER
545 static int set_pix_fmt(AVCodecContext *avctx, vpx_codec_caps_t codec_caps,
546  struct vpx_codec_enc_cfg *enccfg, vpx_codec_flags_t *flags,
547  vpx_img_fmt_t *img_fmt)
548 {
549  VPxContext av_unused *ctx = avctx->priv_data;
551  enccfg->g_bit_depth = enccfg->g_input_bit_depth = desc->comp[0].depth;
552  switch (avctx->pix_fmt) {
553  case AV_PIX_FMT_YUV420P:
554  case AV_PIX_FMT_YUVA420P:
555  enccfg->g_profile = 0;
556  *img_fmt = VPX_IMG_FMT_I420;
557  return 0;
558  case AV_PIX_FMT_YUV422P:
559  enccfg->g_profile = 1;
560  *img_fmt = VPX_IMG_FMT_I422;
561  return 0;
562  case AV_PIX_FMT_YUV440P:
563  enccfg->g_profile = 1;
564  *img_fmt = VPX_IMG_FMT_I440;
565  return 0;
566  case AV_PIX_FMT_GBRP:
567  ctx->vpx_cs = VPX_CS_SRGB;
568  case AV_PIX_FMT_YUV444P:
569  enccfg->g_profile = 1;
570  *img_fmt = VPX_IMG_FMT_I444;
571  return 0;
574  if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
575  enccfg->g_profile = 2;
576  *img_fmt = VPX_IMG_FMT_I42016;
577  *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
578  return 0;
579  }
580  break;
583  if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
584  enccfg->g_profile = 3;
585  *img_fmt = VPX_IMG_FMT_I42216;
586  *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
587  return 0;
588  }
589  break;
592  if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
593  enccfg->g_profile = 3;
594  *img_fmt = VPX_IMG_FMT_I44016;
595  *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
596  return 0;
597  }
598  break;
599  case AV_PIX_FMT_GBRP10:
600  case AV_PIX_FMT_GBRP12:
601  ctx->vpx_cs = VPX_CS_SRGB;
604  if (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH) {
605  enccfg->g_profile = 3;
606  *img_fmt = VPX_IMG_FMT_I44416;
607  *flags |= VPX_CODEC_USE_HIGHBITDEPTH;
608  return 0;
609  }
610  break;
611  default:
612  break;
613  }
614  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
615  return AVERROR_INVALIDDATA;
616 }
617 
618 static void set_colorspace(AVCodecContext *avctx)
619 {
620  enum vpx_color_space vpx_cs;
621  VPxContext *ctx = avctx->priv_data;
622 
623  if (ctx->vpx_cs) {
624  vpx_cs = ctx->vpx_cs;
625  } else {
626  switch (avctx->colorspace) {
627  case AVCOL_SPC_RGB: vpx_cs = VPX_CS_SRGB; break;
628  case AVCOL_SPC_BT709: vpx_cs = VPX_CS_BT_709; break;
629  case AVCOL_SPC_UNSPECIFIED: vpx_cs = VPX_CS_UNKNOWN; break;
630  case AVCOL_SPC_RESERVED: vpx_cs = VPX_CS_RESERVED; break;
631  case AVCOL_SPC_BT470BG: vpx_cs = VPX_CS_BT_601; break;
632  case AVCOL_SPC_SMPTE170M: vpx_cs = VPX_CS_SMPTE_170; break;
633  case AVCOL_SPC_SMPTE240M: vpx_cs = VPX_CS_SMPTE_240; break;
634  case AVCOL_SPC_BT2020_NCL: vpx_cs = VPX_CS_BT_2020; break;
635  default:
636  av_log(avctx, AV_LOG_WARNING, "Unsupported colorspace (%d)\n",
637  avctx->colorspace);
638  return;
639  }
640  }
641  codecctl_int(avctx, VP9E_SET_COLOR_SPACE, vpx_cs);
642 }
643 
644 #if VPX_ENCODER_ABI_VERSION >= 11
645 static void set_color_range(AVCodecContext *avctx)
646 {
647  enum vpx_color_range vpx_cr;
648  switch (avctx->color_range) {
650  case AVCOL_RANGE_MPEG: vpx_cr = VPX_CR_STUDIO_RANGE; break;
651  case AVCOL_RANGE_JPEG: vpx_cr = VPX_CR_FULL_RANGE; break;
652  default:
653  av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
654  avctx->color_range);
655  return;
656  }
657 
658  codecctl_int(avctx, VP9E_SET_COLOR_RANGE, vpx_cr);
659 }
660 #endif
661 #endif
662 
663 /**
664  * Set the target bitrate to VPX library default. Also set CRF to 32 if needed.
665  */
666 static void set_vp8_defaults(AVCodecContext *avctx,
667  struct vpx_codec_enc_cfg *enccfg)
668 {
669  VPxContext *ctx = avctx->priv_data;
670  av_assert0(!avctx->bit_rate);
671  avctx->bit_rate = enccfg->rc_target_bitrate * 1000;
672  if (enccfg->rc_end_usage == VPX_CQ) {
673  av_log(avctx, AV_LOG_WARNING,
674  "Bitrate not specified for constrained quality mode, using default of %dkbit/sec\n",
675  enccfg->rc_target_bitrate);
676  } else {
677  enccfg->rc_end_usage = VPX_CQ;
678  ctx->crf = 32;
679  av_log(avctx, AV_LOG_WARNING,
680  "Neither bitrate nor constrained quality specified, using default CRF of %d and bitrate of %dkbit/sec\n",
681  ctx->crf, enccfg->rc_target_bitrate);
682  }
683 }
684 
685 
686 #if CONFIG_LIBVPX_VP9_ENCODER
687 /**
688  * Keep the target bitrate at 0 to engage constant quality mode. If CRF is not
689  * set, use 32.
690  */
691 static void set_vp9_defaults(AVCodecContext *avctx,
692  struct vpx_codec_enc_cfg *enccfg)
693 {
694  VPxContext *ctx = avctx->priv_data;
695  av_assert0(!avctx->bit_rate);
696  if (enccfg->rc_end_usage != VPX_Q && ctx->lossless < 0) {
697  enccfg->rc_end_usage = VPX_Q;
698  ctx->crf = 32;
699  av_log(avctx, AV_LOG_WARNING,
700  "Neither bitrate nor constrained quality specified, using default CRF of %d\n",
701  ctx->crf);
702  }
703 }
704 #endif
705 
706 /**
707  * Called when the bitrate is not set. It sets appropriate default values for
708  * bitrate and CRF.
709  */
710 static void set_vpx_defaults(AVCodecContext *avctx,
711  struct vpx_codec_enc_cfg *enccfg)
712 {
713  av_assert0(!avctx->bit_rate);
714 #if CONFIG_LIBVPX_VP9_ENCODER
715  if (avctx->codec_id == AV_CODEC_ID_VP9) {
716  set_vp9_defaults(avctx, enccfg);
717  return;
718  }
719 #endif
720  set_vp8_defaults(avctx, enccfg);
721 }
722 
723 static av_cold int vpx_init(AVCodecContext *avctx,
724  const struct vpx_codec_iface *iface)
725 {
726  VPxContext *ctx = avctx->priv_data;
727  struct vpx_codec_enc_cfg enccfg = { 0 };
728  struct vpx_codec_enc_cfg enccfg_alpha;
729  vpx_codec_flags_t flags = (avctx->flags & AV_CODEC_FLAG_PSNR) ? VPX_CODEC_USE_PSNR : 0;
730  AVCPBProperties *cpb_props;
731  int res;
732  vpx_img_fmt_t img_fmt = VPX_IMG_FMT_I420;
733 #if CONFIG_LIBVPX_VP9_ENCODER
734  vpx_codec_caps_t codec_caps = vpx_codec_get_caps(iface);
735  vpx_svc_extra_cfg_t svc_params;
736 #endif
737  AVDictionaryEntry* en = NULL;
738 
739  av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
740  av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
741 
742  if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P)
743  ctx->is_alpha = 1;
744 
745  if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
746  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
747  vpx_codec_err_to_string(res));
748  return AVERROR(EINVAL);
749  }
750 
751 #if CONFIG_LIBVPX_VP9_ENCODER
752  if (avctx->codec_id == AV_CODEC_ID_VP9) {
753  if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
754  return AVERROR(EINVAL);
755  }
756 #endif
757 
758  if(!avctx->bit_rate)
759  if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
760  av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
761  return AVERROR(EINVAL);
762  }
763 
764  dump_enc_cfg(avctx, &enccfg);
765 
766  enccfg.g_w = avctx->width;
767  enccfg.g_h = avctx->height;
768  enccfg.g_timebase.num = avctx->time_base.num;
769  enccfg.g_timebase.den = avctx->time_base.den;
770  enccfg.g_threads =
771  FFMIN(avctx->thread_count ? avctx->thread_count : av_cpu_count(), 16);
772  enccfg.g_lag_in_frames= ctx->lag_in_frames;
773 
774  if (avctx->flags & AV_CODEC_FLAG_PASS1)
775  enccfg.g_pass = VPX_RC_FIRST_PASS;
776  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
777  enccfg.g_pass = VPX_RC_LAST_PASS;
778  else
779  enccfg.g_pass = VPX_RC_ONE_PASS;
780 
781  if (avctx->rc_min_rate == avctx->rc_max_rate &&
782  avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
783  enccfg.rc_end_usage = VPX_CBR;
784  } else if (ctx->crf >= 0) {
785  enccfg.rc_end_usage = VPX_CQ;
786 #if CONFIG_LIBVPX_VP9_ENCODER
787  if (!avctx->bit_rate && avctx->codec_id == AV_CODEC_ID_VP9)
788  enccfg.rc_end_usage = VPX_Q;
789 #endif
790  }
791 
792  if (avctx->bit_rate) {
793  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
795 #if CONFIG_LIBVPX_VP9_ENCODER
796  enccfg.ss_target_bitrate[0] = enccfg.rc_target_bitrate;
797 #endif
798  } else {
799  // Set bitrate to default value. Also sets CRF to default if needed.
800  set_vpx_defaults(avctx, &enccfg);
801  }
802 
803  if (avctx->codec_id == AV_CODEC_ID_VP9 && ctx->lossless == 1) {
804  enccfg.rc_min_quantizer =
805  enccfg.rc_max_quantizer = 0;
806  } else {
807  if (avctx->qmin >= 0)
808  enccfg.rc_min_quantizer = avctx->qmin;
809  if (avctx->qmax >= 0)
810  enccfg.rc_max_quantizer = avctx->qmax;
811  }
812 
813  if (enccfg.rc_end_usage == VPX_CQ
814 #if CONFIG_LIBVPX_VP9_ENCODER
815  || enccfg.rc_end_usage == VPX_Q
816 #endif
817  ) {
818  if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
819  av_log(avctx, AV_LOG_ERROR,
820  "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
821  ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
822  return AVERROR(EINVAL);
823  }
824  }
825 
826 #if FF_API_PRIVATE_OPT
828  if (avctx->frame_skip_threshold)
829  ctx->drop_threshold = avctx->frame_skip_threshold;
831 #endif
832  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
833 
834  //0-100 (0 => CBR, 100 => VBR)
835  enccfg.rc_2pass_vbr_bias_pct = lrint(avctx->qcompress * 100);
836  if (avctx->bit_rate)
837  enccfg.rc_2pass_vbr_minsection_pct =
838  avctx->rc_min_rate * 100LL / avctx->bit_rate;
839  if (avctx->rc_max_rate)
840  enccfg.rc_2pass_vbr_maxsection_pct =
841  avctx->rc_max_rate * 100LL / avctx->bit_rate;
842 #if CONFIG_LIBVPX_VP9_ENCODER
843  if (avctx->codec_id == AV_CODEC_ID_VP9) {
844 #if VPX_ENCODER_ABI_VERSION >= 14
845  if (ctx->corpus_complexity >= 0)
846  enccfg.rc_2pass_vbr_corpus_complexity = ctx->corpus_complexity;
847 #endif
848  }
849 #endif
850 
851  if (avctx->rc_buffer_size)
852  enccfg.rc_buf_sz =
853  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
854  if (avctx->rc_initial_buffer_occupancy)
855  enccfg.rc_buf_initial_sz =
856  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
857  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
858  if (ctx->rc_undershoot_pct >= 0)
859  enccfg.rc_undershoot_pct = ctx->rc_undershoot_pct;
860  if (ctx->rc_overshoot_pct >= 0)
861  enccfg.rc_overshoot_pct = ctx->rc_overshoot_pct;
862 
863  //_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO
864  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
865  enccfg.kf_min_dist = avctx->keyint_min;
866  if (avctx->gop_size >= 0)
867  enccfg.kf_max_dist = avctx->gop_size;
868 
869  if (enccfg.g_pass == VPX_RC_FIRST_PASS)
870  enccfg.g_lag_in_frames = 0;
871  else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
872  int decode_size, ret;
873 
874  if (!avctx->stats_in) {
875  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
876  return AVERROR_INVALIDDATA;
877  }
878 
879  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
880  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
881  if (ret < 0) {
882  av_log(avctx, AV_LOG_ERROR,
883  "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
884  ctx->twopass_stats.sz);
885  ctx->twopass_stats.sz = 0;
886  return ret;
887  }
888  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
889  ctx->twopass_stats.sz);
890  if (decode_size < 0) {
891  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
892  return AVERROR_INVALIDDATA;
893  }
894 
895  ctx->twopass_stats.sz = decode_size;
896  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
897  }
898 
899  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
900  complexity playback on low powered devices at the expense of encode
901  quality. */
902  if (avctx->profile != FF_PROFILE_UNKNOWN)
903  enccfg.g_profile = avctx->profile;
904 
905  enccfg.g_error_resilient = ctx->error_resilient || ctx->flags & VP8F_ERROR_RESILIENT;
906 
907  while ((en = av_dict_get(ctx->vpx_ts_parameters, "", en, AV_DICT_IGNORE_SUFFIX))) {
908  if (vpx_ts_param_parse(ctx, &enccfg, en->key, en->value, avctx->codec_id) < 0)
909  av_log(avctx, AV_LOG_WARNING,
910  "Error parsing option '%s = %s'.\n",
911  en->key, en->value);
912  }
913 
914  dump_enc_cfg(avctx, &enccfg);
915  /* Construct Encoder Context */
916  res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
917  if (res != VPX_CODEC_OK) {
918  log_encoder_error(avctx, "Failed to initialize encoder");
919  return AVERROR(EINVAL);
920  }
921 #if CONFIG_LIBVPX_VP9_ENCODER
922  if (avctx->codec_id == AV_CODEC_ID_VP9 && enccfg.ts_number_layers > 1) {
923  memset(&svc_params, 0, sizeof(svc_params));
924  for (int i = 0; i < enccfg.ts_number_layers; ++i) {
925  svc_params.max_quantizers[i] = enccfg.rc_max_quantizer;
926  svc_params.min_quantizers[i] = enccfg.rc_min_quantizer;
927  }
928  svc_params.scaling_factor_num[0] = enccfg.g_h;
929  svc_params.scaling_factor_den[0] = enccfg.g_h;
930 #if VPX_ENCODER_ABI_VERSION >= 12
931  codecctl_int(avctx, VP9E_SET_SVC, 1);
932  codecctl_intp(avctx, VP9E_SET_SVC_PARAMETERS, (int *)&svc_params);
933 #endif
934  }
935 #endif
936  if (ctx->is_alpha) {
937  enccfg_alpha = enccfg;
938  res = vpx_codec_enc_init(&ctx->encoder_alpha, iface, &enccfg_alpha, flags);
939  if (res != VPX_CODEC_OK) {
940  log_encoder_error(avctx, "Failed to initialize alpha encoder");
941  return AVERROR(EINVAL);
942  }
943  }
944 
945  //codec control failures are currently treated only as warnings
946  av_log(avctx, AV_LOG_DEBUG, "vpx_codec_control\n");
947  codecctl_int(avctx, VP8E_SET_CPUUSED, ctx->cpu_used);
948  if (ctx->flags & VP8F_AUTO_ALT_REF)
949  ctx->auto_alt_ref = 1;
950  if (ctx->auto_alt_ref >= 0)
951  codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF,
952  avctx->codec_id == AV_CODEC_ID_VP8 ? !!ctx->auto_alt_ref : ctx->auto_alt_ref);
953  if (ctx->arnr_max_frames >= 0)
954  codecctl_int(avctx, VP8E_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
955  if (ctx->arnr_strength >= 0)
956  codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH, ctx->arnr_strength);
957  if (ctx->arnr_type >= 0)
958  codecctl_int(avctx, VP8E_SET_ARNR_TYPE, ctx->arnr_type);
959  if (ctx->tune >= 0)
960  codecctl_int(avctx, VP8E_SET_TUNING, ctx->tune);
961 
962  if (ctx->auto_alt_ref && ctx->is_alpha && avctx->codec_id == AV_CODEC_ID_VP8) {
963  av_log(avctx, AV_LOG_ERROR, "Transparency encoding with auto_alt_ref does not work\n");
964  return AVERROR(EINVAL);
965  }
966 
967  if (ctx->sharpness >= 0)
968  codecctl_int(avctx, VP8E_SET_SHARPNESS, ctx->sharpness);
969 
970  if (CONFIG_LIBVPX_VP8_ENCODER && avctx->codec_id == AV_CODEC_ID_VP8) {
971 #if FF_API_PRIVATE_OPT
973  if (avctx->noise_reduction)
974  ctx->noise_sensitivity = avctx->noise_reduction;
976 #endif
977  codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, ctx->noise_sensitivity);
978  codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS, av_log2(avctx->slices));
979  }
980  codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD, ctx->static_thresh);
981  if (ctx->crf >= 0)
982  codecctl_int(avctx, VP8E_SET_CQ_LEVEL, ctx->crf);
983  if (ctx->max_intra_rate >= 0)
984  codecctl_int(avctx, VP8E_SET_MAX_INTRA_BITRATE_PCT, ctx->max_intra_rate);
985 
986 #if CONFIG_LIBVPX_VP9_ENCODER
987  if (avctx->codec_id == AV_CODEC_ID_VP9) {
988  if (ctx->lossless >= 0)
989  codecctl_int(avctx, VP9E_SET_LOSSLESS, ctx->lossless);
990  if (ctx->tile_columns >= 0)
991  codecctl_int(avctx, VP9E_SET_TILE_COLUMNS, ctx->tile_columns);
992  if (ctx->tile_rows >= 0)
993  codecctl_int(avctx, VP9E_SET_TILE_ROWS, ctx->tile_rows);
994  if (ctx->frame_parallel >= 0)
995  codecctl_int(avctx, VP9E_SET_FRAME_PARALLEL_DECODING, ctx->frame_parallel);
996  if (ctx->aq_mode >= 0)
997  codecctl_int(avctx, VP9E_SET_AQ_MODE, ctx->aq_mode);
998  set_colorspace(avctx);
999 #if VPX_ENCODER_ABI_VERSION >= 11
1000  set_color_range(avctx);
1001 #endif
1002 #if VPX_ENCODER_ABI_VERSION >= 12
1003  codecctl_int(avctx, VP9E_SET_TARGET_LEVEL, ctx->level < 0 ? 255 : lrint(ctx->level * 10));
1004 #endif
1005 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
1006  if (ctx->row_mt >= 0)
1007  codecctl_int(avctx, VP9E_SET_ROW_MT, ctx->row_mt);
1008 #endif
1009 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
1010  if (ctx->tune_content >= 0)
1011  codecctl_int(avctx, VP9E_SET_TUNE_CONTENT, ctx->tune_content);
1012 #endif
1013 #ifdef VPX_CTRL_VP9E_SET_TPL
1014  if (ctx->tpl_model >= 0)
1015  codecctl_int(avctx, VP9E_SET_TPL, ctx->tpl_model);
1016 #endif
1017  }
1018 #endif
1019 
1020  av_log(avctx, AV_LOG_DEBUG, "Using deadline: %d\n", ctx->deadline);
1021 
1022  //provide dummy value to initialize wrapper, values will be updated each _encode()
1023  vpx_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
1024  (unsigned char*)1);
1025 #if CONFIG_LIBVPX_VP9_ENCODER
1026  if (avctx->codec_id == AV_CODEC_ID_VP9 && (codec_caps & VPX_CODEC_CAP_HIGHBITDEPTH))
1027  ctx->rawimg.bit_depth = enccfg.g_bit_depth;
1028 #endif
1029 
1030  cpb_props = ff_add_cpb_side_data(avctx);
1031  if (!cpb_props)
1032  return AVERROR(ENOMEM);
1033 
1034  if (enccfg.rc_end_usage == VPX_CBR ||
1035  enccfg.g_pass != VPX_RC_ONE_PASS) {
1036  cpb_props->max_bitrate = avctx->rc_max_rate;
1037  cpb_props->min_bitrate = avctx->rc_min_rate;
1038  cpb_props->avg_bitrate = avctx->bit_rate;
1039  }
1040  cpb_props->buffer_size = avctx->rc_buffer_size;
1041 
1042  return 0;
1043 }
1044 
1045 static inline void cx_pktcpy(struct FrameListData *dst,
1046  const struct vpx_codec_cx_pkt *src,
1047  const struct vpx_codec_cx_pkt *src_alpha,
1048  VPxContext *ctx)
1049 {
1050  dst->pts = src->data.frame.pts;
1051  dst->duration = src->data.frame.duration;
1052  dst->flags = src->data.frame.flags;
1053  dst->sz = src->data.frame.sz;
1054  dst->buf = src->data.frame.buf;
1055  dst->have_sse = 0;
1056  /* For alt-ref frame, don't store PSNR or increment frame_number */
1057  if (!(dst->flags & VPX_FRAME_IS_INVISIBLE)) {
1058  dst->frame_number = ++ctx->frame_number;
1059  dst->have_sse = ctx->have_sse;
1060  if (ctx->have_sse) {
1061  /* associate last-seen SSE to the frame. */
1062  /* Transfers ownership from ctx to dst. */
1063  /* WARNING! This makes the assumption that PSNR_PKT comes
1064  just before the frame it refers to! */
1065  memcpy(dst->sse, ctx->sse, sizeof(dst->sse));
1066  ctx->have_sse = 0;
1067  }
1068  } else {
1069  dst->frame_number = -1; /* sanity marker */
1070  }
1071  if (src_alpha) {
1072  dst->buf_alpha = src_alpha->data.frame.buf;
1073  dst->sz_alpha = src_alpha->data.frame.sz;
1074  } else {
1075  dst->buf_alpha = NULL;
1076  dst->sz_alpha = 0;
1077  }
1078 }
1079 
1080 /**
1081  * Store coded frame information in format suitable for return from encode2().
1082  *
1083  * Write information from @a cx_frame to @a pkt
1084  * @return packet data size on success
1085  * @return a negative AVERROR on error
1086  */
1087 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
1088  AVPacket *pkt)
1089 {
1090  int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
1091  uint8_t *side_data;
1092  if (ret >= 0) {
1093  int pict_type;
1094  memcpy(pkt->data, cx_frame->buf, pkt->size);
1095  pkt->pts = pkt->dts = cx_frame->pts;
1096 #if FF_API_CODED_FRAME
1098  avctx->coded_frame->pts = cx_frame->pts;
1099  avctx->coded_frame->key_frame = !!(cx_frame->flags & VPX_FRAME_IS_KEY);
1101 #endif
1102 
1103  if (!!(cx_frame->flags & VPX_FRAME_IS_KEY)) {
1104  pict_type = AV_PICTURE_TYPE_I;
1105 #if FF_API_CODED_FRAME
1107  avctx->coded_frame->pict_type = pict_type;
1109 #endif
1110  pkt->flags |= AV_PKT_FLAG_KEY;
1111  } else {
1112  pict_type = AV_PICTURE_TYPE_P;
1113 #if FF_API_CODED_FRAME
1115  avctx->coded_frame->pict_type = pict_type;
1117 #endif
1118  }
1119 
1120  ff_side_data_set_encoder_stats(pkt, 0, cx_frame->sse + 1,
1121  cx_frame->have_sse ? 3 : 0, pict_type);
1122 
1123  if (cx_frame->have_sse) {
1124  int i;
1125  /* Beware of the Y/U/V/all order! */
1126 #if FF_API_CODED_FRAME && FF_API_ERROR_FRAME
1128  avctx->coded_frame->error[0] = cx_frame->sse[1];
1129  avctx->coded_frame->error[1] = cx_frame->sse[2];
1130  avctx->coded_frame->error[2] = cx_frame->sse[3];
1131  avctx->coded_frame->error[3] = 0; // alpha
1133 #endif
1134  for (i = 0; i < 3; ++i) {
1135  avctx->error[i] += cx_frame->sse[i + 1];
1136  }
1137  cx_frame->have_sse = 0;
1138  }
1139  if (cx_frame->sz_alpha > 0) {
1140  side_data = av_packet_new_side_data(pkt,
1142  cx_frame->sz_alpha + 8);
1143  if(!side_data) {
1144  av_packet_unref(pkt);
1145  return AVERROR(ENOMEM);
1146  }
1147  AV_WB64(side_data, 1);
1148  memcpy(side_data + 8, cx_frame->buf_alpha, cx_frame->sz_alpha);
1149  }
1150  } else {
1151  return ret;
1152  }
1153  return pkt->size;
1154 }
1155 
1156 /**
1157  * Queue multiple output frames from the encoder, returning the front-most.
1158  * In cases where vpx_codec_get_cx_data() returns more than 1 frame append
1159  * the frame queue. Return the head frame if available.
1160  * @return Stored frame size
1161  * @return AVERROR(EINVAL) on output size error
1162  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
1163  */
1164 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
1165 {
1166  VPxContext *ctx = avctx->priv_data;
1167  const struct vpx_codec_cx_pkt *pkt;
1168  const struct vpx_codec_cx_pkt *pkt_alpha = NULL;
1169  const void *iter = NULL;
1170  const void *iter_alpha = NULL;
1171  int size = 0;
1172 
1173  if (ctx->coded_frame_list) {
1174  struct FrameListData *cx_frame = ctx->coded_frame_list;
1175  /* return the leading frame if we've already begun queueing */
1176  size = storeframe(avctx, cx_frame, pkt_out);
1177  if (size < 0)
1178  return size;
1179  ctx->coded_frame_list = cx_frame->next;
1180  free_coded_frame(cx_frame);
1181  }
1182 
1183  /* consume all available output from the encoder before returning. buffers
1184  are only good through the next vpx_codec call */
1185  while ((pkt = vpx_codec_get_cx_data(&ctx->encoder, &iter)) &&
1186  (!ctx->is_alpha ||
1187  (pkt_alpha = vpx_codec_get_cx_data(&ctx->encoder_alpha, &iter_alpha)))) {
1188  switch (pkt->kind) {
1189  case VPX_CODEC_CX_FRAME_PKT:
1190  if (!size) {
1191  struct FrameListData cx_frame;
1192 
1193  /* avoid storing the frame when the list is empty and we haven't yet
1194  provided a frame for output */
1196  cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);
1197  size = storeframe(avctx, &cx_frame, pkt_out);
1198  if (size < 0)
1199  return size;
1200  } else {
1201  struct FrameListData *cx_frame = av_malloc(sizeof(*cx_frame));
1202 
1203  if (!cx_frame) {
1204  av_log(avctx, AV_LOG_ERROR,
1205  "Frame queue element alloc failed\n");
1206  return AVERROR(ENOMEM);
1207  }
1208  cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);
1209  cx_frame->buf = av_malloc(cx_frame->sz);
1210 
1211  if (!cx_frame->buf) {
1212  av_log(avctx, AV_LOG_ERROR,
1213  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1214  cx_frame->sz);
1215  av_freep(&cx_frame);
1216  return AVERROR(ENOMEM);
1217  }
1218  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
1219  if (ctx->is_alpha) {
1220  cx_frame->buf_alpha = av_malloc(cx_frame->sz_alpha);
1221  if (!cx_frame->buf_alpha) {
1222  av_log(avctx, AV_LOG_ERROR,
1223  "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
1224  cx_frame->sz_alpha);
1225  av_free(cx_frame);
1226  return AVERROR(ENOMEM);
1227  }
1228  memcpy(cx_frame->buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
1229  }
1230  coded_frame_add(&ctx->coded_frame_list, cx_frame);
1231  }
1232  break;
1233  case VPX_CODEC_STATS_PKT: {
1234  struct vpx_fixed_buf *stats = &ctx->twopass_stats;
1235  int err;
1236  if ((err = av_reallocp(&stats->buf,
1237  stats->sz +
1238  pkt->data.twopass_stats.sz)) < 0) {
1239  stats->sz = 0;
1240  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
1241  return err;
1242  }
1243  memcpy((uint8_t*)stats->buf + stats->sz,
1244  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1245  stats->sz += pkt->data.twopass_stats.sz;
1246  break;
1247  }
1248  case VPX_CODEC_PSNR_PKT:
1249  av_assert0(!ctx->have_sse);
1250  ctx->sse[0] = pkt->data.psnr.sse[0];
1251  ctx->sse[1] = pkt->data.psnr.sse[1];
1252  ctx->sse[2] = pkt->data.psnr.sse[2];
1253  ctx->sse[3] = pkt->data.psnr.sse[3];
1254  ctx->have_sse = 1;
1255  break;
1256  case VPX_CODEC_CUSTOM_PKT:
1257  //ignore unsupported/unrecognized packet types
1258  break;
1259  }
1260  }
1261 
1262  return size;
1263 }
1264 
1265 static int set_roi_map(AVCodecContext *avctx, const AVFrameSideData *sd, int frame_width, int frame_height,
1266  vpx_roi_map_t *roi_map, int block_size, int segment_cnt)
1267 {
1268  /**
1269  * range of vpx_roi_map_t.delta_q[i] is [-63, 63]
1270  */
1271 #define MAX_DELTA_Q 63
1272 
1273  const AVRegionOfInterest *roi = NULL;
1274  int nb_rois;
1275  uint32_t self_size;
1276  int segment_id;
1277 
1278  /* record the mapping from delta_q to "segment id + 1" in segment_mapping[].
1279  * the range of delta_q is [-MAX_DELTA_Q, MAX_DELTA_Q],
1280  * and its corresponding array index is [0, 2 * MAX_DELTA_Q],
1281  * and so the length of the mapping array is 2 * MAX_DELTA_Q + 1.
1282  * "segment id + 1", so we can say there's no mapping if the value of array element is zero.
1283  */
1284  int segment_mapping[2 * MAX_DELTA_Q + 1] = { 0 };
1285 
1286  memset(roi_map, 0, sizeof(*roi_map));
1287 
1288  /* segment id 0 in roi_map is reserved for the areas not covered by AVRegionOfInterest.
1289  * segment id 0 in roi_map is also for the areas with AVRegionOfInterest.qoffset near 0.
1290  * (delta_q of segment id 0 is 0).
1291  */
1292  segment_mapping[MAX_DELTA_Q] = 1;
1293  segment_id = 1;
1294 
1295  roi = (const AVRegionOfInterest*)sd->data;
1296  self_size = roi->self_size;
1297  if (!self_size || sd->size % self_size) {
1298  av_log(avctx, AV_LOG_ERROR, "Invalid AVRegionOfInterest.self_size.\n");
1299  return AVERROR(EINVAL);
1300  }
1301  nb_rois = sd->size / self_size;
1302 
1303  /* This list must be iterated from zero because regions are
1304  * defined in order of decreasing importance. So discard less
1305  * important areas if they exceed the segment count.
1306  */
1307  for (int i = 0; i < nb_rois; i++) {
1308  int delta_q;
1309  int mapping_index;
1310 
1311  roi = (const AVRegionOfInterest*)(sd->data + self_size * i);
1312  if (!roi->qoffset.den) {
1313  av_log(avctx, AV_LOG_ERROR, "AVRegionOfInterest.qoffset.den must not be zero.\n");
1314  return AVERROR(EINVAL);
1315  }
1316 
1317  delta_q = (int)(roi->qoffset.num * 1.0f / roi->qoffset.den * MAX_DELTA_Q);
1318  delta_q = av_clip(delta_q, -MAX_DELTA_Q, MAX_DELTA_Q);
1319 
1320  mapping_index = delta_q + MAX_DELTA_Q;
1321  if (!segment_mapping[mapping_index]) {
1322  if (segment_id == segment_cnt) {
1323  av_log(avctx, AV_LOG_WARNING,
1324  "ROI only supports %d segments (and segment 0 is reserved for non-ROIs), skipping the left ones.\n",
1325  segment_cnt);
1326  break;
1327  }
1328 
1329  segment_mapping[mapping_index] = segment_id + 1;
1330  roi_map->delta_q[segment_id] = delta_q;
1331  segment_id++;
1332  }
1333  }
1334 
1335  roi_map->rows = (frame_height + block_size - 1) / block_size;
1336  roi_map->cols = (frame_width + block_size - 1) / block_size;
1337  roi_map->roi_map = av_mallocz_array(roi_map->rows * roi_map->cols, sizeof(*roi_map->roi_map));
1338  if (!roi_map->roi_map) {
1339  av_log(avctx, AV_LOG_ERROR, "roi_map alloc failed.\n");
1340  return AVERROR(ENOMEM);
1341  }
1342 
1343  /* This list must be iterated in reverse, so for the case that
1344  * two regions are overlapping, the more important area takes effect.
1345  */
1346  for (int i = nb_rois - 1; i >= 0; i--) {
1347  int delta_q;
1348  int mapping_value;
1349  int starty, endy, startx, endx;
1350 
1351  roi = (const AVRegionOfInterest*)(sd->data + self_size * i);
1352 
1353  starty = av_clip(roi->top / block_size, 0, roi_map->rows);
1354  endy = av_clip((roi->bottom + block_size - 1) / block_size, 0, roi_map->rows);
1355  startx = av_clip(roi->left / block_size, 0, roi_map->cols);
1356  endx = av_clip((roi->right + block_size - 1) / block_size, 0, roi_map->cols);
1357 
1358  delta_q = (int)(roi->qoffset.num * 1.0f / roi->qoffset.den * MAX_DELTA_Q);
1359  delta_q = av_clip(delta_q, -MAX_DELTA_Q, MAX_DELTA_Q);
1360 
1361  mapping_value = segment_mapping[delta_q + MAX_DELTA_Q];
1362  if (mapping_value) {
1363  for (int y = starty; y < endy; y++)
1364  for (int x = startx; x < endx; x++)
1365  roi_map->roi_map[x + y * roi_map->cols] = mapping_value - 1;
1366  }
1367  }
1368 
1369  return 0;
1370 }
1371 
1372 static int vp9_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
1373 {
1374  VPxContext *ctx = avctx->priv_data;
1375 
1376 #ifdef VPX_CTRL_VP9E_SET_ROI_MAP
1377  int version = vpx_codec_version();
1378  int major = VPX_VERSION_MAJOR(version);
1379  int minor = VPX_VERSION_MINOR(version);
1380  int patch = VPX_VERSION_PATCH(version);
1381 
1382  if (major > 1 || (major == 1 && minor > 8) || (major == 1 && minor == 8 && patch >= 1)) {
1383  vpx_roi_map_t roi_map;
1384  const int segment_cnt = 8;
1385  const int block_size = 8;
1386  int ret;
1387 
1388  if (ctx->aq_mode > 0 || ctx->cpu_used < 5 || ctx->deadline != VPX_DL_REALTIME) {
1389  if (!ctx->roi_warned) {
1390  ctx->roi_warned = 1;
1391  av_log(avctx, AV_LOG_WARNING, "ROI is only enabled when aq_mode is 0, cpu_used >= 5 "
1392  "and deadline is REALTIME, so skipping ROI.\n");
1393  return AVERROR(EINVAL);
1394  }
1395  }
1396 
1397  ret = set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1398  if (ret) {
1399  log_encoder_error(avctx, "Failed to set_roi_map.\n");
1400  return ret;
1401  }
1402 
1403  memset(roi_map.ref_frame, -1, sizeof(roi_map.ref_frame));
1404 
1405  if (vpx_codec_control(&ctx->encoder, VP9E_SET_ROI_MAP, &roi_map)) {
1406  log_encoder_error(avctx, "Failed to set VP9E_SET_ROI_MAP codec control.\n");
1407  ret = AVERROR_INVALIDDATA;
1408  }
1409  av_freep(&roi_map.roi_map);
1410  return ret;
1411  }
1412 #endif
1413 
1414  if (!ctx->roi_warned) {
1415  ctx->roi_warned = 1;
1416  av_log(avctx, AV_LOG_WARNING, "ROI is not supported, please upgrade libvpx to version >= 1.8.1. "
1417  "You may need to rebuild ffmpeg.\n");
1418  }
1419  return 0;
1420 }
1421 
1422 static int vp8_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
1423 {
1424  vpx_roi_map_t roi_map;
1425  const int segment_cnt = 4;
1426  const int block_size = 16;
1427  VPxContext *ctx = avctx->priv_data;
1428 
1429  int ret = set_roi_map(avctx, sd, frame_width, frame_height, &roi_map, block_size, segment_cnt);
1430  if (ret) {
1431  log_encoder_error(avctx, "Failed to set_roi_map.\n");
1432  return ret;
1433  }
1434 
1435  if (vpx_codec_control(&ctx->encoder, VP8E_SET_ROI_MAP, &roi_map)) {
1436  log_encoder_error(avctx, "Failed to set VP8E_SET_ROI_MAP codec control.\n");
1437  ret = AVERROR_INVALIDDATA;
1438  }
1439 
1440  av_freep(&roi_map.roi_map);
1441  return ret;
1442 }
1443 
1444 static int realloc_alpha_uv(AVCodecContext *avctx, int width, int height)
1445 {
1446  VPxContext *ctx = avctx->priv_data;
1447  struct vpx_image *rawimg_alpha = &ctx->rawimg_alpha;
1448  unsigned char **planes = rawimg_alpha->planes;
1449  int *stride = rawimg_alpha->stride;
1450 
1451  if (!planes[VPX_PLANE_U] ||
1452  !planes[VPX_PLANE_V] ||
1453  width != (int)rawimg_alpha->d_w ||
1454  height != (int)rawimg_alpha->d_h) {
1455  av_freep(&planes[VPX_PLANE_U]);
1456  av_freep(&planes[VPX_PLANE_V]);
1457 
1458  vpx_img_wrap(rawimg_alpha, VPX_IMG_FMT_I420, width, height, 1,
1459  (unsigned char*)1);
1460  planes[VPX_PLANE_U] = av_malloc_array(stride[VPX_PLANE_U], height);
1461  planes[VPX_PLANE_V] = av_malloc_array(stride[VPX_PLANE_V], height);
1462  if (!planes[VPX_PLANE_U] || !planes[VPX_PLANE_V])
1463  return AVERROR(ENOMEM);
1464 
1465  memset(planes[VPX_PLANE_U], 0x80, stride[VPX_PLANE_U] * height);
1466  memset(planes[VPX_PLANE_V], 0x80, stride[VPX_PLANE_V] * height);
1467  }
1468 
1469  return 0;
1470 }
1471 
1473  const AVFrame *frame, int *got_packet)
1474 {
1475  VPxContext *ctx = avctx->priv_data;
1476  struct vpx_image *rawimg = NULL;
1477  struct vpx_image *rawimg_alpha = NULL;
1478  int64_t timestamp = 0;
1479  int res, coded_size;
1480  vpx_enc_frame_flags_t flags = 0;
1481  const struct vpx_codec_enc_cfg *enccfg = ctx->encoder.config.enc;
1482  vpx_svc_layer_id_t layer_id;
1483  int layer_id_valid = 0;
1484 
1485  if (frame) {
1487  rawimg = &ctx->rawimg;
1488  rawimg->planes[VPX_PLANE_Y] = frame->data[0];
1489  rawimg->planes[VPX_PLANE_U] = frame->data[1];
1490  rawimg->planes[VPX_PLANE_V] = frame->data[2];
1491  rawimg->stride[VPX_PLANE_Y] = frame->linesize[0];
1492  rawimg->stride[VPX_PLANE_U] = frame->linesize[1];
1493  rawimg->stride[VPX_PLANE_V] = frame->linesize[2];
1494  if (ctx->is_alpha) {
1495  rawimg_alpha = &ctx->rawimg_alpha;
1496  res = realloc_alpha_uv(avctx, frame->width, frame->height);
1497  if (res < 0)
1498  return res;
1499  rawimg_alpha->planes[VPX_PLANE_Y] = frame->data[3];
1500  rawimg_alpha->stride[VPX_PLANE_Y] = frame->linesize[3];
1501  }
1502  timestamp = frame->pts;
1503 #if VPX_IMAGE_ABI_VERSION >= 4
1504  switch (frame->color_range) {
1505  case AVCOL_RANGE_MPEG:
1506  rawimg->range = VPX_CR_STUDIO_RANGE;
1507  break;
1508  case AVCOL_RANGE_JPEG:
1509  rawimg->range = VPX_CR_FULL_RANGE;
1510  break;
1511  }
1512 #endif
1513  if (frame->pict_type == AV_PICTURE_TYPE_I)
1514  flags |= VPX_EFLAG_FORCE_KF;
1515  if (frame->metadata) {
1516  AVDictionaryEntry* en = av_dict_get(frame->metadata, "vp8-flags", NULL, 0);
1517  if (en) {
1518  flags |= strtoul(en->value, NULL, 10);
1519  }
1520 
1521  memset(&layer_id, 0, sizeof(layer_id));
1522 
1523  en = av_dict_get(frame->metadata, "temporal_id", NULL, 0);
1524  if (en) {
1525  layer_id.temporal_layer_id = strtoul(en->value, NULL, 10);
1526 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT
1527  layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1528 #endif
1529  layer_id_valid = 1;
1530  }
1531  }
1532 
1533  if (sd) {
1534  if (avctx->codec_id == AV_CODEC_ID_VP8) {
1535  vp8_encode_set_roi(avctx, frame->width, frame->height, sd);
1536  } else {
1537  vp9_encode_set_roi(avctx, frame->width, frame->height, sd);
1538  }
1539  }
1540  }
1541 
1542  // this is for encoding with preset temporal layering patterns defined in
1543  // set_temporal_layer_pattern function.
1544  if (enccfg->ts_number_layers > 1 && ctx->ts_layer_flags) {
1545  if (flags & VPX_EFLAG_FORCE_KF) {
1546  // keyframe, reset temporal layering.
1547  ctx->current_temporal_idx = 0;
1548  flags = VPX_EFLAG_FORCE_KF;
1549  } else {
1550  flags = 0;
1551  }
1552 
1553  /* get the flags from the temporal layer configuration. */
1554  flags |= ctx->ts_layer_flags[ctx->current_temporal_idx];
1555 
1556  memset(&layer_id, 0, sizeof(layer_id));
1557 #if VPX_ENCODER_ABI_VERSION >= 12
1558  layer_id.spatial_layer_id = 0;
1559 #endif
1560  layer_id.temporal_layer_id = enccfg->ts_layer_id[ctx->current_temporal_idx];
1561 #ifdef VPX_CTRL_VP9E_SET_MAX_INTER_BITRATE_PCT
1562  layer_id.temporal_layer_id_per_spatial[0] = layer_id.temporal_layer_id;
1563 #endif
1564  layer_id_valid = 1;
1565  }
1566 
1567  if (layer_id_valid) {
1568  if (avctx->codec_id == AV_CODEC_ID_VP8) {
1569  codecctl_int(avctx, VP8E_SET_TEMPORAL_LAYER_ID, layer_id.temporal_layer_id);
1570  }
1571 #if CONFIG_LIBVPX_VP9_ENCODER && VPX_ENCODER_ABI_VERSION >= 12
1572  else if (avctx->codec_id == AV_CODEC_ID_VP9) {
1573  codecctl_intp(avctx, VP9E_SET_SVC_LAYER_ID, (int *)&layer_id);
1574  }
1575 #endif
1576  }
1577 
1578  res = vpx_codec_encode(&ctx->encoder, rawimg, timestamp,
1579  avctx->ticks_per_frame, flags, ctx->deadline);
1580  if (res != VPX_CODEC_OK) {
1581  log_encoder_error(avctx, "Error encoding frame");
1582  return AVERROR_INVALIDDATA;
1583  }
1584 
1585  if (ctx->is_alpha) {
1586  res = vpx_codec_encode(&ctx->encoder_alpha, rawimg_alpha, timestamp,
1587  avctx->ticks_per_frame, flags, ctx->deadline);
1588  if (res != VPX_CODEC_OK) {
1589  log_encoder_error(avctx, "Error encoding alpha frame");
1590  return AVERROR_INVALIDDATA;
1591  }
1592  }
1593 
1594  coded_size = queue_frames(avctx, pkt);
1595 
1596  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
1597  unsigned int b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
1598 
1599  avctx->stats_out = av_malloc(b64_size);
1600  if (!avctx->stats_out) {
1601  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%d bytes) failed\n",
1602  b64_size);
1603  return AVERROR(ENOMEM);
1604  }
1605  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
1606  ctx->twopass_stats.sz);
1607  } else if (enccfg->ts_number_layers > 1 && ctx->ts_layer_flags) {
1608  ctx->current_temporal_idx = (ctx->current_temporal_idx + 1) % enccfg->ts_periodicity;
1609  }
1610 
1611  *got_packet = !!coded_size;
1612  return 0;
1613 }
1614 
1615 #define OFFSET(x) offsetof(VPxContext, x)
1616 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1617 
1618 #define COMMON_OPTIONS \
1619  { "lag-in-frames", "Number of frames to look ahead for " \
1620  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1621  { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1622  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1623  { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"}, \
1624  { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" }, \
1625  { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" }, \
1626  { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" }, \
1627  { "tune", "Tune the encoding to a specific scenario", OFFSET(tune), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "tune"}, \
1628  { "psnr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_PSNR}, 0, 0, VE, "tune"}, \
1629  { "ssim", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VP8_TUNE_SSIM}, 0, 0, VE, "tune"}, \
1630  { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
1631  { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"}, \
1632  { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"}, \
1633  { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"}, \
1634  { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"}, \
1635  { "max-intra-rate", "Maximum I-frame bitrate (pct) 0=unlimited", OFFSET(max_intra_rate), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE}, \
1636  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"}, \
1637  { "partitions", "The frame partitions are independently decodable " \
1638  "by the bool decoder, meaning that partitions can be decoded even " \
1639  "though earlier partitions have been lost. Note that intra prediction" \
1640  " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"}, \
1641  { "crf", "Select the quality for constant quality mode", offsetof(VPxContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE }, \
1642  { "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 }, \
1643  { "drop-threshold", "Frame drop threshold", offsetof(VPxContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE }, \
1644  { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE}, \
1645  { "undershoot-pct", "Datarate undershoot (min) target (%)", OFFSET(rc_undershoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 100, VE }, \
1646  { "overshoot-pct", "Datarate overshoot (max) target (%)", OFFSET(rc_overshoot_pct), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1000, VE }, \
1647  { "ts-parameters", "Temporal scaling configuration using a :-separated list of key=value parameters", OFFSET(vpx_ts_parameters), AV_OPT_TYPE_DICT, {.str=NULL}, 0, 0, VE}, \
1648 
1649 #define LEGACY_OPTIONS \
1650  {"speed", "", offsetof(VPxContext, cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE}, \
1651  {"quality", "", offsetof(VPxContext, deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"}, \
1652  {"vp8flags", "", offsetof(VPxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX, VE, "flags"}, \
1653  {"error_resilient", "enable error resilience", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"}, \
1654  {"altref", "enable use of alternate reference frames (VP8/2-pass only)", 0, AV_OPT_TYPE_CONST, {.i64 = VP8F_AUTO_ALT_REF}, INT_MIN, INT_MAX, VE, "flags"}, \
1655  {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VPxContext, arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15, VE}, \
1656  {"arnr_strength", "altref noise reduction filter strength", offsetof(VPxContext, arnr_strength), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6, VE}, \
1657  {"arnr_type", "altref noise reduction filter type", offsetof(VPxContext, arnr_type), AV_OPT_TYPE_INT, {.i64 = 3}, 1, 3, VE}, \
1658  {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VPxContext, lag_in_frames), AV_OPT_TYPE_INT, {.i64 = 25}, 0, 25, VE}, \
1659  {"sharpness", "Increase sharpness at the expense of lower PSNR", offsetof(VPxContext, sharpness), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, VE},
1660 
1661 #if CONFIG_LIBVPX_VP8_ENCODER
1662 static const AVOption vp8_options[] = {
1664  { "auto-alt-ref", "Enable use of alternate reference "
1665  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1666  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -16, 16, VE},
1668  { NULL }
1669 };
1670 #endif
1671 
1672 #if CONFIG_LIBVPX_VP9_ENCODER
1673 static const AVOption vp9_options[] = {
1675  { "auto-alt-ref", "Enable use of alternate reference "
1676  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1677  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, -8, 8, VE},
1678  { "lossless", "Lossless mode", OFFSET(lossless), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},
1679  { "tile-columns", "Number of tile columns to use, log2", OFFSET(tile_columns), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
1680  { "tile-rows", "Number of tile rows to use, log2", OFFSET(tile_rows), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
1681  { "frame-parallel", "Enable frame parallel decodability features", OFFSET(frame_parallel), AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1, VE},
1682 #if VPX_ENCODER_ABI_VERSION >= 12
1683  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
1684 #else
1685  { "aq-mode", "adaptive quantization mode", OFFSET(aq_mode), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3, VE, "aq_mode"},
1686 #endif
1687  { "none", "Aq not used", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode" },
1688  { "variance", "Variance based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode" },
1689  { "complexity", "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode" },
1690  { "cyclic", "Cyclic Refresh Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode" },
1691 #if VPX_ENCODER_ABI_VERSION >= 12
1692  { "equator360", "360 video Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 4}, 0, 0, VE, "aq_mode" },
1693  {"level", "Specify level", OFFSET(level), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 6.2, VE},
1694 #endif
1695 #ifdef VPX_CTRL_VP9E_SET_ROW_MT
1696  {"row-mt", "Row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
1697 #endif
1698 #ifdef VPX_CTRL_VP9E_SET_TUNE_CONTENT
1699 #if VPX_ENCODER_ABI_VERSION >= 14
1700  { "tune-content", "Tune content type", OFFSET(tune_content), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE, "tune_content" },
1701 #else
1702  { "tune-content", "Tune content type", OFFSET(tune_content), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE, "tune_content" },
1703 #endif
1704  { "default", "Regular video content", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "tune_content" },
1705  { "screen", "Screen capture content", 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "tune_content" },
1706 #if VPX_ENCODER_ABI_VERSION >= 14
1707  { "film", "Film content; improves grain retention", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "tune_content" },
1708 #endif
1709 #endif
1710 #if VPX_ENCODER_ABI_VERSION >= 14
1711  { "corpus-complexity", "corpus vbr complexity midpoint", OFFSET(corpus_complexity), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 10000, VE },
1712 #endif
1713 #ifdef VPX_CTRL_VP9E_SET_TPL
1714  { "enable-tpl", "Enable temporal dependency model", OFFSET(tpl_model), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE },
1715 #endif
1717  { NULL }
1718 };
1719 #endif
1720 
1721 #undef COMMON_OPTIONS
1722 #undef LEGACY_OPTIONS
1723 
1724 static const AVCodecDefault defaults[] = {
1725  { "b", "0" },
1726  { "qmin", "-1" },
1727  { "qmax", "-1" },
1728  { "g", "-1" },
1729  { "keyint_min", "-1" },
1730  { NULL },
1731 };
1732 
1733 #if CONFIG_LIBVPX_VP8_ENCODER
1734 static av_cold int vp8_init(AVCodecContext *avctx)
1735 {
1736  return vpx_init(avctx, vpx_codec_vp8_cx());
1737 }
1738 
1739 static const AVClass class_vp8 = {
1740  .class_name = "libvpx-vp8 encoder",
1741  .item_name = av_default_item_name,
1742  .option = vp8_options,
1743  .version = LIBAVUTIL_VERSION_INT,
1744 };
1745 
1747  .name = "libvpx",
1748  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
1749  .type = AVMEDIA_TYPE_VIDEO,
1750  .id = AV_CODEC_ID_VP8,
1751  .priv_data_size = sizeof(VPxContext),
1752  .init = vp8_init,
1753  .encode2 = vpx_encode,
1754  .close = vpx_free,
1757  .priv_class = &class_vp8,
1758  .defaults = defaults,
1759  .wrapper_name = "libvpx",
1760 };
1761 #endif /* CONFIG_LIBVPX_VP8_ENCODER */
1762 
1763 #if CONFIG_LIBVPX_VP9_ENCODER
1764 static av_cold int vp9_init(AVCodecContext *avctx)
1765 {
1766  return vpx_init(avctx, vpx_codec_vp9_cx());
1767 }
1768 
1769 static const AVClass class_vp9 = {
1770  .class_name = "libvpx-vp9 encoder",
1771  .item_name = av_default_item_name,
1772  .option = vp9_options,
1773  .version = LIBAVUTIL_VERSION_INT,
1774 };
1775 
1777  .name = "libvpx-vp9",
1778  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"),
1779  .type = AVMEDIA_TYPE_VIDEO,
1780  .id = AV_CODEC_ID_VP9,
1781  .priv_data_size = sizeof(VPxContext),
1782  .init = vp9_init,
1783  .encode2 = vpx_encode,
1784  .close = vpx_free,
1787  .priv_class = &class_vp9,
1788  .defaults = defaults,
1789  .init_static_data = ff_vp9_init_static,
1790  .wrapper_name = "libvpx",
1791 };
1792 #endif /* CONFIG_LIBVPX_VP9_ENCODER */
uint8_t is_alpha
Definition: libvpxenc.c:72
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:514
struct vpx_image rawimg
Definition: libvpxenc.c:69
int arnr_max_frames
Definition: libvpxenc.c:91
#define NULL
Definition: coverity.c:32
static void set_vpx_defaults(AVCodecContext *avctx, struct vpx_codec_enc_cfg *enccfg)
Called when the bitrate is not set.
Definition: libvpxenc.c:710
int row_mt
Definition: libvpxenc.c:119
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:254
version
Definition: libkvazaar.c:317
#define AV_PIX_FMT_YUV440P10
Definition: pixfmt.h:401
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
static av_cold int vpx_free(AVCodecContext *avctx)
Definition: libvpxenc.c:358
AVOption.
Definition: opt.h:248
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:796
int av_cpu_count(void)
Definition: cpu.c:275
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:1714
#define MAX_DELTA_Q
#define OFFSET(x)
Definition: libvpxenc.c:1615
const char * desc
Definition: libsvtav1.c:79
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:581
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int rc_overshoot_pct
Definition: libvpxenc.c:103
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
struct FrameListData * coded_frame_list
Definition: libvpxenc.c:78
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:459
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:518
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1437
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1166
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
void * buf
compressed data buffer
Definition: libaomenc.c:48
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_log2(unsigned v)
Definition: intmath.c:26
int aq_mode
Definition: libvpxenc.c:114
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:519
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
size_t sz
length of compressed data
Definition: libaomenc.c:49
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1558
static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VPxContext *ctx)
Definition: libvpxenc.c:1045
const char * key
int frame_parallel
Definition: libvpxenc.c:113
int static_thresh
Definition: libvpxenc.c:100
static AVPacket pkt
static void error(const char *err)
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: codec.h:118
int profile
profile
Definition: avcodec.h:1864
AVCodec.
Definition: codec.h:190
struct vpx_fixed_buf twopass_stats
Definition: libvpxenc.c:73
int error_resilient
Definition: libvpxenc.c:98
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:513
int tile_rows
Definition: libvpxenc.c:112
uint64_t frame_number
Definition: libvpxenc.c:77
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:468
functionally identical to above
Definition: pixfmt.h:520
AVRational qoffset
Quantisation offset.
Definition: frame.h:281
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:654
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:738
#define VP8F_AUTO_ALT_REF
Enable automatic alternate reference frame generation.
Definition: libvpxenc.c:87
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:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
#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:75
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
struct FrameListData * next
Definition: libaomenc.c:58
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
Definition: libvpxenc.c:314
#define av_malloc(s)
int64_t pts
time stamp to show frame (in timebase units)
Definition: libaomenc.c:50
AVOptions.
AVCodec ff_libvpx_vp8_encoder
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libvpxenc.c:285
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:407
Structure to hold side data for an AVFrame.
Definition: frame.h:220
int auto_alt_ref
Definition: libvpxenc.c:89
#define height
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
uint8_t * data
Definition: packet.h:363
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
AVDictionary * metadata
metadata.
Definition: frame.h:600
int vpx_cs
Definition: libvpxenc.c:117
uint64_t sse[4]
Definition: libvpxenc.c:75
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:486
ptrdiff_t size
Definition: opengl_enc.c:100
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:244
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1550
attribute_deprecated uint64_t error[AV_NUM_DATA_POINTERS]
Definition: frame.h:449
attribute_deprecated int frame_skip_threshold
Definition: avcodec.h:1460
#define av_log(a,...)
int noise_sensitivity
Definition: libvpxenc.c:116
#define LEGACY_OPTIONS
Definition: libvpxenc.c:1649
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define src
Definition: vp8dsp.c:254
static int vpx_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libvpxenc.c:1472
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
int width
Definition: frame.h:372
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int arnr_type
Definition: libvpxenc.c:93
int tune
Definition: libvpxenc.c:95
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
Definition: libvpxenc.c:1087
#define COMMON_OPTIONS
Definition: libvpxenc.c:1618
int qmax
maximum quantizer
Definition: avcodec.h:1380
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:558
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int roi_warned
If the driver does not support ROI then warn the first time we encounter a frame with ROI side data...
Definition: libvpxenc.c:127
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
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:138
static void set_color_range(AVCodecContext *avctx)
Definition: libaomenc.c:392
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1394
static int vp8_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
Definition: libvpxenc.c:1422
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1416
common internal API header
float level
Definition: libvpxenc.c:118
int lossless
Definition: libvpxenc.c:110
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
Definition: libvpxenc.c:187
int tpl_model
Definition: libvpxenc.c:122
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
struct vpx_image rawimg_alpha
Definition: libvpxenc.c:71
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
#define FFMIN(a, b)
Definition: common.h:96
uint64_t sse[4]
Definition: libaomenc.c:55
#define width
int width
picture width / height.
Definition: avcodec.h:704
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1865
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:523
attribute_deprecated int noise_reduction
Definition: avcodec.h:1049
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:312
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
static void vp8_ts_parse_int_array(int *dest, char *value, size_t value_len, int max_entries)
Definition: libvpxenc.c:385
static void stats(AVPacket *const *in, int n_in, unsigned *_max, unsigned *_sum)
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
int deadline
Definition: libvpxenc.c:74
static int vp9_encode_set_roi(AVCodecContext *avctx, int frame_width, int frame_height, const AVFrameSideData *sd)
Definition: libvpxenc.c:1372
Structure describing a single Region Of Interest.
Definition: frame.h:239
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:663
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libvpxenc.c:176
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
int tile_rows
Definition: h265_levels.c:217
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1790
Full range content.
Definition: pixfmt.h:586
AVCodec ff_libvpx_vp9_encoder
if(ret)
#define VP8F_ERROR_RESILIENT
Enable measures appropriate for streaming over lossy links.
Definition: libvpxenc.c:86
int cpu_used
Definition: libvpxenc.c:80
static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)
Definition: libvpxenc.c:723
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:453
static const AVCodecDefault defaults[]
Definition: libvpxenc.c:1724
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
int max_intra_rate
Definition: libvpxenc.c:101
#define delta_q(name)
Definition: cbs_av1.c:698
#define VE
Definition: libvpxenc.c:1616
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:161
int tune_content
Definition: libvpxenc.c:120
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:541
av_cold void ff_vp9_init_static(AVCodec *codec)
Definition: libvpx.c:68
int lag_in_frames
Definition: libvpxenc.c:97
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)
Definition: rtpdec_vp9.c:34
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
main external API structure.
Definition: avcodec.h:531
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
Definition: libvpxenc.c:1164
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
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
AVDictionary * vpx_ts_parameters
Definition: libvpxenc.c:105
static void set_vp8_defaults(AVCodecContext *avctx, struct vpx_codec_enc_cfg *enccfg)
Set the target bitrate to VPX library default.
Definition: libvpxenc.c:666
int qmin
minimum quantizer
Definition: avcodec.h:1373
static void set_temporal_layer_pattern(int layering_mode, vpx_codec_enc_cfg_t *cfg, int *layer_flags, int *flag_periodicity)
Definition: libvpxenc.c:397
int current_temporal_idx
Definition: libvpxenc.c:107
static const struct @324 planes[]
uint8_t * data
Definition: frame.h:222
int * ts_layer_flags
Definition: libvpxenc.c:106
Data found in BlockAdditional element of matroska container.
Definition: packet.h:191
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
Describe the class of an AVClass context structure.
Definition: log.h:67
static int vpx_ts_param_parse(VPxContext *ctx, struct vpx_codec_enc_cfg *enccfg, char *key, char *value, enum AVCodecID codec_id)
Definition: libvpxenc.c:501
static const AVProfile profiles[]
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1159
static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
Definition: libaomdec.c:86
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:181
uint32_t flags
flags for this frame
Definition: libaomenc.c:54
#define AV_PIX_FMT_YUV440P12
Definition: pixfmt.h:405
#define snprintf
Definition: snprintf.h:34
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libvpxenc.c:295
uint64_t frame_number
Definition: libaomenc.c:57
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:1365
int sharpness
Definition: libvpxenc.c:81
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
size_t sz_alpha
Definition: libvpxenc.c:54
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
int have_sse
true if we have pending sse[]
Definition: libaomenc.c:56
#define SIZE_SPECIFIER
Definition: internal.h:229
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
uint8_t level
Definition: svq3.c:205
static int set_roi_map(AVCodecContext *avctx, const AVFrameSideData *sd, int frame_width, int frame_height, vpx_roi_map_t *roi_map, int block_size, int segment_cnt)
Definition: libvpxenc.c:1265
Narrow or limited range content.
Definition: pixfmt.h:569
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
Definition: avstring.c:186
int flags
VP8 specific flags, see VP8F_* below.
Definition: libvpxenc.c:85
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:726
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
Definition: libvpxenc.c:131
struct vpx_codec_ctx encoder_alpha
Definition: libvpxenc.c:70
static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)
Definition: rtpdec_vp8.c:263
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
common internal and external API header
struct vpx_codec_ctx encoder
Definition: libvpxenc.c:68
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1781
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2005
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libvpxenc.c:303
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
void * buf_alpha
Definition: libvpxenc.c:53
int slices
Number of slices.
Definition: avcodec.h:1182
void * priv_data
Definition: avcodec.h:558
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libaomenc.c:47
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:477
int arnr_strength
Definition: libvpxenc.c:92
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:392
unsigned long duration
duration to show frame (in timebase units)
Definition: libaomenc.c:52
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:79
#define lrint
Definition: tablegen.h:53
int drop_threshold
Definition: libvpxenc.c:115
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
int have_sse
true if we have pending sse[]
Definition: libvpxenc.c:76
int height
Definition: frame.h:372
#define av_freep(p)
int rc_undershoot_pct
Definition: libvpxenc.c:102
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
static int realloc_alpha_uv(AVCodecContext *avctx, int width, int height)
Definition: libvpxenc.c:1444
#define av_malloc_array(a, b)
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
const AVProfile ff_vp9_profiles[]
Definition: profiles.c:133
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
int corpus_complexity
Definition: libvpxenc.c:121
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
#define av_unused
Definition: attributes.h:131
int tile_columns
Definition: libvpxenc.c:111
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1409
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
int keyint_min
minimum GOP size
Definition: avcodec.h:1112