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