FFmpeg: libavcodec/libvpxenc.c Source File

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

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