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 "libavutil/base64.h"
34 #include "libavutil/common.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/opt.h"
37 
42 struct FrameListData {
43  void *buf;
44  size_t sz;
45  int64_t pts;
47  unsigned long duration;
49  uint32_t flags;
51 };
52 
53 typedef struct VP8EncoderContext {
54  AVClass *class;
55  struct vpx_codec_ctx encoder;
56  struct vpx_image rawimg;
57  struct vpx_fixed_buf twopass_stats;
58  unsigned long deadline; //i.e., RT/GOOD/BEST
60  int cpu_used;
64  int arnr_type;
67  int crf;
68 } VP8Context;
69 
71 static const char *const ctlidstr[] = {
72  [VP8E_UPD_ENTROPY] = "VP8E_UPD_ENTROPY",
73  [VP8E_UPD_REFERENCE] = "VP8E_UPD_REFERENCE",
74  [VP8E_USE_REFERENCE] = "VP8E_USE_REFERENCE",
75  [VP8E_SET_ROI_MAP] = "VP8E_SET_ROI_MAP",
76  [VP8E_SET_ACTIVEMAP] = "VP8E_SET_ACTIVEMAP",
77  [VP8E_SET_SCALEMODE] = "VP8E_SET_SCALEMODE",
78  [VP8E_SET_CPUUSED] = "VP8E_SET_CPUUSED",
79  [VP8E_SET_ENABLEAUTOALTREF] = "VP8E_SET_ENABLEAUTOALTREF",
80  [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",
81  [VP8E_SET_SHARPNESS] = "VP8E_SET_SHARPNESS",
82  [VP8E_SET_STATIC_THRESHOLD] = "VP8E_SET_STATIC_THRESHOLD",
83  [VP8E_SET_TOKEN_PARTITIONS] = "VP8E_SET_TOKEN_PARTITIONS",
84  [VP8E_GET_LAST_QUANTIZER] = "VP8E_GET_LAST_QUANTIZER",
85  [VP8E_SET_ARNR_MAXFRAMES] = "VP8E_SET_ARNR_MAXFRAMES",
86  [VP8E_SET_ARNR_STRENGTH] = "VP8E_SET_ARNR_STRENGTH",
87  [VP8E_SET_ARNR_TYPE] = "VP8E_SET_ARNR_TYPE",
88  [VP8E_SET_CQ_LEVEL] = "VP8E_SET_CQ_LEVEL",
89 };
90 
91 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
92 {
93  VP8Context *ctx = avctx->priv_data;
94  const char *error = vpx_codec_error(&ctx->encoder);
95  const char *detail = vpx_codec_error_detail(&ctx->encoder);
96 
97  av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
98  if (detail)
99  av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", detail);
100 }
101 
103  const struct vpx_codec_enc_cfg *cfg)
104 {
105  int width = -30;
106  int level = AV_LOG_DEBUG;
107 
108  av_log(avctx, level, "vpx_codec_enc_cfg\n");
109  av_log(avctx, level, "generic settings\n"
110  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
111  " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
112  width, "g_usage:", cfg->g_usage,
113  width, "g_threads:", cfg->g_threads,
114  width, "g_profile:", cfg->g_profile,
115  width, "g_w:", cfg->g_w,
116  width, "g_h:", cfg->g_h,
117  width, "g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
118  width, "g_error_resilient:", cfg->g_error_resilient,
119  width, "g_pass:", cfg->g_pass,
120  width, "g_lag_in_frames:", cfg->g_lag_in_frames);
121  av_log(avctx, level, "rate control settings\n"
122  " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
123  " %*s%d\n %*s%p(%zu)\n %*s%u\n",
124  width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
125  width, "rc_resize_allowed:", cfg->rc_resize_allowed,
126  width, "rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
127  width, "rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
128  width, "rc_end_usage:", cfg->rc_end_usage,
129  width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
130  width, "rc_target_bitrate:", cfg->rc_target_bitrate);
131  av_log(avctx, level, "quantizer settings\n"
132  " %*s%u\n %*s%u\n",
133  width, "rc_min_quantizer:", cfg->rc_min_quantizer,
134  width, "rc_max_quantizer:", cfg->rc_max_quantizer);
135  av_log(avctx, level, "bitrate tolerance\n"
136  " %*s%u\n %*s%u\n",
137  width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
138  width, "rc_overshoot_pct:", cfg->rc_overshoot_pct);
139  av_log(avctx, level, "decoder buffer model\n"
140  " %*s%u\n %*s%u\n %*s%u\n",
141  width, "rc_buf_sz:", cfg->rc_buf_sz,
142  width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
143  width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
144  av_log(avctx, level, "2 pass rate control settings\n"
145  " %*s%u\n %*s%u\n %*s%u\n",
146  width, "rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
147  width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
148  width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
149  av_log(avctx, level, "keyframing settings\n"
150  " %*s%d\n %*s%u\n %*s%u\n",
151  width, "kf_mode:", cfg->kf_mode,
152  width, "kf_min_dist:", cfg->kf_min_dist,
153  width, "kf_max_dist:", cfg->kf_max_dist);
154  av_log(avctx, level, "\n");
155 }
156 
157 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
158 {
159  struct FrameListData **p = list;
160 
161  while (*p != NULL)
162  p = &(*p)->next;
163  *p = cx_frame;
164  cx_frame->next = NULL;
165 }
166 
167 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
168 {
169  av_freep(&cx_frame->buf);
170  av_freep(&cx_frame);
171 }
172 
173 static av_cold void free_frame_list(struct FrameListData *list)
174 {
175  struct FrameListData *p = list;
176 
177  while (p) {
178  list = list->next;
179  free_coded_frame(p);
180  p = list;
181  }
182 }
183 
185  enum vp8e_enc_control_id id, int val)
186 {
187  VP8Context *ctx = avctx->priv_data;
188  char buf[80];
189  int width = -30;
190  int res;
191 
192  snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
193  av_log(avctx, AV_LOG_DEBUG, " %*s%d\n", width, buf, val);
194 
195  res = vpx_codec_control(&ctx->encoder, id, val);
196  if (res != VPX_CODEC_OK) {
197  snprintf(buf, sizeof(buf), "Failed to set %s codec control",
198  ctlidstr[id]);
199  log_encoder_error(avctx, buf);
200  }
201 
202  return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
203 }
204 
205 static av_cold int vp8_free(AVCodecContext *avctx)
206 {
207  VP8Context *ctx = avctx->priv_data;
208 
209  vpx_codec_destroy(&ctx->encoder);
210  av_freep(&ctx->twopass_stats.buf);
211  av_freep(&avctx->coded_frame);
212  av_freep(&avctx->stats_out);
213  free_frame_list(ctx->coded_frame_list);
214  return 0;
215 }
216 
217 static av_cold int vp8_init(AVCodecContext *avctx)
218 {
219  VP8Context *ctx = avctx->priv_data;
220  const struct vpx_codec_iface *iface = &vpx_codec_vp8_cx_algo;
221  struct vpx_codec_enc_cfg enccfg;
222  int res;
223 
224  av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
225  av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
226 
227  if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
228  av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
229  vpx_codec_err_to_string(res));
230  return AVERROR(EINVAL);
231  }
232  dump_enc_cfg(avctx, &enccfg);
233 
234  enccfg.g_w = avctx->width;
235  enccfg.g_h = avctx->height;
236  enccfg.g_timebase.num = avctx->time_base.num;
237  enccfg.g_timebase.den = avctx->time_base.den;
238  enccfg.g_threads = avctx->thread_count;
239 
240  if (ctx->lag_in_frames >= 0)
241  enccfg.g_lag_in_frames = ctx->lag_in_frames;
242 
243  if (avctx->flags & CODEC_FLAG_PASS1)
244  enccfg.g_pass = VPX_RC_FIRST_PASS;
245  else if (avctx->flags & CODEC_FLAG_PASS2)
246  enccfg.g_pass = VPX_RC_LAST_PASS;
247  else
248  enccfg.g_pass = VPX_RC_ONE_PASS;
249 
250  if (!avctx->bit_rate)
251  avctx->bit_rate = enccfg.rc_target_bitrate * 1000;
252  else
253  enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
255 
256  if (ctx->crf)
257  enccfg.rc_end_usage = VPX_CQ;
258  else if (avctx->rc_min_rate == avctx->rc_max_rate &&
259  avctx->rc_min_rate == avctx->bit_rate)
260  enccfg.rc_end_usage = VPX_CBR;
261 
262  if (avctx->qmin > 0)
263  enccfg.rc_min_quantizer = avctx->qmin;
264  if (avctx->qmax > 0)
265  enccfg.rc_max_quantizer = avctx->qmax;
266  enccfg.rc_dropframe_thresh = avctx->frame_skip_threshold;
267 
268  //0-100 (0 => CBR, 100 => VBR)
269  enccfg.rc_2pass_vbr_bias_pct = round(avctx->qcompress * 100);
270  enccfg.rc_2pass_vbr_minsection_pct =
271  avctx->rc_min_rate * 100LL / avctx->bit_rate;
272  if (avctx->rc_max_rate)
273  enccfg.rc_2pass_vbr_maxsection_pct =
274  avctx->rc_max_rate * 100LL / avctx->bit_rate;
275 
276  if (avctx->rc_buffer_size)
277  enccfg.rc_buf_sz =
278  avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
279  if (avctx->rc_initial_buffer_occupancy)
280  enccfg.rc_buf_initial_sz =
281  avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
282  enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
283 
284  //_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO
285  if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
286  enccfg.kf_min_dist = avctx->keyint_min;
287  if (avctx->gop_size >= 0)
288  enccfg.kf_max_dist = avctx->gop_size;
289 
290  if (enccfg.g_pass == VPX_RC_FIRST_PASS)
291  enccfg.g_lag_in_frames = 0;
292  else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
293  int decode_size;
294 
295  if (!avctx->stats_in) {
296  av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
297  return AVERROR_INVALIDDATA;
298  }
299 
300  ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
301  ctx->twopass_stats.buf = av_malloc(ctx->twopass_stats.sz);
302  if (!ctx->twopass_stats.buf) {
303  av_log(avctx, AV_LOG_ERROR,
304  "Stat buffer alloc (%zu bytes) failed\n",
305  ctx->twopass_stats.sz);
306  return AVERROR(ENOMEM);
307  }
308  decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
309  ctx->twopass_stats.sz);
310  if (decode_size < 0) {
311  av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
312  return AVERROR_INVALIDDATA;
313  }
314 
315  ctx->twopass_stats.sz = decode_size;
316  enccfg.rc_twopass_stats_in = ctx->twopass_stats;
317  }
318 
319  /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
320  complexity playback on low powered devices at the expense of encode
321  quality. */
322  if (avctx->profile != FF_PROFILE_UNKNOWN)
323  enccfg.g_profile = avctx->profile;
324 
325  enccfg.g_error_resilient = ctx->error_resilient;
326 
327  dump_enc_cfg(avctx, &enccfg);
328  /* Construct Encoder Context */
329  res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, 0);
330  if (res != VPX_CODEC_OK) {
331  log_encoder_error(avctx, "Failed to initialize encoder");
332  return AVERROR(EINVAL);
333  }
334 
335  //codec control failures are currently treated only as warnings
336  av_log(avctx, AV_LOG_DEBUG, "vpx_codec_control\n");
337  if (ctx->cpu_used != INT_MIN)
338  codecctl_int(avctx, VP8E_SET_CPUUSED, ctx->cpu_used);
339  if (ctx->auto_alt_ref >= 0)
340  codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
341  if (ctx->arnr_max_frames >= 0)
342  codecctl_int(avctx, VP8E_SET_ARNR_MAXFRAMES, ctx->arnr_max_frames);
343  if (ctx->arnr_strength >= 0)
344  codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH, ctx->arnr_strength);
345  if (ctx->arnr_type >= 0)
346  codecctl_int(avctx, VP8E_SET_ARNR_TYPE, ctx->arnr_type);
347  codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, avctx->noise_reduction);
348  codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS, av_log2(avctx->slices));
349  codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD, avctx->mb_threshold);
350  codecctl_int(avctx, VP8E_SET_CQ_LEVEL, ctx->crf);
351 
352  //provide dummy value to initialize wrapper, values will be updated each _encode()
353  vpx_img_wrap(&ctx->rawimg, VPX_IMG_FMT_I420, avctx->width, avctx->height, 1,
354  (unsigned char*)1);
355 
356  avctx->coded_frame = avcodec_alloc_frame();
357  if (!avctx->coded_frame) {
358  av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");
359  vp8_free(avctx);
360  return AVERROR(ENOMEM);
361  }
362  return 0;
363 }
364 
365 static inline void cx_pktcpy(struct FrameListData *dst,
366  const struct vpx_codec_cx_pkt *src)
367 {
368  dst->pts = src->data.frame.pts;
369  dst->duration = src->data.frame.duration;
370  dst->flags = src->data.frame.flags;
371  dst->sz = src->data.frame.sz;
372  dst->buf = src->data.frame.buf;
373 }
374 
382 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
383  AVPacket *pkt, AVFrame *coded_frame)
384 {
385  int ret = ff_alloc_packet(pkt, cx_frame->sz);
386  if (ret >= 0) {
387  memcpy(pkt->data, cx_frame->buf, pkt->size);
388  pkt->pts = pkt->dts = cx_frame->pts;
389  coded_frame->pts = cx_frame->pts;
390  coded_frame->key_frame = !!(cx_frame->flags & VPX_FRAME_IS_KEY);
391 
392  if (coded_frame->key_frame) {
393  coded_frame->pict_type = AV_PICTURE_TYPE_I;
394  pkt->flags |= AV_PKT_FLAG_KEY;
395  } else
396  coded_frame->pict_type = AV_PICTURE_TYPE_P;
397  } else {
398  av_log(avctx, AV_LOG_ERROR,
399  "Error getting output packet of size %zu.\n", cx_frame->sz);
400  return ret;
401  }
402  return pkt->size;
403 }
404 
413 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out,
414  AVFrame *coded_frame)
415 {
416  VP8Context *ctx = avctx->priv_data;
417  const struct vpx_codec_cx_pkt *pkt;
418  const void *iter = NULL;
419  int size = 0;
420 
421  if (ctx->coded_frame_list) {
422  struct FrameListData *cx_frame = ctx->coded_frame_list;
423  /* return the leading frame if we've already begun queueing */
424  size = storeframe(avctx, cx_frame, pkt_out, coded_frame);
425  if (size < 0)
426  return size;
427  ctx->coded_frame_list = cx_frame->next;
428  free_coded_frame(cx_frame);
429  }
430 
431  /* consume all available output from the encoder before returning. buffers
432  are only good through the next vpx_codec call */
433  while ((pkt = vpx_codec_get_cx_data(&ctx->encoder, &iter))) {
434  switch (pkt->kind) {
435  case VPX_CODEC_CX_FRAME_PKT:
436  if (!size) {
437  struct FrameListData cx_frame;
438 
439  /* avoid storing the frame when the list is empty and we haven't yet
440  provided a frame for output */
441  assert(!ctx->coded_frame_list);
442  cx_pktcpy(&cx_frame, pkt);
443  size = storeframe(avctx, &cx_frame, pkt_out, coded_frame);
444  if (size < 0)
445  return size;
446  } else {
447  struct FrameListData *cx_frame =
448  av_malloc(sizeof(struct FrameListData));
449 
450  if (!cx_frame) {
451  av_log(avctx, AV_LOG_ERROR,
452  "Frame queue element alloc failed\n");
453  return AVERROR(ENOMEM);
454  }
455  cx_pktcpy(cx_frame, pkt);
456  cx_frame->buf = av_malloc(cx_frame->sz);
457 
458  if (!cx_frame->buf) {
459  av_log(avctx, AV_LOG_ERROR,
460  "Data buffer alloc (%zu bytes) failed\n",
461  cx_frame->sz);
462  return AVERROR(ENOMEM);
463  }
464  memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
465  coded_frame_add(&ctx->coded_frame_list, cx_frame);
466  }
467  break;
468  case VPX_CODEC_STATS_PKT: {
469  struct vpx_fixed_buf *stats = &ctx->twopass_stats;
470  stats->buf = av_realloc(stats->buf,
471  stats->sz + pkt->data.twopass_stats.sz);
472  if (!stats->buf) {
473  av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
474  return AVERROR(ENOMEM);
475  }
476  memcpy((uint8_t*)stats->buf + stats->sz,
477  pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
478  stats->sz += pkt->data.twopass_stats.sz;
479  break;
480  }
481  case VPX_CODEC_PSNR_PKT: //FIXME add support for CODEC_FLAG_PSNR
482  case VPX_CODEC_CUSTOM_PKT:
483  //ignore unsupported/unrecognized packet types
484  break;
485  }
486  }
487 
488  return size;
489 }
490 
491 static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt,
492  const AVFrame *frame, int *got_packet)
493 {
494  VP8Context *ctx = avctx->priv_data;
495  struct vpx_image *rawimg = NULL;
496  int64_t timestamp = 0;
497  int res, coded_size;
498  vpx_enc_frame_flags_t flags = 0;
499 
500  if (frame) {
501  rawimg = &ctx->rawimg;
502  rawimg->planes[VPX_PLANE_Y] = frame->data[0];
503  rawimg->planes[VPX_PLANE_U] = frame->data[1];
504  rawimg->planes[VPX_PLANE_V] = frame->data[2];
505  rawimg->stride[VPX_PLANE_Y] = frame->linesize[0];
506  rawimg->stride[VPX_PLANE_U] = frame->linesize[1];
507  rawimg->stride[VPX_PLANE_V] = frame->linesize[2];
508  timestamp = frame->pts;
509  if (frame->pict_type == AV_PICTURE_TYPE_I)
510  flags |= VPX_EFLAG_FORCE_KF;
511  }
512 
513  res = vpx_codec_encode(&ctx->encoder, rawimg, timestamp,
514  avctx->ticks_per_frame, flags, ctx->deadline);
515  if (res != VPX_CODEC_OK) {
516  log_encoder_error(avctx, "Error encoding frame");
517  return AVERROR_INVALIDDATA;
518  }
519  coded_size = queue_frames(avctx, pkt, avctx->coded_frame);
520 
521  if (!frame && avctx->flags & CODEC_FLAG_PASS1) {
522  unsigned int b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
523 
524  avctx->stats_out = av_malloc(b64_size);
525  if (!avctx->stats_out) {
526  av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%d bytes) failed\n",
527  b64_size);
528  return AVERROR(ENOMEM);
529  }
530  av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
531  ctx->twopass_stats.sz);
532  }
533 
534  *got_packet = !!coded_size;
535  return 0;
536 }
537 
538 #define OFFSET(x) offsetof(VP8Context, x)
539 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
540 static const AVOption options[] = {
541  { "cpu-used", "Quality/Speed ratio modifier", OFFSET(cpu_used), AV_OPT_TYPE_INT, {.i64 = INT_MIN}, INT_MIN, INT_MAX, VE},
542  { "auto-alt-ref", "Enable use of alternate reference "
543  "frames (2-pass only)", OFFSET(auto_alt_ref), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, VE},
544  { "lag-in-frames", "Number of frames to look ahead for "
545  "alternate reference frame selection", OFFSET(lag_in_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
546  { "arnr-maxframes", "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
547  { "arnr-strength", "altref noise reduction filter strength", OFFSET(arnr_strength), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE},
548  { "arnr-type", "altref noise reduction filter type", OFFSET(arnr_type), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VE, "arnr_type"},
549  { "backward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" },
550  { "forward", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" },
551  { "centered", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" },
552  { "deadline", "Time to spend encoding, in microseconds.", OFFSET(deadline), AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"},
553  { "best", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"},
554  { "good", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"},
555  { "realtime", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME}, 0, 0, VE, "quality"},
556  { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
557 #ifdef VPX_ERROR_RESILIENT_DEFAULT
558  { "default", "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
559  { "partitions", "The frame partitions are independently decodable "
560  "by the bool decoder, meaning that partitions can be decoded even "
561  "though earlier partitions have been lost. Note that intra predicition"
562  " is still done over the partition boundary.", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"},
563 #endif
564  { "crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 63, VE },
565  { NULL }
566 };
567 
568 static const AVClass class = {
569  .class_name = "libvpx encoder",
570  .item_name = av_default_item_name,
571  .option = options,
573 };
574 
575 static const AVCodecDefault defaults[] = {
576  { "qmin", "-1" },
577  { "qmax", "-1" },
578  { "g", "-1" },
579  { "keyint_min", "-1" },
580  { NULL },
581 };
582 
584  .name = "libvpx",
585  .type = AVMEDIA_TYPE_VIDEO,
586  .id = AV_CODEC_ID_VP8,
587  .priv_data_size = sizeof(VP8Context),
588  .init = vp8_init,
589  .encode2 = vp8_encode,
590  .close = vp8_free,
591  .capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
592  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
593  .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
594  .priv_class = &class,
595  .defaults = defaults,
596 };
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:61
int size
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
unsigned long deadline
Definition: libvpxenc.c:58
AVOption.
Definition: opt.h:233
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
#define OFFSET(x)
Definition: libvpxenc.c:538
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2376
int num
numerator
Definition: rational.h:44
int size
Definition: avcodec.h:916
struct FrameListData * coded_frame_list
Definition: libvpxenc.c:59
size_t sz
length of compressed data
Definition: libvpxenc.c:44
AVCodec ff_libvpx_encoder
Definition: libvpxenc.c:583
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2510
int profile
profile
Definition: avcodec.h:2815
AVCodec.
Definition: avcodec.h:2960
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1465
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:151
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:38
static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src)
Definition: libvpxenc.c:365
uint8_t
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
Definition: libvpxenc.c:184
int64_t pts
time stamp to show frame (in timebase units)
Definition: libvpxenc.c:45
AVOptions.
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
Definition: libvpxenc.c:157
int64_t pts
presentation timestamp in time_base units (time when frame should be shown to user) If AV_NOPTS_VALUE...
Definition: avcodec.h:1088
struct vpx_image rawimg
Definition: libvpxenc.c:56
uint8_t * data
Definition: avcodec.h:915
static int flags
Definition: log.c:42
int mb_threshold
Macroblock threshold below which the user specified macroblock types will be used.
Definition: avcodec.h:1944
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2502
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
int frame_skip_threshold
frame skip threshold
Definition: avcodec.h:2416
int qmax
maximum quantizer
Definition: avcodec.h:2292
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:54
static const AVOption options[]
Definition: libvpxenc.c:540
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2339
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
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:921
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2317
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
Definition: utils.c:616
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
Definition: libvpxenc.c:102
int bit_rate
the average bitrate
Definition: avcodec.h:1404
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1065
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes.
Definition: base64.h:59
int width
picture width / height.
Definition: avcodec.h:1508
static av_cold int vp8_free(AVCodecContext *avctx)
Definition: libvpxenc.c:205
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:878
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1474
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
Definition: libvpxenc.c:91
LIBAVUTIL_VERSION_INT
Definition: eval.c:52
struct vpx_fixed_buf twopass_stats
Definition: libvpxenc.c:57
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2733
struct FrameListData * next
Definition: libvpxenc.c:50
NULL
Definition: eval.c:52
static const AVCodecDefault defaults[]
Definition: libvpxenc.c:575
static int width
Definition: utils.c:156
#define VE
Definition: libvpxenc.c:539
external API header
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
av_default_item_name
Definition: dnxhdenc.c:43
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
int qmin
minimum quantizer
Definition: avcodec.h:2285
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt, AVFrame *coded_frame)
Store coded frame information in format suitable for return from encode2().
Definition: libvpxenc.c:382
Describe the class of an AVClass context structure.
Definition: log.h:33
uint32_t flags
flags for this frame
Definition: libvpxenc.c:49
static av_cold int vp8_init(AVCodecContext *avctx)
Definition: libvpxenc.c:217
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
Definition: libvpxenc.c:167
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
Definition: avcodec.h:2277
static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libvpxenc.c:491
void * buf
compressed data buffer
Definition: libvpxenc.c:43
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
uint8_t level
Definition: svq3.c:125
struct vpx_codec_ctx encoder
Definition: libvpxenc.c:55
int noise_reduction
noise reduction strength
Definition: avcodec.h:1914
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1524
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
Definition: libvpxenc.c:71
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
common internal api header.
common internal and external API header
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:116
int den
denominator
Definition: rational.h:45
static av_cold void free_frame_list(struct FrameListData *list)
Definition: libvpxenc.c:173
int slices
Number of slices.
Definition: avcodec.h:2095
void * priv_data
Definition: avcodec.h:1382
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
Definition: libvpxenc.c:42
#define av_log2
Definition: intmath.h:85
struct VP8EncoderContext VP8Context
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1058
unsigned long duration
duration to show frame (in timebase units)
Definition: libvpxenc.c:47
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:914
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out, AVFrame *coded_frame)
Queue multiple output frames from the encoder, returning the front-most.
Definition: libvpxenc.c:413
int rc_min_rate
minimum bitrate
Definition: avcodec.h:2346
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:898
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:908
Predicted.
Definition: avutil.h:246
int keyint_min
minimum GOP size
Definition: avcodec.h:2015