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