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