Libav
libvpxenc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010, Google, Inc.
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
26 #define VPX_DISABLE_CTRL_TYPECHECKS 1
27 #define VPX_CODEC_DISABLE_COMPAT 1
28 #include <vpx/vpx_encoder.h>
29 #include <vpx/vp8cx.h>
30 
31 #include "avcodec.h"
32 #include "internal.h"
33 #include "libvpx.h"
34 #include "libavutil/base64.h"
35 #include "libavutil/common.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/opt.h"
38 
43 struct FrameListData {
44  void *buf;
45  size_t sz;
46  int64_t pts;
48  unsigned long duration;
50  uint32_t flags;
52 };
53 
54 typedef struct VP8EncoderContext {
55  AVClass *class;
56  struct vpx_codec_ctx encoder;
57  struct vpx_image rawimg;
58  struct vpx_fixed_buf twopass_stats;
59  unsigned long deadline; //i.e., RT/GOOD/BEST
61  int cpu_used;
65  int arnr_type;
68  int crf;
72 } VP8Context;
73 
75 static const char *const ctlidstr[] = {
76  [VP8E_SET_ARNR_MAXFRAMES] = "VP8E_SET_ARNR_MAXFRAMES",
77  [VP8E_SET_ARNR_STRENGTH] = "VP8E_SET_ARNR_STRENGTH",
78  [VP8E_SET_ARNR_TYPE] = "VP8E_SET_ARNR_TYPE",
79  [VP8E_SET_CPUUSED] = "VP8E_SET_CPUUSED",
80  [VP8E_SET_CQ_LEVEL] = "VP8E_SET_CQ_LEVEL",
81  [VP8E_SET_ENABLEAUTOALTREF] = "VP8E_SET_ENABLEAUTOALTREF",
82  [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",
83  [VP8E_SET_STATIC_THRESHOLD] = "VP8E_SET_STATIC_THRESHOLD",
84  [VP8E_SET_TOKEN_PARTITIONS] = "VP8E_SET_TOKEN_PARTITIONS",
85 };
86 
87 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
88 {
89  VP8Context *ctx = avctx->priv_data;
90  const char *error = vpx_codec_error(&ctx->encoder);
91  const char *detail = vpx_codec_error_detail(&ctx->encoder);
92 
93  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
94  if (detail)
95  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
96 }
97 
98 static av_cold void dump_enc_cfg(AVCodecContext *avctx,
99  const struct vpx_codec_enc_cfg *cfg)
100 {
101  int width = -30;
102  int level = AV_LOG_DEBUG;
103 
104  av_log(avctx, level, "vpx_codec_enc_cfg\n");
105  av_log(avctx, level, "generic settings\n"
106  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
107  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
108  width, "g_usage:", cfg->g_usage,
109  width, "g_threads:", cfg->g_threads,
110  width, "g_profile:", cfg->g_profile,
111  width, "g_w:", cfg->g_w,
112  width, "g_h:", cfg->g_h,
113  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
114  width, "g_error_resilient:", cfg->g_error_resilient,
115  width, "g_pass:", cfg->g_pass,
116  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
117  av_log(avctx, level, "rate control settings\n"
118  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
119  " %*s%d\n %*s%p(%zu)\n %*s%u\n",
120  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
121  width, "rc_resize_allowed:", cfg->rc_resize_allowed,
122  width, "rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
123  width, "rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
124  width, "rc_end_usage:", cfg->rc_end_usage,
125  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
126  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
127  av_log(avctx, level, "quantizer settings\n"
128  " %*s%u\n %*s%u\n",
129  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
130  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
131  av_log(avctx, level, "bitrate tolerance\n"
132  " %*s%u\n %*s%u\n",
133  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
134  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
135  av_log(avctx, level, "decoder buffer model\n"
136  " %*s%u\n %*s%u\n %*s%u\n",
137  width, "rc_buf_sz:", cfg->rc_buf_sz,
138  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
139  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
140  av_log(avctx, level, "2 pass rate control settings\n"
141  " %*s%u\n %*s%u\n %*s%u\n",
142  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
143  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
144  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
145  av_log(avctx, level, "keyframing settings\n"
146  " %*s%d\n %*s%u\n %*s%u\n",
147  width, "kf_mode:", cfg->kf_mode,
148  width, "kf_min_dist:", cfg->kf_min_dist,
149  width, "kf_max_dist:", cfg->kf_max_dist);
150  av_log(avctx, level, "\n");
151 }
152 
153 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
154 {
155  struct FrameListData **p = list;
156 
157  while (*p)
158  p = &(*p)->next;
159  *p = cx_frame;
160  cx_frame->next = NULL;
161 }
162 
163 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
164 {
165  av_freep(&cx_frame->buf);
166  av_freep(&cx_frame);
167 }
168 
169 static av_cold void free_frame_list(struct FrameListData *list)
170 {
171  struct FrameListData *p = list;
172 
173  while (p) {
174  list = list->next;
175  free_coded_frame(p);
176  p = list;
177  }
178 }
179 
181  enum vp8e_enc_control_id id, int val)
182 {
183  VP8Context *ctx = avctx->priv_data;
184  char buf[80];
185  int width = -30;
186  int res;
187 
188  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
189  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
190 
191  res = vpx_codec_control(&ctx->encoder, id, val);
192  if (res != VPX_CODEC_OK) {
193  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
194  ctlidstr[id]);
195  log_encoder_error(avctx, buf);
196  }
197 
198  return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
199 }
200 
201 static av_cold int vp8_free(AVCodecContext *avctx)
202 {
203  VP8Context *ctx = avctx->priv_data;
204 
205  vpx_codec_destroy(&ctx->encoder);
206  av_freep(&ctx->twopass_stats.buf);
207  av_freep(&avctx->stats_out);
209  return 0;
210 }
211 
212 static av_cold int vpx_init(AVCodecContext *avctx,
213  const struct vpx_codec_iface *iface)
214 {
215  VP8Context *ctx = avctx->priv_data;
216  struct vpx_codec_enc_cfg enccfg = { 0 };
217  AVCPBProperties *cpb_props;
218  int res;
219 
220  av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
221  av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
222 
223  if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
224  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
225  vpx_codec_err_to_string(res));
226  return AVERROR(EINVAL);
227  }
228  dump_enc_cfg(avctx, &enccfg);
229 
230  enccfg.g_w = avctx->width;
231  enccfg.g_h = avctx->height;
232  enccfg.g_timebase.num = avctx->time_base.num;
233  enccfg.g_timebase.den = avctx->time_base.den;
234  enccfg.g_threads = avctx->thread_count;
235 
236  if (ctx->lag_in_frames >= 0)
237  enccfg.g_lag_in_frames = ctx->lag_in_frames;
238 
239  if (avctx->flags & AV_CODEC_FLAG_PASS1)
240  enccfg.g_pass = VPX_RC_FIRST_PASS;
241  else if (avctx->flags & AV_CODEC_FLAG_PASS2)
242  enccfg.g_pass = VPX_RC_LAST_PASS;
243  else
244  enccfg.g_pass = VPX_RC_ONE_PASS;
245 
246  if (!avctx->bit_rate)
247  avctx->bit_rate = enccfg.rc_target_bitrate * 1000;
248  else
249  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
251 
252  if (ctx->crf)
253  enccfg.rc_end_usage = VPX_CQ;
254  else if (avctx->rc_min_rate == avctx->rc_max_rate &&
255  avctx->rc_min_rate == avctx->bit_rate)
256  enccfg.rc_end_usage = VPX_CBR;
257 
258  if (avctx->qmin > 0)
259  enccfg.rc_min_quantizer = avctx->qmin;
260  if (avctx->qmax > 0)
261  enccfg.rc_max_quantizer = avctx->qmax;
262 
263 #if FF_API_PRIVATE_OPT
265  if (avctx->frame_skip_threshold)
266  ctx->drop_threshold = avctx->frame_skip_threshold;
268 #endif
269  enccfg.rc_dropframe_thresh = ctx->drop_threshold;
270 
271  //0-100 (0 => CBR, 100 => VBR)
272  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
273  enccfg.rc_2pass_vbr_minsection_pct =
274  avctx->rc_min_rate * 100LL / avctx->bit_rate;
275  if (avctx->rc_max_rate)
276  enccfg.rc_2pass_vbr_maxsection_pct =
277  avctx->rc_max_rate * 100LL / avctx->bit_rate;
278 
279  if (avctx->rc_buffer_size)
280  enccfg.rc_buf_sz =
281  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
282  if (avctx->rc_initial_buffer_occupancy)
283  enccfg.rc_buf_initial_sz =
284  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
285  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
286 
287  //_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO
288  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
289  enccfg.kf_min_dist = avctx->keyint_min;
290  if (avctx->gop_size >= 0)
291  enccfg.kf_max_dist = avctx->gop_size;
292 
293  if (enccfg.g_pass == VPX_RC_FIRST_PASS)
294  enccfg.g_lag_in_frames = 0;
295  else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
296  int decode_size, ret;
297 
298  if (!avctx->stats_in) {
299  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
300  return AVERROR_INVALIDDATA;
301  }
302 
303  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
304  ret = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
305  if (ret < 0) {
306  av_log(avctx, AV_LOG_ERROR,
307  "Stat buffer alloc (%zu bytes) failed\n",
308  ctx->twopass_stats.sz);
309  return ret;
310  }
311  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
312  ctx->twopass_stats.sz);
313  if (decode_size < 0) {
314  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
315  return AVERROR_INVALIDDATA;
316  }
317 
318  ctx->twopass_stats.sz = decode_size;
319  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
320  }
321 
322  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
323  complexity playback on low powered devices at the expense of encode
324  quality. */
325  if (avctx->profile != FF_PROFILE_UNKNOWN)
326  enccfg.g_profile = avctx->profile;
327  else if (avctx->pix_fmt == AV_PIX_FMT_YUV420P)
328  avctx->profile = enccfg.g_profile = FF_PROFILE_VP9_0;
329  else
330  avctx->profile = enccfg.g_profile = FF_PROFILE_VP9_1;
331 
332  enccfg.g_error_resilient = ctx->error_resilient;
333 
334  dump_enc_cfg(avctx, &enccfg);
335  /* Construct Encoder Context */
336  res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, 0);
337  if (res != VPX_CODEC_OK) {
338  log_encoder_error(avctx, "Failed to initialize encoder");
339  return AVERROR(EINVAL);
340  }
341 
342  //codec control failures are currently treated only as warnings
343  av_log(avctx, AV_LOG_DEBUG, "vpx_codec_control\n");
344  if (ctx->cpu_used != INT_MIN)
345  codecctl_int(avctx, VP8E_SET_CPUUSED, ctx->cpu_used);
346  if (ctx->auto_alt_ref >= 0)
347  codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
348  if (ctx->arnr_max_frames >= 0)
349  codecctl_int(avctx, VP8E_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
350  if (ctx->arnr_strength >= 0)
351  codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH, ctx->arnr_strength);
352  if (ctx->arnr_type >= 0)
353  codecctl_int(avctx, VP8E_SET_ARNR_TYPE, ctx->arnr_type);
354 
355  if (CONFIG_LIBVPX_VP8_ENCODER && iface == &vpx_codec_vp8_cx_algo) {
356 #if FF_API_PRIVATE_OPT
358  if (avctx->noise_reduction)
359  ctx->noise_sensitivity = avctx->noise_reduction;
361 #endif
362  codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, ctx->noise_sensitivity);
363  codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS, av_log2(avctx->slices));
364  }
365 #if FF_API_MPV_OPT
367  if (avctx->mb_threshold) {
368  av_log(avctx, AV_LOG_WARNING, "The mb_threshold option is deprecated, "
369  "use the static-thresh private option instead.\n");
370  ctx->static_thresh = avctx->mb_threshold;
371  }
373 #endif
374  codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD, ctx->static_thresh);
375  codecctl_int(avctx, VP8E_SET_CQ_LEVEL, ctx->crf);
376 
377  //provide dummy value to initialize wrapper, values will be updated each _encode()
378  vpx_img_wrap(&ctx->rawimg, ff_vpx_pixfmt_to_imgfmt(avctx->pix_fmt),
379  avctx->width, avctx->height, 1, (unsigned char *)1);
380 
381  cpb_props = ff_add_cpb_side_data(avctx);
382  if (!cpb_props)
383  return AVERROR(ENOMEM);
384 
385  if (enccfg.rc_end_usage == VPX_CBR ||
386  enccfg.g_pass != VPX_RC_ONE_PASS) {
387  cpb_props->max_bitrate = avctx->rc_max_rate;
388  cpb_props->min_bitrate = avctx->rc_min_rate;
389  cpb_props->avg_bitrate = avctx->bit_rate;
390  }
391  cpb_props->buffer_size = avctx->rc_buffer_size;
392 
393  return 0;
394 }
395 
396 static inline void cx_pktcpy(struct FrameListData *dst,
397  const struct vpx_codec_cx_pkt *src)
398 {
399  dst->pts = src->data.frame.pts;
400  dst->duration = src->data.frame.duration;
401  dst->flags = src->data.frame.flags;
402  dst->sz = src->data.frame.sz;
403  dst->buf = src->data.frame.buf;
404 }
405 
413 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
414  AVPacket *pkt)
415 {
416  int ret = ff_alloc_packet(pkt, cx_frame->sz);
417  if (ret >= 0) {
418  memcpy(pkt->data, cx_frame->buf, pkt->size);
419  pkt->pts = pkt->dts = cx_frame->pts;
420 #if FF_API_CODED_FRAME
422  avctx->coded_frame->pts = cx_frame->pts;
423  avctx->coded_frame->key_frame = !!(cx_frame->flags & VPX_FRAME_IS_KEY);
425 #endif
426 
427  if (!!(cx_frame->flags & VPX_FRAME_IS_KEY)) {
428 #if FF_API_CODED_FRAME
432 #endif
433  pkt->flags |= AV_PKT_FLAG_KEY;
434  } else {
435 #if FF_API_CODED_FRAME
439 #endif
440  }
441  } else {
442  av_log(avctx, AV_LOG_ERROR,
443  "Error getting output packet of size %zu.\n", cx_frame->sz);
444  return ret;
445  }
446  return pkt->size;
447 }
448 
457 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
458 {
459  VP8Context *ctx = avctx->priv_data;
460  const struct vpx_codec_cx_pkt *pkt;
461  const void *iter = NULL;
462  int size = 0;
463 
464  if (ctx->coded_frame_list) {
465  struct FrameListData *cx_frame = ctx->coded_frame_list;
466  /* return the leading frame if we've already begun queueing */
467  size = storeframe(avctx, cx_frame, pkt_out);
468  if (size < 0)
469  return size;
470  ctx->coded_frame_list = cx_frame->next;
471  free_coded_frame(cx_frame);
472  }
473 
474  /* consume all available output from the encoder before returning. buffers
475  are only good through the next vpx_codec call */
476  while ((pkt = vpx_codec_get_cx_data(&ctx->encoder, &iter))) {
477  switch (pkt->kind) {
478  case VPX_CODEC_CX_FRAME_PKT:
479  if (!size) {
480  struct FrameListData cx_frame;
481 
482  /* avoid storing the frame when the list is empty and we haven't yet
483  provided a frame for output */
484  assert(!ctx->coded_frame_list);
485  cx_pktcpy(&cx_frame, pkt);
486  size = storeframe(avctx, &cx_frame, pkt_out);
487  if (size < 0)
488  return size;
489  } else {
490  struct FrameListData *cx_frame =
491  av_malloc(sizeof(struct FrameListData));
492 
493  if (!cx_frame) {
494  av_log(avctx, AV_LOG_ERROR,
495  "Frame queue element alloc failed\n");
496  return AVERROR(ENOMEM);
497  }
498  cx_pktcpy(cx_frame, pkt);
499  cx_frame->buf = av_malloc(cx_frame->sz);
500 
501  if (!cx_frame->buf) {
502  av_log(avctx, AV_LOG_ERROR,
503  "Data buffer alloc (%zu bytes) failed\n",
504  cx_frame->sz);
505  av_freep(&cx_frame);
506  return AVERROR(ENOMEM);
507  }
508  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
509  coded_frame_add(&ctx->coded_frame_list, cx_frame);
510  }
511  break;
512  case VPX_CODEC_STATS_PKT: {
513  struct vpx_fixed_buf *stats = &ctx->twopass_stats;
514  int err;
515  if ((err = av_reallocp(&stats->buf,
516  stats->sz +
517  pkt->data.twopass_stats.sz)) < 0) {
518  stats->sz = 0;
519  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
520  return err;
521  }
522  memcpy((uint8_t*)stats->buf + stats->sz,
523  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
524  stats->sz += pkt->data.twopass_stats.sz;
525  break;
526  }
527  case VPX_CODEC_PSNR_PKT: //FIXME add support for AV_CODEC_FLAG_PSNR
528  case VPX_CODEC_CUSTOM_PKT:
529  //ignore unsupported/unrecognized packet types
530  break;
531  }
532  }
533 
534  return size;
535 }
536 
537 static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt,
538  const AVFrame *frame, int *got_packet)
539 {
540  VP8Context *ctx = avctx->priv_data;
541  struct vpx_image *rawimg = NULL;
542  int64_t timestamp = 0;
543  int res, coded_size;
544  vpx_enc_frame_flags_t flags = 0;
545 
546  if (frame) {
547  rawimg = &ctx->rawimg;
548  rawimg->planes[VPX_PLANE_Y] = frame->data[0];
549  rawimg->planes[VPX_PLANE_U] = frame->data[1];
550  rawimg->planes[VPX_PLANE_V] = frame->data[2];
551  rawimg->stride[VPX_PLANE_Y] = frame->linesize[0];
552  rawimg->stride[VPX_PLANE_U] = frame->linesize[1];
553  rawimg->stride[VPX_PLANE_V] = frame->linesize[2];
554  timestamp = frame->pts;
555 #if VPX_IMAGE_ABI_VERSION >= 4
556  switch (frame->color_range) {
557  case AVCOL_RANGE_MPEG:
558  rawimg->range = VPX_CR_STUDIO_RANGE;
559  break;
560  case AVCOL_RANGE_JPEG:
561  rawimg->range = VPX_CR_FULL_RANGE;
562  break;
563  }
564 #endif
565  if (frame->pict_type == AV_PICTURE_TYPE_I)
566  flags |= VPX_EFLAG_FORCE_KF;
567  }
568 
569  res = vpx_codec_encode(&ctx->encoder, rawimg, timestamp,
570  avctx->ticks_per_frame, flags, ctx->deadline);
571  if (res != VPX_CODEC_OK) {
572  log_encoder_error(avctx, "Error encoding frame");
573  return AVERROR_INVALIDDATA;
574  }
575  coded_size = queue_frames(avctx, pkt);
576 
577  if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
578  unsigned int b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
579 
580  avctx->stats_out = av_malloc(b64_size);
581  if (!avctx->stats_out) {
582  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%d bytes) failed\n",
583  b64_size);
584  return AVERROR(ENOMEM);
585  }
586  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
587  ctx->twopass_stats.sz);
588  }
589 
590  *got_packet = !!coded_size;
591  return 0;
592 }
593 
594 #define OFFSET(x) offsetof(VP8Context, x)
595 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
596 static const AVOption options[] = {
597  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = 1}, INT_MIN, INT_MAX, VE},
598  { "auto-alt-ref", "Enable use of alternate reference "
599  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},
600  { "lag-in-frames", "Number of frames to look ahead for "
601  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
602  { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
603  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
604  { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"},
605  { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" },
606  { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" },
607  { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" },
608  { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"},
609  { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"},
610  { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"},
611  { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"},
612  { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
613 #ifdef VPX_ERROR_RESILIENT_DEFAULT
614  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
615  { "partitions", "The frame partitions are independently decodable "
616  "by the bool decoder, meaning that partitions can be decoded even "
617  "though earlier partitions have been lost. Note that intra predicition"
618  " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"},
619 #endif
620  { "crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 63, VE },
621  { "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 },
622  { "drop-threshold", "Frame drop threshold", offsetof(VP8Context, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
623  { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE},
624  { NULL }
625 };
626 
627 static const AVCodecDefault defaults[] = {
628  { "qmin", "-1" },
629  { "qmax", "-1" },
630  { "g", "-1" },
631  { "keyint_min", "-1" },
632  { NULL },
633 };
634 
635 #if CONFIG_LIBVPX_VP8_ENCODER
636 static av_cold int vp8_init(AVCodecContext *avctx)
637 {
638  return vpx_init(avctx, &vpx_codec_vp8_cx_algo);
639 }
640 
641 static const AVClass class_vp8 = {
642  .class_name = "libvpx encoder",
643  .item_name = av_default_item_name,
644  .option = options,
645  .version = LIBAVUTIL_VERSION_INT,
646 };
647 
648 AVCodec ff_libvpx_vp8_encoder = {
649  .name = "libvpx",
650  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
651  .type = AVMEDIA_TYPE_VIDEO,
652  .id = AV_CODEC_ID_VP8,
653  .priv_data_size = sizeof(VP8Context),
654  .init = vp8_init,
655  .encode2 = vp8_encode,
656  .close = vp8_free,
659  .priv_class = &class_vp8,
660  .defaults = defaults,
661 };
662 #endif /* CONFIG_LIBVPX_VP8_ENCODER */
663 
664 #if CONFIG_LIBVPX_VP9_ENCODER
665 static av_cold int vp9_init(AVCodecContext *avctx)
666 {
667  return vpx_init(avctx, &vpx_codec_vp9_cx_algo);
668 }
669 
670 static const AVClass class_vp9 = {
671  .class_name = "libvpx encoder",
672  .item_name = av_default_item_name,
673  .option = options,
674  .version = LIBAVUTIL_VERSION_INT,
675 };
676 
677 static const AVProfile profiles[] = {
678  { FF_PROFILE_VP9_0, "Profile 0" },
679  { FF_PROFILE_VP9_1, "Profile 1" },
680  { FF_PROFILE_VP9_2, "Profile 2" },
681  { FF_PROFILE_VP9_3, "Profile 3" },
682  { FF_PROFILE_UNKNOWN },
683 };
684 
685 AVCodec ff_libvpx_vp9_encoder = {
686  .name = "libvpx-vp9",
687  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"),
688  .type = AVMEDIA_TYPE_VIDEO,
689  .id = AV_CODEC_ID_VP9,
690  .priv_data_size = sizeof(VP8Context),
691  .init = vp9_init,
692  .encode2 = vp8_encode,
693  .close = vp8_free,
695  .pix_fmts = (const enum AVPixelFormat[]) {
697 #if VPX_IMAGE_ABI_VERSION >= 3
701 #endif
703  },
704  .profiles = NULL_IF_CONFIG_SMALL(profiles),
705  .priv_class = &class_vp9,
706  .defaults = defaults,
707 };
708 #endif /* CONFIG_LIBVPX_VP9_ENCODER */
int cpu_used
Definition: libvpxenc.c:61
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int lag_in_frames
Definition: libvpxenc.c:66
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
AVOption.
Definition: opt.h:234
struct vpx_codec_ctx encoder
Definition: libvpxenc.c:56
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:40
#define OFFSET(x)
Definition: libvpxenc.c:594
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:64
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:130
const char * desc
Definition: nvenc.c:101
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1145
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2426
int num
numerator
Definition: rational.h:44
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1621
size_t sz
length of compressed data
Definition: libvpxenc.c:45
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2564
int arnr_max_frames
Definition: libvpxenc.c:63
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:905
int profile
profile
Definition: avcodec.h:2880
AVCodec.
Definition: avcodec.h:3120
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1150
int error_resilient
Definition: libvpxenc.c:67
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1535
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:202
#define FF_PROFILE_VP9_0
Definition: avcodec.h:2956
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:39
#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: avcodec.h:863
int auto_alt_ref
Definition: libvpxenc.c:62
static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src)
Definition: libvpxenc.c:396
uint8_t
#define av_cold
Definition: attributes.h:66
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
Definition: libvpxenc.c:180
int64_t pts
time stamp to show frame (in timebase units)
Definition: libvpxenc.c:46
AVOptions.
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libvpxenc.c:153
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:211
uint8_t * data
Definition: avcodec.h:1346
int av_reallocp(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:140
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:140
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1161
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2556
attribute_deprecated int frame_skip_threshold
Definition: avcodec.h:2466
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1378
#define src
Definition: vp8dsp.c:254
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
struct vpx_image rawimg
Definition: libvpxenc.c:57
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt)
Store coded frame information in format suitable for return from encode2().
Definition: libvpxenc.c:413
#define AVERROR(e)
Definition: error.h:43
#define FF_PROFILE_VP9_3
Definition: avcodec.h:2959
#define CONFIG_LIBVPX_VP8_ENCODER
Definition: config.h:1163
int qmax
maximum quantizer
Definition: avcodec.h:2337
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
enum AVColorRange color_range
Definition: frame.h:351
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1503
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:54
static const AVOption options[]
Definition: libvpxenc.c:596
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2387
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
static av_always_inline av_const double round(double x)
Definition: libm.h:151
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:72
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1352
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:63
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2364
#define FF_PROFILE_VP9_2
Definition: avcodec.h:2958
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
Definition: libvpxenc.c:98
int bit_rate
the average bitrate
Definition: avcodec.h:1473
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:201
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes.
Definition: base64.h:59
vpx_img_fmt_t ff_vpx_pixfmt_to_imgfmt(enum AVPixelFormat pix)
Definition: libvpx.c:53
int width
picture width / height.
Definition: avcodec.h:1580
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2881
attribute_deprecated int noise_reduction
Definition: avcodec.h:1979
int static_thresh
Definition: libvpxenc.c:69
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:751
static av_cold int vp8_free(AVCodecContext *avctx)
Definition: libvpxenc.c:201
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1211
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1544
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libvpxenc.c:87
attribute_deprecated int mb_threshold
Definition: avcodec.h:1993
int arnr_strength
Definition: libvpxenc.c:64
LIBAVUTIL_VERSION_INT
Definition: eval.c:55
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2806
struct FrameListData * next
Definition: libvpxenc.c:51
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:365
static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)
Definition: libvpxenc.c:212
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1140
NULL
Definition: eval.c:55
static const AVCodecDefault defaults[]
Definition: libvpxenc.c:627
#define FF_PROFILE_VP9_1
Definition: avcodec.h:2957
static int width
Definition: utils.c:156
#define AV_LOG_INFO
Standard information.
Definition: log.h:135
#define VE
Definition: libvpxenc.c:595
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:158
static av_cold int vp9_init(AVFormatContext *ctx, int st_index, PayloadContext *data)
Definition: rtpdec_vp9.c:34
av_default_item_name
Definition: dnxhdenc.c:55
main external API structure.
Definition: avcodec.h:1409
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
Queue multiple output frames from the encoder, returning the front-most.
Definition: libvpxenc.c:457
int qmin
minimum quantizer
Definition: avcodec.h:2330
static const AVProfile profiles[]
Definition: libdcadec.c:181
Describe the class of an AVClass context structure.
Definition: log.h:34
int arnr_type
Definition: libvpxenc.c:65
uint32_t flags
flags for this frame
Definition: libvpxenc.c:50
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libvpxenc.c:163
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2322
static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libvpxenc.c:537
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:257
void * buf
compressed data buffer
Definition: libvpxenc.c:44
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
uint8_t level
Definition: svq3.c:204
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:364
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1606
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
Definition: libvpxenc.c:75
struct vpx_fixed_buf twopass_stats
Definition: libvpxenc.c:58
static av_cold int vp8_init(AVFormatContext *s, int st_index, PayloadContext *vp8)
Definition: rtpdec_vp8.c:263
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:59
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:77
common internal api header.
int noise_sensitivity
Definition: libvpxenc.c:71
common internal and external API header
unsigned long deadline
Definition: libvpxenc.c:59
AVProfile.
Definition: avcodec.h:3108
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2797
int den
denominator
Definition: rational.h:45
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2754
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libvpxenc.c:169
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:755
int slices
Number of slices.
Definition: avcodec.h:2143
void * priv_data
Definition: avcodec.h:1451
int drop_threshold
Definition: libvpxenc.c:70
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:78
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libvpxenc.c:43
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
#define av_log2
Definition: intmath.h:85
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:196
unsigned long duration
duration to show frame (in timebase units)
Definition: libvpxenc.c:48
int av_base64_decode(uint8_t *out, const char *in, int out_size)
Decode a base64-encoded string.
Definition: base64.c:45
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1345
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:96
int rc_min_rate
minimum bitrate
Definition: avcodec.h:2394
AVPixelFormat
Pixel format.
Definition: pixfmt.h:57
This structure stores compressed data.
Definition: avcodec.h:1323
struct FrameListData * coded_frame_list
Definition: libvpxenc.c:60
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1339
Predicted.
Definition: avutil.h:261
int keyint_min
minimum GOP size
Definition: avcodec.h:2064