git.sesse.net Git - ffmpeg/blob - libavcodec/libaomenc.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  * AV1 encoder support via libaom
  24  */
  25
  26 #define AOM_DISABLE_CTRL_TYPECHECKS 1
  27 #include <aom/aom_encoder.h>
  28 #include <aom/aomcx.h>
  29
  30 #include "libavutil/avassert.h"
  31 #include "libavutil/base64.h"
  32 #include "libavutil/common.h"
  33 #include "libavutil/mathematics.h"
  34 #include "libavutil/opt.h"
  35 #include "libavutil/pixdesc.h"
  36
  37 #include "avcodec.h"
  38 #include "internal.h"
  39 #include "profiles.h"
  40
  41 /*
  42  * Portion of struct aom_codec_cx_pkt from aom_encoder.h.
  43  * One encoded frame returned from the library.
  44  */
  45 struct FrameListData {
  46     void *buf;                       /**< compressed data buffer */
  47     size_t sz;                       /**< length of compressed data */
  48     int64_t pts;                     /**< time stamp to show frame
  49                                           (in timebase units) */
  50     unsigned long duration;          /**< duration to show frame
  51                                           (in timebase units) */
  52     uint32_t flags;                  /**< flags for this frame */
  53     struct FrameListData *next;
  54 };
  55
  56 typedef struct AOMEncoderContext {
  57     AVClass *class;
  58     struct aom_codec_ctx encoder;
  59     struct aom_image rawimg;
  60     struct aom_fixed_buf twopass_stats;
  61     struct FrameListData *coded_frame_list;
  62     int cpu_used;
  63     int auto_alt_ref;
  64     int lag_in_frames;
  65     int error_resilient;
  66     int crf;
  67     int static_thresh;
  68     int drop_threshold;
  69     int noise_sensitivity;
  70 } AOMContext;
  71
  72 static const char *const ctlidstr[] = {
  73     [AOME_SET_CPUUSED]          = "AOME_SET_CPUUSED",
  74     [AOME_SET_CQ_LEVEL]         = "AOME_SET_CQ_LEVEL",
  75     [AOME_SET_ENABLEAUTOALTREF] = "AOME_SET_ENABLEAUTOALTREF",
  76     [AOME_SET_STATIC_THRESHOLD] = "AOME_SET_STATIC_THRESHOLD",
  77     [AV1E_SET_COLOR_RANGE]      = "AV1E_SET_COLOR_RANGE",
  78     [AV1E_SET_COLOR_PRIMARIES]  = "AV1E_SET_COLOR_PRIMARIES",
  79     [AV1E_SET_MATRIX_COEFFICIENTS] = "AV1E_SET_MATRIX_COEFFICIENTS",
  80     [AV1E_SET_TRANSFER_CHARACTERISTICS] = "AV1E_SET_TRANSFER_CHARACTERISTICS",
  81 };
  82
  83 static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
  84 {
  85     AOMContext *ctx    = avctx->priv_data;
  86     const char *error  = aom_codec_error(&ctx->encoder);
  87     const char *detail = aom_codec_error_detail(&ctx->encoder);
  88
  89     av_log(avctx, AV_LOG_ERROR, "%s: %s\n", desc, error);
  90     if (detail)
  91         av_log(avctx, AV_LOG_ERROR, "  Additional information: %s\n", detail);
  92 }
  93
  94 static av_cold void dump_enc_cfg(AVCodecContext *avctx,
  95                                  const struct aom_codec_enc_cfg *cfg)
  96 {
  97     int width = -30;
  98     int level = AV_LOG_DEBUG;
  99
 100     av_log(avctx, level, "aom_codec_enc_cfg\n");
 101     av_log(avctx, level, "generic settings\n"
 102                          "  %*s%u\n  %*s%u\n  %*s%u\n  %*s%u\n  %*s%u\n"
 103                          "  %*s%u\n  %*s%u\n"
 104                          "  %*s{%u/%u}\n  %*s%u\n  %*s%d\n  %*s%u\n",
 105            width, "g_usage:",           cfg->g_usage,
 106            width, "g_threads:",         cfg->g_threads,
 107            width, "g_profile:",         cfg->g_profile,
 108            width, "g_w:",               cfg->g_w,
 109            width, "g_h:",               cfg->g_h,
 110            width, "g_bit_depth:",       cfg->g_bit_depth,
 111            width, "g_input_bit_depth:", cfg->g_input_bit_depth,
 112            width, "g_timebase:",        cfg->g_timebase.num, cfg->g_timebase.den,
 113            width, "g_error_resilient:", cfg->g_error_resilient,
 114            width, "g_pass:",            cfg->g_pass,
 115            width, "g_lag_in_frames:",   cfg->g_lag_in_frames);
 116     av_log(avctx, level, "rate control settings\n"
 117                          "  %*s%u\n  %*s%d\n  %*s%p(%"SIZE_SPECIFIER")\n  %*s%u\n",
 118            width, "rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
 119            width, "rc_end_usage:",        cfg->rc_end_usage,
 120            width, "rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
 121            width, "rc_target_bitrate:",   cfg->rc_target_bitrate);
 122     av_log(avctx, level, "quantizer settings\n"
 123                          "  %*s%u\n  %*s%u\n",
 124            width, "rc_min_quantizer:", cfg->rc_min_quantizer,
 125            width, "rc_max_quantizer:", cfg->rc_max_quantizer);
 126     av_log(avctx, level, "bitrate tolerance\n"
 127                          "  %*s%u\n  %*s%u\n",
 128            width, "rc_undershoot_pct:", cfg->rc_undershoot_pct,
 129            width, "rc_overshoot_pct:",  cfg->rc_overshoot_pct);
 130     av_log(avctx, level, "decoder buffer model\n"
 131                          "  %*s%u\n  %*s%u\n  %*s%u\n",
 132            width, "rc_buf_sz:",         cfg->rc_buf_sz,
 133            width, "rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
 134            width, "rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
 135     av_log(avctx, level, "2 pass rate control settings\n"
 136                          "  %*s%u\n  %*s%u\n  %*s%u\n",
 137            width, "rc_2pass_vbr_bias_pct:",       cfg->rc_2pass_vbr_bias_pct,
 138            width, "rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
 139            width, "rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
 140     av_log(avctx, level, "keyframing settings\n"
 141                          "  %*s%d\n  %*s%u\n  %*s%u\n",
 142            width, "kf_mode:",     cfg->kf_mode,
 143            width, "kf_min_dist:", cfg->kf_min_dist,
 144            width, "kf_max_dist:", cfg->kf_max_dist);
 145     av_log(avctx, level, "\n");
 146 }
 147
 148 static void coded_frame_add(void *list, struct FrameListData *cx_frame)
 149 {
 150     struct FrameListData **p = list;
 151
 152     while (*p)
 153         p = &(*p)->next;
 154     *p = cx_frame;
 155     cx_frame->next = NULL;
 156 }
 157
 158 static av_cold void free_coded_frame(struct FrameListData *cx_frame)
 159 {
 160     av_freep(&cx_frame->buf);
 161     av_freep(&cx_frame);
 162 }
 163
 164 static av_cold void free_frame_list(struct FrameListData *list)
 165 {
 166     struct FrameListData *p = list;
 167
 168     while (p) {
 169         list = list->next;
 170         free_coded_frame(p);
 171         p = list;
 172     }
 173 }
 174
 175 static av_cold int codecctl_int(AVCodecContext *avctx,
 176                                 enum aome_enc_control_id id, int val)
 177 {
 178     AOMContext *ctx = avctx->priv_data;
 179     char buf[80];
 180     int width = -30;
 181     int res;
 182
 183     snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
 184     av_log(avctx, AV_LOG_DEBUG, "  %*s%d\n", width, buf, val);
 185
 186     res = aom_codec_control(&ctx->encoder, id, val);
 187     if (res != AOM_CODEC_OK) {
 188         snprintf(buf, sizeof(buf), "Failed to set %s codec control",
 189                  ctlidstr[id]);
 190         log_encoder_error(avctx, buf);
 191         return AVERROR(EINVAL);
 192     }
 193
 194     return 0;
 195 }
 196
 197 static av_cold int aom_free(AVCodecContext *avctx)
 198 {
 199     AOMContext *ctx = avctx->priv_data;
 200
 201     aom_codec_destroy(&ctx->encoder);
 202     av_freep(&ctx->twopass_stats.buf);
 203     av_freep(&avctx->stats_out);
 204     free_frame_list(ctx->coded_frame_list);
 205     return 0;
 206 }
 207
 208 static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
 209                        struct aom_codec_enc_cfg *enccfg, aom_codec_flags_t *flags,
 210                        aom_img_fmt_t *img_fmt)
 211 {
 212     AOMContext av_unused *ctx = avctx->priv_data;
 213     enccfg->g_bit_depth = enccfg->g_input_bit_depth = 8;
 214     switch (avctx->pix_fmt) {
 215     case AV_PIX_FMT_YUV420P:
 216         enccfg->g_profile = FF_PROFILE_AV1_MAIN;
 217         *img_fmt = AOM_IMG_FMT_I420;
 218         return 0;
 219     case AV_PIX_FMT_YUV422P:
 220         enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
 221         *img_fmt = AOM_IMG_FMT_I422;
 222         return 0;
 223     case AV_PIX_FMT_YUV444P:
 224         enccfg->g_profile = FF_PROFILE_AV1_HIGH;
 225         *img_fmt = AOM_IMG_FMT_I444;
 226         return 0;
 227     case AV_PIX_FMT_YUV420P10:
 228     case AV_PIX_FMT_YUV420P12:
 229         if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
 230             enccfg->g_bit_depth = enccfg->g_input_bit_depth =
 231                 avctx->pix_fmt == AV_PIX_FMT_YUV420P10 ? 10 : 12;
 232             enccfg->g_profile =
 233                 enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
 234             *img_fmt = AOM_IMG_FMT_I42016;
 235             *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
 236             return 0;
 237         }
 238         break;
 239     case AV_PIX_FMT_YUV422P10:
 240     case AV_PIX_FMT_YUV422P12:
 241         if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
 242             enccfg->g_bit_depth = enccfg->g_input_bit_depth =
 243                 avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12;
 244             enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
 245             *img_fmt = AOM_IMG_FMT_I42216;
 246             *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
 247             return 0;
 248         }
 249         break;
 250     case AV_PIX_FMT_YUV444P10:
 251     case AV_PIX_FMT_YUV444P12:
 252         if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
 253             enccfg->g_bit_depth = enccfg->g_input_bit_depth =
 254                 avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ? 10 : 12;
 255             enccfg->g_profile =
 256                 enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
 257             *img_fmt = AOM_IMG_FMT_I44416;
 258             *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
 259             return 0;
 260         }
 261         break;
 262     default:
 263         break;
 264     }
 265     av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
 266     return AVERROR_INVALIDDATA;
 267 }
 268
 269 static void set_color_range(AVCodecContext *avctx)
 270 {
 271     enum aom_color_range aom_cr;
 272     switch (avctx->color_range) {
 273     case AVCOL_RANGE_UNSPECIFIED:
 274     case AVCOL_RANGE_MPEG:       aom_cr = AOM_CR_STUDIO_RANGE; break;
 275     case AVCOL_RANGE_JPEG:       aom_cr = AOM_CR_FULL_RANGE;   break;
 276     default:
 277         av_log(avctx, AV_LOG_WARNING, "Unsupported color range (%d)\n",
 278                avctx->color_range);
 279         return;
 280     }
 281
 282     codecctl_int(avctx, AV1E_SET_COLOR_RANGE, aom_cr);
 283 }
 284
 285 static av_cold int aom_init(AVCodecContext *avctx,
 286                             const struct aom_codec_iface *iface)
 287 {
 288     AOMContext *ctx = avctx->priv_data;
 289     struct aom_codec_enc_cfg enccfg = { 0 };
 290     aom_codec_flags_t flags = 0;
 291     AVCPBProperties *cpb_props;
 292     int res;
 293     aom_img_fmt_t img_fmt;
 294     aom_codec_caps_t codec_caps = aom_codec_get_caps(iface);
 295
 296     av_log(avctx, AV_LOG_INFO, "%s\n", aom_codec_version_str());
 297     av_log(avctx, AV_LOG_VERBOSE, "%s\n", aom_codec_build_config());
 298
 299     if ((res = aom_codec_enc_config_default(iface, &enccfg, 0)) != AOM_CODEC_OK) {
 300         av_log(avctx, AV_LOG_ERROR, "Failed to get config: %s\n",
 301                aom_codec_err_to_string(res));
 302         return AVERROR(EINVAL);
 303     }
 304
 305     if (set_pix_fmt(avctx, codec_caps, &enccfg, &flags, &img_fmt))
 306         return AVERROR(EINVAL);
 307
 308     if(!avctx->bit_rate)
 309         if(avctx->rc_max_rate || avctx->rc_buffer_size || avctx->rc_initial_buffer_occupancy) {
 310             av_log( avctx, AV_LOG_ERROR, "Rate control parameters set without a bitrate\n");
 311             return AVERROR(EINVAL);
 312         }
 313
 314     dump_enc_cfg(avctx, &enccfg);
 315
 316     enccfg.g_w            = avctx->width;
 317     enccfg.g_h            = avctx->height;
 318     enccfg.g_timebase.num = avctx->time_base.num;
 319     enccfg.g_timebase.den = avctx->time_base.den;
 320     enccfg.g_threads      = avctx->thread_count;
 321
 322     if (ctx->lag_in_frames >= 0)
 323         enccfg.g_lag_in_frames = ctx->lag_in_frames;
 324
 325     if (avctx->flags & AV_CODEC_FLAG_PASS1)
 326         enccfg.g_pass = AOM_RC_FIRST_PASS;
 327     else if (avctx->flags & AV_CODEC_FLAG_PASS2)
 328         enccfg.g_pass = AOM_RC_LAST_PASS;
 329     else
 330         enccfg.g_pass = AOM_RC_ONE_PASS;
 331
 332     if (avctx->rc_min_rate == avctx->rc_max_rate &&
 333         avctx->rc_min_rate == avctx->bit_rate && avctx->bit_rate) {
 334         enccfg.rc_end_usage = AOM_CBR;
 335     } else if (ctx->crf >= 0) {
 336         enccfg.rc_end_usage = AOM_CQ;
 337         if (!avctx->bit_rate)
 338             enccfg.rc_end_usage = AOM_Q;
 339     }
 340
 341     if (avctx->bit_rate) {
 342         enccfg.rc_target_bitrate = av_rescale_rnd(avctx->bit_rate, 1, 1000,
 343                                                   AV_ROUND_NEAR_INF);
 344     } else if (enccfg.rc_end_usage != AOM_Q) {
 345         if (enccfg.rc_end_usage == AOM_CQ) {
 346             enccfg.rc_target_bitrate = 1000000;
 347         } else {
 348             avctx->bit_rate = enccfg.rc_target_bitrate * 1000;
 349             av_log(avctx, AV_LOG_WARNING,
 350                    "Neither bitrate nor constrained quality specified, using default bitrate of %dkbit/sec\n",
 351                    enccfg.rc_target_bitrate);
 352         }
 353     }
 354
 355     if (avctx->qmin >= 0)
 356         enccfg.rc_min_quantizer = avctx->qmin;
 357     if (avctx->qmax >= 0)
 358         enccfg.rc_max_quantizer = avctx->qmax;
 359
 360     if (enccfg.rc_end_usage == AOM_CQ || enccfg.rc_end_usage == AOM_Q) {
 361         if (ctx->crf < enccfg.rc_min_quantizer || ctx->crf > enccfg.rc_max_quantizer) {
 362             av_log(avctx, AV_LOG_ERROR,
 363                    "CQ level %d must be between minimum and maximum quantizer value (%d-%d)\n",
 364                    ctx->crf, enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
 365             return AVERROR(EINVAL);
 366         }
 367     }
 368
 369     enccfg.rc_dropframe_thresh = ctx->drop_threshold;
 370
 371     // 0-100 (0 => CBR, 100 => VBR)
 372     enccfg.rc_2pass_vbr_bias_pct       = round(avctx->qcompress * 100);
 373     if (avctx->bit_rate)
 374         enccfg.rc_2pass_vbr_minsection_pct =
 375             avctx->rc_min_rate * 100LL / avctx->bit_rate;
 376     if (avctx->rc_max_rate)
 377         enccfg.rc_2pass_vbr_maxsection_pct =
 378             avctx->rc_max_rate * 100LL / avctx->bit_rate;
 379
 380     if (avctx->rc_buffer_size)
 381         enccfg.rc_buf_sz =
 382             avctx->rc_buffer_size * 1000LL / avctx->bit_rate;
 383     if (avctx->rc_initial_buffer_occupancy)
 384         enccfg.rc_buf_initial_sz =
 385             avctx->rc_initial_buffer_occupancy * 1000LL / avctx->bit_rate;
 386     enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
 387
 388     // _enc_init() will balk if kf_min_dist differs from max w/AOM_KF_AUTO
 389     if (avctx->keyint_min >= 0 && avctx->keyint_min == avctx->gop_size)
 390         enccfg.kf_min_dist = avctx->keyint_min;
 391     if (avctx->gop_size >= 0)
 392         enccfg.kf_max_dist = avctx->gop_size;
 393
 394     if (enccfg.g_pass == AOM_RC_FIRST_PASS)
 395         enccfg.g_lag_in_frames = 0;
 396     else if (enccfg.g_pass == AOM_RC_LAST_PASS) {
 397         int decode_size, ret;
 398
 399         if (!avctx->stats_in) {
 400             av_log(avctx, AV_LOG_ERROR, "No stats file for second pass\n");
 401             return AVERROR_INVALIDDATA;
 402         }
 403
 404         ctx->twopass_stats.sz = strlen(avctx->stats_in) * 3 / 4;
 405         ret                   = av_reallocp(&ctx->twopass_stats.buf, ctx->twopass_stats.sz);
 406         if (ret < 0) {
 407             av_log(avctx, AV_LOG_ERROR,
 408                    "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
 409                    ctx->twopass_stats.sz);
 410             ctx->twopass_stats.sz = 0;
 411             return ret;
 412         }
 413         decode_size = av_base64_decode(ctx->twopass_stats.buf, avctx->stats_in,
 414                                        ctx->twopass_stats.sz);
 415         if (decode_size < 0) {
 416             av_log(avctx, AV_LOG_ERROR, "Stat buffer decode failed\n");
 417             return AVERROR_INVALIDDATA;
 418         }
 419
 420         ctx->twopass_stats.sz      = decode_size;
 421         enccfg.rc_twopass_stats_in = ctx->twopass_stats;
 422     }
 423
 424     /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
 425      * complexity playback on low powered devices at the expense of encode
 426      * quality. */
 427     if (avctx->profile != FF_PROFILE_UNKNOWN)
 428         enccfg.g_profile = avctx->profile;
 429
 430     enccfg.g_error_resilient = ctx->error_resilient;
 431
 432     dump_enc_cfg(avctx, &enccfg);
 433     /* Construct Encoder Context */
 434     res = aom_codec_enc_init(&ctx->encoder, iface, &enccfg, flags);
 435     if (res != AOM_CODEC_OK) {
 436         log_encoder_error(avctx, "Failed to initialize encoder");
 437         return AVERROR(EINVAL);
 438     }
 439
 440     // codec control failures are currently treated only as warnings
 441     av_log(avctx, AV_LOG_DEBUG, "aom_codec_control\n");
 442     codecctl_int(avctx, AOME_SET_CPUUSED, ctx->cpu_used);
 443     if (ctx->auto_alt_ref >= 0)
 444         codecctl_int(avctx, AOME_SET_ENABLEAUTOALTREF, ctx->auto_alt_ref);
 445
 446     codecctl_int(avctx, AOME_SET_STATIC_THRESHOLD, ctx->static_thresh);
 447     if (ctx->crf >= 0)
 448         codecctl_int(avctx, AOME_SET_CQ_LEVEL,          ctx->crf);
 449
 450     codecctl_int(avctx, AV1E_SET_COLOR_PRIMARIES, avctx->color_primaries);
 451     codecctl_int(avctx, AV1E_SET_MATRIX_COEFFICIENTS, avctx->colorspace);
 452     codecctl_int(avctx, AV1E_SET_TRANSFER_CHARACTERISTICS, avctx->color_trc);
 453     set_color_range(avctx);
 454
 455     // provide dummy value to initialize wrapper, values will be updated each _encode()
 456     aom_img_wrap(&ctx->rawimg, img_fmt, avctx->width, avctx->height, 1,
 457                  (unsigned char*)1);
 458
 459     if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
 460         ctx->rawimg.bit_depth = enccfg.g_bit_depth;
 461
 462     cpb_props = ff_add_cpb_side_data(avctx);
 463     if (!cpb_props)
 464         return AVERROR(ENOMEM);
 465
 466     if (enccfg.rc_end_usage == AOM_CBR ||
 467         enccfg.g_pass != AOM_RC_ONE_PASS) {
 468         cpb_props->max_bitrate = avctx->rc_max_rate;
 469         cpb_props->min_bitrate = avctx->rc_min_rate;
 470         cpb_props->avg_bitrate = avctx->bit_rate;
 471     }
 472     cpb_props->buffer_size = avctx->rc_buffer_size;
 473
 474     return 0;
 475 }
 476
 477 static inline void cx_pktcpy(struct FrameListData *dst,
 478                              const struct aom_codec_cx_pkt *src)
 479 {
 480     dst->pts      = src->data.frame.pts;
 481     dst->duration = src->data.frame.duration;
 482     dst->flags    = src->data.frame.flags;
 483     dst->sz       = src->data.frame.sz;
 484     dst->buf      = src->data.frame.buf;
 485 }
 486
 487 /**
 488  * Store coded frame information in format suitable for return from encode2().
 489  *
 490  * Write information from @a cx_frame to @a pkt
 491  * @return packet data size on success
 492  * @return a negative AVERROR on error
 493  */
 494 static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame,
 495                       AVPacket *pkt)
 496 {
 497     int ret = ff_alloc_packet2(avctx, pkt, cx_frame->sz, 0);
 498     if (ret < 0) {
 499         av_log(avctx, AV_LOG_ERROR,
 500                "Error getting output packet of size %"SIZE_SPECIFIER".\n", cx_frame->sz);
 501         return ret;
 502     }
 503     memcpy(pkt->data, cx_frame->buf, pkt->size);
 504     pkt->pts = pkt->dts = cx_frame->pts;
 505
 506     if (!!(cx_frame->flags & AOM_FRAME_IS_KEY))
 507         pkt->flags |= AV_PKT_FLAG_KEY;
 508     return pkt->size;
 509 }
 510
 511 /**
 512  * Queue multiple output frames from the encoder, returning the front-most.
 513  * In cases where aom_codec_get_cx_data() returns more than 1 frame append
 514  * the frame queue. Return the head frame if available.
 515  * @return Stored frame size
 516  * @return AVERROR(EINVAL) on output size error
 517  * @return AVERROR(ENOMEM) on coded frame queue data allocation error
 518  */
 519 static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out)
 520 {
 521     AOMContext *ctx = avctx->priv_data;
 522     const struct aom_codec_cx_pkt *pkt;
 523     const void *iter = NULL;
 524     int size = 0;
 525
 526     if (ctx->coded_frame_list) {
 527         struct FrameListData *cx_frame = ctx->coded_frame_list;
 528         /* return the leading frame if we've already begun queueing */
 529         size = storeframe(avctx, cx_frame, pkt_out);
 530         if (size < 0)
 531             return size;
 532         ctx->coded_frame_list = cx_frame->next;
 533         free_coded_frame(cx_frame);
 534     }
 535
 536     /* consume all available output from the encoder before returning. buffers
 537      * are only good through the next aom_codec call */
 538     while ((pkt = aom_codec_get_cx_data(&ctx->encoder, &iter))) {
 539         switch (pkt->kind) {
 540         case AOM_CODEC_CX_FRAME_PKT:
 541             if (!size) {
 542                 struct FrameListData cx_frame;
 543
 544                 /* avoid storing the frame when the list is empty and we haven't yet
 545                  * provided a frame for output */
 546                 av_assert0(!ctx->coded_frame_list);
 547                 cx_pktcpy(&cx_frame, pkt);
 548                 size = storeframe(avctx, &cx_frame, pkt_out);
 549                 if (size < 0)
 550                     return size;
 551             } else {
 552                 struct FrameListData *cx_frame =
 553                     av_malloc(sizeof(struct FrameListData));
 554
 555                 if (!cx_frame) {
 556                     av_log(avctx, AV_LOG_ERROR,
 557                            "Frame queue element alloc failed\n");
 558                     return AVERROR(ENOMEM);
 559                 }
 560                 cx_pktcpy(cx_frame, pkt);
 561                 cx_frame->buf = av_malloc(cx_frame->sz);
 562
 563                 if (!cx_frame->buf) {
 564                     av_log(avctx, AV_LOG_ERROR,
 565                            "Data buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
 566                            cx_frame->sz);
 567                     av_freep(&cx_frame);
 568                     return AVERROR(ENOMEM);
 569                 }
 570                 memcpy(cx_frame->buf, pkt->data.frame.buf, pkt->data.frame.sz);
 571                 coded_frame_add(&ctx->coded_frame_list, cx_frame);
 572             }
 573             break;
 574         case AOM_CODEC_STATS_PKT:
 575         {
 576             struct aom_fixed_buf *stats = &ctx->twopass_stats;
 577             int err;
 578             if ((err = av_reallocp(&stats->buf,
 579                                    stats->sz +
 580                                    pkt->data.twopass_stats.sz)) < 0) {
 581                 stats->sz = 0;
 582                 av_log(avctx, AV_LOG_ERROR, "Stat buffer realloc failed\n");
 583                 return err;
 584             }
 585             memcpy((uint8_t *)stats->buf + stats->sz,
 586                    pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
 587             stats->sz += pkt->data.twopass_stats.sz;
 588             break;
 589         }
 590         case AOM_CODEC_PSNR_PKT: // FIXME add support for AV_CODEC_FLAG_PSNR
 591         case AOM_CODEC_CUSTOM_PKT:
 592             // ignore unsupported/unrecognized packet types
 593             break;
 594         }
 595     }
 596
 597     return size;
 598 }
 599
 600 static int aom_encode(AVCodecContext *avctx, AVPacket *pkt,
 601                       const AVFrame *frame, int *got_packet)
 602 {
 603     AOMContext *ctx = avctx->priv_data;
 604     struct aom_image *rawimg = NULL;
 605     int64_t timestamp = 0;
 606     int res, coded_size;
 607     aom_enc_frame_flags_t flags = 0;
 608
 609     if (frame) {
 610         rawimg                      = &ctx->rawimg;
 611         rawimg->planes[AOM_PLANE_Y] = frame->data[0];
 612         rawimg->planes[AOM_PLANE_U] = frame->data[1];
 613         rawimg->planes[AOM_PLANE_V] = frame->data[2];
 614         rawimg->stride[AOM_PLANE_Y] = frame->linesize[0];
 615         rawimg->stride[AOM_PLANE_U] = frame->linesize[1];
 616         rawimg->stride[AOM_PLANE_V] = frame->linesize[2];
 617         timestamp                   = frame->pts;
 618         switch (frame->color_range) {
 619         case AVCOL_RANGE_MPEG:
 620             rawimg->range = AOM_CR_STUDIO_RANGE;
 621             break;
 622         case AVCOL_RANGE_JPEG:
 623             rawimg->range = AOM_CR_FULL_RANGE;
 624             break;
 625         }
 626
 627         if (frame->pict_type == AV_PICTURE_TYPE_I)
 628             flags |= AOM_EFLAG_FORCE_KF;
 629     }
 630
 631     res = aom_codec_encode(&ctx->encoder, rawimg, timestamp,
 632                            avctx->ticks_per_frame, flags);
 633     if (res != AOM_CODEC_OK) {
 634         log_encoder_error(avctx, "Error encoding frame");
 635         return AVERROR_INVALIDDATA;
 636     }
 637     coded_size = queue_frames(avctx, pkt);
 638
 639     if (!frame && avctx->flags & AV_CODEC_FLAG_PASS1) {
 640         size_t b64_size = AV_BASE64_SIZE(ctx->twopass_stats.sz);
 641
 642         avctx->stats_out = av_malloc(b64_size);
 643         if (!avctx->stats_out) {
 644             av_log(avctx, AV_LOG_ERROR, "Stat buffer alloc (%"SIZE_SPECIFIER" bytes) failed\n",
 645                    b64_size);
 646             return AVERROR(ENOMEM);
 647         }
 648         av_base64_encode(avctx->stats_out, b64_size, ctx->twopass_stats.buf,
 649                          ctx->twopass_stats.sz);
 650     }
 651
 652     *got_packet = !!coded_size;
 653     return 0;
 654 }
 655
 656 static const enum AVPixelFormat av1_pix_fmts[] = {
 657     AV_PIX_FMT_YUV420P,
 658     AV_PIX_FMT_YUV422P,
 659     AV_PIX_FMT_YUV444P,
 660     AV_PIX_FMT_NONE
 661 };
 662
 663 static const enum AVPixelFormat av1_pix_fmts_highbd[] = {
 664     AV_PIX_FMT_YUV420P,
 665     AV_PIX_FMT_YUV422P,
 666     AV_PIX_FMT_YUV444P,
 667     AV_PIX_FMT_YUV420P10,
 668     AV_PIX_FMT_YUV422P10,
 669     AV_PIX_FMT_YUV444P10,
 670     AV_PIX_FMT_YUV420P12,
 671     AV_PIX_FMT_YUV422P12,
 672     AV_PIX_FMT_YUV444P12,
 673     AV_PIX_FMT_NONE
 674 };
 675
 676 static av_cold void av1_init_static(AVCodec *codec)
 677 {
 678     aom_codec_caps_t codec_caps = aom_codec_get_caps(aom_codec_av1_cx());
 679     if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH)
 680         codec->pix_fmts = av1_pix_fmts_highbd;
 681     else
 682         codec->pix_fmts = av1_pix_fmts;
 683 }
 684
 685 static av_cold int av1_init(AVCodecContext *avctx)
 686 {
 687     return aom_init(avctx, aom_codec_av1_cx());
 688 }
 689
 690 #define OFFSET(x) offsetof(AOMContext, x)
 691 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 692 static const AVOption options[] = {
 693     { "cpu-used",        "Quality/Speed ratio modifier",           OFFSET(cpu_used),        AV_OPT_TYPE_INT, {.i64 = 1}, -8, 8, VE},
 694     { "auto-alt-ref",    "Enable use of alternate reference "
 695                          "frames (2-pass only)",                   OFFSET(auto_alt_ref),    AV_OPT_TYPE_INT, {.i64 = -1},      -1,      2,       VE},
 696     { "lag-in-frames",   "Number of frames to look ahead at for "
 697                          "alternate reference frame selection",    OFFSET(lag_in_frames),   AV_OPT_TYPE_INT, {.i64 = -1},      -1,      INT_MAX, VE},
 698     { "error-resilience", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, VE, "er"},
 699     { "default",         "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
 700     { "partitions",      "The frame partitions are independently decodable "
 701                          "by the bool decoder, meaning that partitions can be decoded even "
 702                          "though earlier partitions have been lost. Note that intra predicition"
 703                          " is still done over the partition boundary.",       0, AV_OPT_TYPE_CONST, {.i64 = AOM_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"},
 704     { "crf",              "Select the quality for constant quality mode", offsetof(AOMContext, crf), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 63, VE },
 705     { "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 },
 706     { "drop-threshold",   "Frame drop threshold", offsetof(AOMContext, drop_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, VE },
 707     { "noise-sensitivity", "Noise sensitivity", OFFSET(noise_sensitivity), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 4, VE},
 708     { NULL }
 709 };
 710
 711 static const AVCodecDefault defaults[] = {
 712     { "qmin",             "-1" },
 713     { "qmax",             "-1" },
 714     { "g",                "-1" },
 715     { "keyint_min",       "-1" },
 716     { NULL },
 717 };
 718
 719 static const AVClass class_aom = {
 720     .class_name = "libaom-av1 encoder",
 721     .item_name  = av_default_item_name,
 722     .option     = options,
 723     .version    = LIBAVUTIL_VERSION_INT,
 724 };
 725
 726 AVCodec ff_libaom_av1_encoder = {
 727     .name           = "libaom-av1",
 728     .long_name      = NULL_IF_CONFIG_SMALL("libaom AV1"),
 729     .type           = AVMEDIA_TYPE_VIDEO,
 730     .id             = AV_CODEC_ID_AV1,
 731     .priv_data_size = sizeof(AOMContext),
 732     .init           = av1_init,
 733     .encode2        = aom_encode,
 734     .close          = aom_free,
 735     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_EXPERIMENTAL,
 736     .profiles       = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
 737     .priv_class     = &class_aom,
 738     .defaults       = defaults,
 739     .init_static_data = av1_init_static,
 740     .wrapper_name   = "libaom",
 741 };