git.sesse.net Git - ffmpeg/blob - libavcodec/libvpxenc.c

   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 encoder support via libvpx
  24  */
  25
  26 #define VPX_DISABLE_CTRL_TYPECHECKS 1
  27 #define VPX_CODEC_DISABLE_COMPAT    1
  28 #include <vpx/vpx_encoder.h>
  29 #include <vpx/vp8cx.h>
  30
  31 #include "avcodec.h"
  32 #include "libavutil/base64.h"
  33 #include "libavutil/opt.h"
  34 #include "libavutil/mathematics.h"
  35
  36 /**
  37  * Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
  38  * One encoded frame returned from the library.
  39  */
  40 struct FrameListData {
  41     void *buf;                       /**< compressed data buffer */
  42     size_t sz;                       /**< length of compressed data */
  43     int64_t pts;                     /**< time stamp to show frame
  44                                           (in timebase units) */
  45     unsigned long duration;          /**< duration to show frame
  46                                           (in timebase units) */
  47     uint32_t flags;                  /**< flags for this frame */
  48     struct FrameListData *next;
  49 };
  50
  51 typedef struct VP8EncoderContext {
  52     AVClass *av_class;
  53     struct vpx_codec_ctx encoder;
  54     struct vpx_image rawimg;
  55     struct vpx_fixed_buf twopass_stats;
  56     int deadline; //i.e., RT/GOOD/BEST
  57     struct FrameListData *coded_frame_list;
  58
  59     int cpuused;
  60
  61     /**
  62      * VP8 specific flags, see VP8F_* below.
  63      */
  64     int flags;
  65 #define VP8F_ERROR_RESILIENT 0x00000001 ///< Enable measures appropriate for streaming over lossy links
  66 #define VP8F_AUTO_ALT_REF    0x00000002 ///< Enable automatic alternate reference frame generation
  67
  68     int arnr_max_frames;
  69     int arnr_strength;
  70     int arnr_type;
  71
  72     int rc_lookahead;
  73     int crf;
  74 } VP8Context;
  75
  76 #define V AV_OPT_FLAG_VIDEO_PARAM
  77 #define E AV_OPT_FLAG_ENCODING_PARAM
  78
  79 static const AVOption options[]={
  80 {"speed", "", offsetof(VP8Context, cpuused), FF_OPT_TYPE_INT, {.dbl = 3}, -16, 16, V|E},
  81 {"quality", "", offsetof(VP8Context, deadline), FF_OPT_TYPE_INT, {.dbl = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, V|E, "quality"},
  82 {"best", NULL, 0, FF_OPT_TYPE_CONST, {.dbl = VPX_DL_BEST_QUALITY}, INT_MIN, INT_MAX, V|E, "quality"},
  83 {"good", NULL, 0, FF_OPT_TYPE_CONST, {.dbl = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, V|E, "quality"},
  84 {"realtime", NULL, 0, FF_OPT_TYPE_CONST, {.dbl = VPX_DL_REALTIME}, INT_MIN, INT_MAX, V|E, "quality"},
  85 {"vp8flags", "", offsetof(VP8Context, flags), FF_OPT_TYPE_FLAGS, {.dbl = 0}, 0, UINT_MAX, V|E, "flags"},
  86 {"error_resilient", "enable error resilience", 0, FF_OPT_TYPE_CONST, {.dbl = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, V|E, "flags"},
  87 {"altref", "enable use of alternate reference frames (VP8/2-pass only)", 0, FF_OPT_TYPE_CONST, {.dbl = VP8F_AUTO_ALT_REF}, INT_MIN, INT_MAX, V|E, "flags"},
  88 {"arnr_max_frames", "altref noise reduction max frame count", offsetof(VP8Context, arnr_max_frames), FF_OPT_TYPE_INT, {.dbl = 0}, 0, 15, V|E},
  89 {"arnr_strength", "altref noise reduction filter strength", offsetof(VP8Context, arnr_strength), FF_OPT_TYPE_INT, {.dbl = 3}, 0, 6, V|E},
  90 {"arnr_type", "altref noise reduction filter type", offsetof(VP8Context, arnr_type), FF_OPT_TYPE_INT, {.dbl = 3}, 1, 3, V|E},
  91 #if FF_API_X264_GLOBAL_OPTS
  92 {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VP8Context, rc_lookahead), FF_OPT_TYPE_INT, {.dbl = -1}, -1, 25, V|E},
  93 {"crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), FF_OPT_TYPE_INT, {.dbl = -1}, -1, 63, V|E},
  94 #else
  95 {"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VP8Context, rc_lookahead), FF_OPT_TYPE_INT, {.dbl = 25}, 0, 25, V|E},
  96 {"crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), FF_OPT_TYPE_INT, {.dbl = 0}, 0, 63, V|E},
  97 #endif
  98 {NULL}
  99 };
 100 static const AVClass class = { "libvpx", av_default_item_name, options, LIBAVUTIL_VERSION_INT };
 101
 102 #undef V
 103 #undef E
 104
 105 /** String mappings for enum vp8e_enc_control_id */
 106 static const char *ctlidstr[] = {
 107     [VP8E_UPD_ENTROPY]           = "VP8E_UPD_ENTROPY",
 108     [VP8E_UPD_REFERENCE]         = "VP8E_UPD_REFERENCE",
 109     [VP8E_USE_REFERENCE]         = "VP8E_USE_REFERENCE",
 110     [VP8E_SET_ROI_MAP]           = "VP8E_SET_ROI_MAP",
 111     [VP8E_SET_ACTIVEMAP]         = "VP8E_SET_ACTIVEMAP",
 112     [VP8E_SET_SCALEMODE]         = "VP8E_SET_SCALEMODE",
 113     [VP8E_SET_CPUUSED]           = "VP8E_SET_CPUUSED",
 114     [VP8E_SET_ENABLEAUTOALTREF]  = "VP8E_SET_ENABLEAUTOALTREF",
 115     [VP8E_SET_NOISE_SENSITIVITY] = "VP8E_SET_NOISE_SENSITIVITY",
 116     [VP8E_SET_SHARPNESS]         = "VP8E_SET_SHARPNESS",
 117     [VP8E_SET_STATIC_THRESHOLD]  = "VP8E_SET_STATIC_THRESHOLD",
 118     [VP8E_SET_TOKEN_PARTITIONS]  = "VP8E_SET_TOKEN_PARTITIONS",
 119     [VP8E_GET_LAST_QUANTIZER]    = "VP8E_GET_LAST_QUANTIZER",
 120     [VP8E_SET_ARNR_MAXFRAMES]    = "VP8E_SET_ARNR_MAXFRAMES",
 121     [VP8E_SET_ARNR_STRENGTH]     = "VP8E_SET_ARNR_STRENGTH",
 122     [VP8E_SET_ARNR_TYPE]         = "VP8E_SET_ARNR_TYPE",
 123     [VP8E_SET_CQ_LEVEL]          = "VP8E_SET_CQ_LEVEL",
 124 };
 125
 126 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
 127 {
 128     VP8Context *ctx = avctx->priv_data;
 129     const char *error  = vpx_codec_error(&ctx->encoder);
 130     const char *detail = vpx_codec_error_detail(&ctx->encoder);
 131
 132     av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
 133     if (detail)
 134         av_log(avctx, AV_LOG_ERROR, "  Additional information: %s\n", detail);
 135 }
 136
 137 static av_cold void dump_enc_cfg(AVCodecContext *avctx,
 138                                  const struct vpx_codec_enc_cfg *cfg)
 139 {
 140     int width = -30;
 141     int level = AV_LOG_DEBUG;
 142
 143     av_log(avctx, level, "vpx_codec_enc_cfg\n");
 144     av_log(avctx, level, "generic settings\n"
 145            "  %*s%u\n  %*s%u\n  %*s%u\n  %*s%u\n  %*s%u\n"
 146            "  %*s{%u/%u}\n  %*s%u\n  %*s%d\n  %*s%u\n",
 147            width, "g_usage:",           cfg->g_usage,
 148            width, "g_threads:",         cfg->g_threads,
 149            width, "g_profile:",         cfg->g_profile,
 150            width, "g_w:",               cfg->g_w,
 151            width, "g_h:",               cfg->g_h,
 152            width, "g_timebase:",        cfg->g_timebase.num, cfg->g_timebase.den,
 153            width, "g_error_resilient:", cfg->g_error_resilient,
 154            width, "g_pass:",            cfg->g_pass,
 155            width, "g_lag_in_frames:",   cfg->g_lag_in_frames);
 156     av_log(avctx, level, "rate control settings\n"
 157            "  %*s%u\n  %*s%u\n  %*s%u\n  %*s%u\n"
 158            "  %*s%d\n  %*s%p(%zu)\n  %*s%u\n",
 159            width, "rc_dropframe_thresh:",   cfg->rc_dropframe_thresh,
 160            width, "rc_resize_allowed:",     cfg->rc_resize_allowed,
 161            width, "rc_resize_up_thresh:",   cfg->rc_resize_up_thresh,
 162            width, "rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
 163            width, "rc_end_usage:",          cfg->rc_end_usage,
 164            width, "rc_twopass_stats_in:",   cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
 165            width, "rc_target_bitrate:",     cfg->rc_target_bitrate);
 166     av_log(avctx, level, "quantizer settings\n"
 167            "  %*s%u\n  %*s%u\n",
 168            width, "rc_min_quantizer:", cfg->rc_min_quantizer,
 169            width, "rc_max_quantizer:", cfg->rc_max_quantizer);
 170     av_log(avctx, level, "bitrate tolerance\n"
 171            "  %*s%u\n  %*s%u\n",
 172            width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
 173            width, "rc_overshoot_pct:",  cfg->rc_overshoot_pct);
 174     av_log(avctx, level, "decoder buffer model\n"
 175             "  %*s%u\n  %*s%u\n  %*s%u\n",
 176             width, "rc_buf_sz:",         cfg->rc_buf_sz,
 177             width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
 178             width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
 179     av_log(avctx, level, "2 pass rate control settings\n"
 180            "  %*s%u\n  %*s%u\n  %*s%u\n",
 181            width, "rc_2pass_vbr_bias_pct:",       cfg->rc_2pass_vbr_bias_pct,
 182            width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
 183            width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
 184     av_log(avctx, level, "keyframing settings\n"
 185            "  %*s%d\n  %*s%u\n  %*s%u\n",
 186            width, "kf_mode:",     cfg->kf_mode,
 187            width, "kf_min_dist:", cfg->kf_min_dist,
 188            width, "kf_max_dist:", cfg->kf_max_dist);
 189     av_log(avctx, level, "\n");
 190 }
 191
 192 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
 193 {
 194     struct FrameListData **p = list;
 195
 196     while (*p != NULL)
 197         p = &(*p)->next;
 198     *p = cx_frame;
 199     cx_frame->next = NULL;
 200 }
 201
 202 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
 203 {
 204     av_freep(&cx_frame->buf);
 205     av_freep(&cx_frame);
 206 }
 207
 208 static av_cold void free_frame_list(struct FrameListData *list)
 209 {
 210     struct FrameListData *p = list;
 211
 212     while (p) {
 213         list = list->next;
 214         free_coded_frame(p);
 215         p = list;
 216     }
 217 }
 218
 219 static av_cold int codecctl_int(AVCodecContext *avctx,
 220                                 enum vp8e_enc_control_id id, int val)
 221 {
 222     VP8Context *ctx = avctx->priv_data;
 223     char buf[80];
 224     int width = -30;
 225     int res;
 226
 227     snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
 228     av_log(avctx, AV_LOG_DEBUG, "  %*s%d\n", width, buf, val);
 229
 230     res = vpx_codec_control(&ctx->encoder, id, val);
 231     if (res != VPX_CODEC_OK) {
 232         snprintf(buf, sizeof(buf), "Failed to set %s codec control",
 233                  ctlidstr[id]);
 234         log_encoder_error(avctx, buf);
 235     }
 236
 237     return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
 238 }
 239
 240 static av_cold int vp8_free(AVCodecContext *avctx)
 241 {
 242     VP8Context *ctx = avctx->priv_data;
 243
 244     vpx_codec_destroy(&ctx->encoder);
 245     av_freep(&ctx->twopass_stats.buf);
 246     av_freep(&avctx->coded_frame);
 247     av_freep(&avctx->stats_out);
 248     free_frame_list(ctx->coded_frame_list);
 249     return 0;
 250 }
 251
 252 static av_cold int vp8_init(AVCodecContext *avctx)
 253 {
 254     VP8Context *ctx = avctx->priv_data;
 255     const struct vpx_codec_iface *iface = &vpx_codec_vp8_cx_algo;
 256     struct vpx_codec_enc_cfg enccfg;
 257     int res;
 258
 259     av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str());
 260     av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config());
 261
 262     if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
 263         av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
 264                vpx_codec_err_to_string(res));
 265         return AVERROR(EINVAL);
 266     }
 267     dump_enc_cfg(avctx, &enccfg);
 268
 269     enccfg.g_w            = avctx->width;
 270     enccfg.g_h            = avctx->height;
 271     enccfg.g_timebase.num = avctx->time_base.num;
 272     enccfg.g_timebase.den = avctx->time_base.den;
 273     enccfg.g_threads      = avctx->thread_count;
 274 #if FF_API_X264_GLOBAL_OPTS
 275     enccfg.g_lag_in_frames= FFMIN(avctx->rc_lookahead, 25);  //0-25, avoids init failure
 276     if (ctx->rc_lookahead >= 0)
 277         enccfg.g_lag_in_frames= ctx->rc_lookahead;
 278 #else
 279     enccfg.g_lag_in_frames= ctx->rc_lookahead;
 280 #endif
 281
 282     if (avctx->flags & CODEC_FLAG_PASS1)
 283         enccfg.g_pass = VPX_RC_FIRST_PASS;
 284     else if (avctx->flags & CODEC_FLAG_PASS2)
 285         enccfg.g_pass = VPX_RC_LAST_PASS;
 286     else
 287         enccfg.g_pass = VPX_RC_ONE_PASS;
 288
 289     if (avctx->rc_min_rate == avctx->rc_max_rate &&
 290         avctx->rc_min_rate == avctx->bit_rate)
 291         enccfg.rc_end_usage = VPX_CBR;
 292 #if FF_API_X264_GLOBAL_OPTS
 293     else if (avctx->crf || ctx->crf > 0)
 294 #else
 295     else if (ctx->crf)
 296 #endif
 297         enccfg.rc_end_usage = VPX_CQ;
 298     enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
 299                                               AV_ROUND_NEAR_INF);
 300
 301     enccfg.rc_min_quantizer = avctx->qmin;
 302     enccfg.rc_max_quantizer = avctx->qmax;
 303     enccfg.rc_dropframe_thresh = avctx->frame_skip_threshold;
 304
 305     //0-100 (0 => CBR, 100 => VBR)
 306     enccfg.rc_2pass_vbr_bias_pct           = round(avctx->qcompress * 100);
 307     enccfg.rc_2pass_vbr_minsection_pct     =
 308         avctx->rc_min_rate * 100LL / avctx->bit_rate;
 309     if (avctx->rc_max_rate)
 310         enccfg.rc_2pass_vbr_maxsection_pct =
 311             avctx->rc_max_rate * 100LL / avctx->bit_rate;
 312
 313     if (avctx->rc_buffer_size)
 314         enccfg.rc_buf_sz         =
 315             avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
 316     if (avctx->rc_initial_buffer_occupancy)
 317         enccfg.rc_buf_initial_sz =
 318             avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
 319     enccfg.rc_buf_optimal_sz     = enccfg.rc_buf_sz * 5 / 6;
 320     enccfg.rc_undershoot_pct     = round(avctx->rc_buffer_aggressivity * 100);
 321
 322     //_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO
 323     if (avctx->keyint_min == avctx->gop_size)
 324         enccfg.kf_min_dist = avctx->keyint_min;
 325     enccfg.kf_max_dist     = avctx->gop_size;
 326
 327     if (enccfg.g_pass == VPX_RC_FIRST_PASS)
 328         enccfg.g_lag_in_frames = 0;
 329     else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
 330         int decode_size;
 331
 332         if (!avctx->stats_in) {
 333             av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
 334             return AVERROR_INVALIDDATA;
 335         }
 336
 337         ctx->twopass_stats.sz  = strlen(avctx->stats_in) * 3 / 4;
 338         ctx->twopass_stats.buf = av_malloc(ctx->twopass_stats.sz);
 339         if (!ctx->twopass_stats.buf) {
 340             av_log(avctx, AV_LOG_ERROR,
 341                    "Stat buffer alloc (%zu bytes) failed\n",
 342                    ctx->twopass_stats.sz);
 343             return AVERROR(ENOMEM);
 344         }
 345         decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
 346                                        ctx->twopass_stats.sz);
 347         if (decode_size < 0) {
 348             av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
 349             return AVERROR_INVALIDDATA;
 350         }
 351
 352         ctx->twopass_stats.sz      = decode_size;
 353         enccfg.rc_twopass_stats_in = ctx->twopass_stats;
 354     }
 355
 356     /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
 357        complexity playback on low powered devices at the expense of encode
 358        quality. */
 359    if (avctx->profile != FF_PROFILE_UNKNOWN)
 360        enccfg.g_profile = avctx->profile;
 361
 362     enccfg.g_error_resilient = ctx->flags & VP8F_ERROR_RESILIENT;
 363
 364     dump_enc_cfg(avctx, &enccfg);
 365     /* Construct Encoder Context */
 366     res = vpx_codec_enc_init(&ctx->encoder, iface, &enccfg, 0);
 367     if (res != VPX_CODEC_OK) {
 368         log_encoder_error(avctx, "Failed to initialize encoder");
 369         return AVERROR(EINVAL);
 370     }
 371
 372     //codec control failures are currently treated only as warnings
 373     av_log(avctx, AV_LOG_DEBUG, "vpx_codec_control\n");
 374     codecctl_int(avctx, VP8E_SET_CPUUSED,           ctx->cpuused);
 375     codecctl_int(avctx, VP8E_SET_NOISE_SENSITIVITY, avctx->noise_reduction);
 376     codecctl_int(avctx, VP8E_SET_TOKEN_PARTITIONS,  av_log2(avctx->slices));
 377     codecctl_int(avctx, VP8E_SET_STATIC_THRESHOLD,  avctx->mb_threshold);
 378 #if FF_API_X264_GLOBAL_OPTS
 379     codecctl_int(avctx, VP8E_SET_CQ_LEVEL,          (int)avctx->crf);
 380     if (ctx->crf >= 0)
 381         codecctl_int(avctx, VP8E_SET_CQ_LEVEL,      ctx->crf);
 382 #else
 383     codecctl_int(avctx, VP8E_SET_CQ_LEVEL,          ctx->crf);
 384 #endif
 385     codecctl_int(avctx, VP8E_SET_ENABLEAUTOALTREF,  !!(ctx->flags & VP8F_AUTO_ALT_REF));
 386     codecctl_int(avctx, VP8E_SET_ARNR_MAXFRAMES,    ctx->arnr_max_frames);
 387     codecctl_int(avctx, VP8E_SET_ARNR_STRENGTH,     ctx->arnr_strength);
 388     codecctl_int(avctx, VP8E_SET_ARNR_TYPE,         ctx->arnr_type);
 389
 390     av_log(avctx, AV_LOG_DEBUG, "Using deadline: %d\n", ctx->deadline);
 391
 392     //provide dummy value to initialize wrapper, values will be updated each _encode()
 393     vpx_img_wrap(&ctx->rawimg, VPX_IMG_FMT_I420, avctx->width, avctx->height, 1,
 394                  (unsigned char*)1);
 395
 396     avctx->coded_frame = avcodec_alloc_frame();
 397     if (!avctx->coded_frame) {
 398         av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");
 399         vp8_free(avctx);
 400         return AVERROR(ENOMEM);
 401     }
 402     return 0;
 403 }
 404
 405 static inline void cx_pktcpy(struct FrameListData *dst,
 406                              const struct vpx_codec_cx_pkt *src)
 407 {
 408     dst->pts      = src->data.frame.pts;
 409     dst->duration = src->data.frame.duration;
 410     dst->flags    = src->data.frame.flags;
 411     dst->sz       = src->data.frame.sz;
 412     dst->buf      = src->data.frame.buf;
 413 }
 414
 415 /**
 416  * Store coded frame information in format suitable for return from encode().
 417  *
 418  * Write buffer information from @a cx_frame to @a buf & @a buf_size.
 419  * Timing/frame details to @a coded_frame.
 420  * @return Frame size written to @a buf on success
 421  * @return AVERROR(EINVAL) on error
 422  */
 423 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
 424                       uint8_t *buf, int buf_size, AVFrame *coded_frame)
 425 {
 426     if ((int) cx_frame->sz <= buf_size) {
 427         buf_size = cx_frame->sz;
 428         memcpy(buf, cx_frame->buf, buf_size);
 429         coded_frame->pts       = cx_frame->pts;
 430         coded_frame->key_frame = !!(cx_frame->flags & VPX_FRAME_IS_KEY);
 431
 432         if (coded_frame->key_frame)
 433             coded_frame->pict_type = AV_PICTURE_TYPE_I;
 434         else
 435             coded_frame->pict_type = AV_PICTURE_TYPE_P;
 436     } else {
 437         av_log(avctx, AV_LOG_ERROR,
 438                "Compressed frame larger than storage provided! (%zu/%d)\n",
 439                cx_frame->sz, buf_size);
 440         return AVERROR(EINVAL);
 441     }
 442     return buf_size;
 443 }
 444
 445 /**
 446  * Queue multiple output frames from the encoder, returning the front-most.
 447  * In cases where vpx_codec_get_cx_data() returns more than 1 frame append
 448  * the frame queue. Return the head frame if available.
 449  * @return Stored frame size
 450  * @return AVERROR(EINVAL) on output size error
 451  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
 452  */
 453 static int queue_frames(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 454                         AVFrame *coded_frame)
 455 {
 456     VP8Context *ctx = avctx->priv_data;
 457     const struct vpx_codec_cx_pkt *pkt;
 458     const void *iter = NULL;
 459     int size = 0;
 460
 461     if (ctx->coded_frame_list) {
 462         struct FrameListData *cx_frame = ctx->coded_frame_list;
 463         /* return the leading frame if we've already begun queueing */
 464         size = storeframe(avctx, cx_frame, buf, buf_size, coded_frame);
 465         if (size < 0)
 466             return AVERROR(EINVAL);
 467         ctx->coded_frame_list = cx_frame->next;
 468         free_coded_frame(cx_frame);
 469     }
 470
 471     /* consume all available output from the encoder before returning. buffers
 472        are only good through the next vpx_codec call */
 473     while ((pkt = vpx_codec_get_cx_data(&ctx->encoder, &iter))) {
 474         switch (pkt->kind) {
 475         case VPX_CODEC_CX_FRAME_PKT:
 476             if (!size) {
 477                 struct FrameListData cx_frame;
 478
 479                 /* avoid storing the frame when the list is empty and we haven't yet
 480                    provided a frame for output */
 481                 assert(!ctx->coded_frame_list);
 482                 cx_pktcpy(&cx_frame, pkt);
 483                 size = storeframe(avctx, &cx_frame, buf, buf_size, coded_frame);
 484                 if (size < 0)
 485                     return AVERROR(EINVAL);
 486             } else {
 487                 struct FrameListData *cx_frame =
 488                     av_malloc(sizeof(struct FrameListData));
 489
 490                 if (!cx_frame) {
 491                     av_log(avctx, AV_LOG_ERROR,
 492                            "Frame queue element alloc failed\n");
 493                     return AVERROR(ENOMEM);
 494                 }
 495                 cx_pktcpy(cx_frame, pkt);
 496                 cx_frame->buf = av_malloc(cx_frame->sz);
 497
 498                 if (!cx_frame->buf) {
 499                     av_log(avctx, AV_LOG_ERROR,
 500                            "Data buffer alloc (%zu bytes) failed\n",
 501                            cx_frame->sz);
 502                     return AVERROR(ENOMEM);
 503                 }
 504                 memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
 505                 coded_frame_add(&ctx->coded_frame_list, cx_frame);
 506             }
 507             break;
 508         case VPX_CODEC_STATS_PKT: {
 509             struct vpx_fixed_buf *stats = &ctx->twopass_stats;
 510             stats->buf = av_realloc(stats->buf,
 511                                     stats->sz + pkt->data.twopass_stats.sz);
 512             if (!stats->buf) {
 513                 av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
 514                 return AVERROR(ENOMEM);
 515             }
 516             memcpy((uint8_t*)stats->buf + stats->sz,
 517                    pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
 518             stats->sz += pkt->data.twopass_stats.sz;
 519             break;
 520         }
 521         case VPX_CODEC_PSNR_PKT: //FIXME add support for CODEC_FLAG_PSNR
 522         case VPX_CODEC_CUSTOM_PKT:
 523             //ignore unsupported/unrecognized packet types
 524             break;
 525         }
 526     }
 527
 528     return size;
 529 }
 530
 531 static int vp8_encode(AVCodecContext *avctx, uint8_t *buf, int buf_size,
 532                       void *data)
 533 {
 534     VP8Context *ctx = avctx->priv_data;
 535     AVFrame *frame = data;
 536     struct vpx_image *rawimg = NULL;
 537     int64_t timestamp = 0;
 538     int res, coded_size;
 539
 540     if (frame) {
 541         rawimg                      = &ctx->rawimg;
 542         rawimg->planes[VPX_PLANE_Y] = frame->data[0];
 543         rawimg->planes[VPX_PLANE_U] = frame->data[1];
 544         rawimg->planes[VPX_PLANE_V] = frame->data[2];
 545         rawimg->stride[VPX_PLANE_Y] = frame->linesize[0];
 546         rawimg->stride[VPX_PLANE_U] = frame->linesize[1];
 547         rawimg->stride[VPX_PLANE_V] = frame->linesize[2];
 548         timestamp                   = frame->pts;
 549     }
 550
 551     res = vpx_codec_encode(&ctx->encoder, rawimg, timestamp,
 552                            avctx->ticks_per_frame, 0, ctx->deadline);
 553     if (res != VPX_CODEC_OK) {
 554         log_encoder_error(avctx, "Error encoding frame");
 555         return AVERROR_INVALIDDATA;
 556     }
 557     coded_size = queue_frames(avctx, buf, buf_size, avctx->coded_frame);
 558
 559     if (!frame && avctx->flags & CODEC_FLAG_PASS1) {
 560         unsigned int b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
 561
 562         avctx->stats_out = av_malloc(b64_size);
 563         if (!avctx->stats_out) {
 564             av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%d bytes) failed\n",
 565                    b64_size);
 566             return AVERROR(ENOMEM);
 567         }
 568         av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
 569                          ctx->twopass_stats.sz);
 570     }
 571     return coded_size;
 572 }
 573
 574 AVCodec ff_libvpx_encoder = {
 575     .name           = "libvpx",
 576     .type           = AVMEDIA_TYPE_VIDEO,
 577     .id             = CODEC_ID_VP8,
 578     .priv_data_size = sizeof(VP8Context),
 579     .init           = vp8_init,
 580     .encode         = vp8_encode,
 581     .close          = vp8_free,
 582     .capabilities   = CODEC_CAP_DELAY,
 583     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
 584     .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
 585     .priv_class= &class,
 586 };