granicus.if.org Git - libvpx/blob - vp8/vp8_cx_iface.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "./vpx_config.h"
  12 #include "./vp8_rtcd.h"
  13 #include "./vpx_dsp_rtcd.h"
  14 #include "./vpx_scale_rtcd.h"
  15 #include "vpx/vpx_codec.h"
  16 #include "vpx/internal/vpx_codec_internal.h"
  17 #include "vpx_version.h"
  18 #include "vpx_mem/vpx_mem.h"
  19 #include "vpx_ports/system_state.h"
  20 #include "vpx_ports/vpx_once.h"
  21 #include "vp8/encoder/onyx_int.h"
  22 #include "vpx/vp8cx.h"
  23 #include "vp8/encoder/firstpass.h"
  24 #include "vp8/common/onyx.h"
  25 #include "vp8/common/common.h"
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 struct vp8_extracfg {
  30   struct vpx_codec_pkt_list *pkt_list;
  31   int cpu_used; /** available cpu percentage in 1/16*/
  32   /** if encoder decides to uses alternate reference frame */
  33   unsigned int enable_auto_alt_ref;
  34   unsigned int noise_sensitivity;
  35   unsigned int Sharpness;
  36   unsigned int static_thresh;
  37   unsigned int token_partitions;
  38   unsigned int arnr_max_frames; /* alt_ref Noise Reduction Max Frame Count */
  39   unsigned int arnr_strength;   /* alt_ref Noise Reduction Strength */
  40   unsigned int arnr_type;       /* alt_ref filter type */
  41   vp8e_tuning tuning;
  42   unsigned int cq_level; /* constrained quality level */
  43   unsigned int rc_max_intra_bitrate_pct;
  44   unsigned int gf_cbr_boost_pct;
  45   unsigned int screen_content_mode;
  46 };
  47
  48 static struct vp8_extracfg default_extracfg = {
  49   NULL,
  50 #if !(CONFIG_REALTIME_ONLY)
  51   0, /* cpu_used      */
  52 #else
  53   4,                      /* cpu_used      */
  54 #endif
  55   0, /* enable_auto_alt_ref */
  56   0, /* noise_sensitivity */
  57   0, /* Sharpness */
  58   0, /* static_thresh */
  59 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
  60   VP8_EIGHT_TOKENPARTITION,
  61 #else
  62   VP8_ONE_TOKENPARTITION, /* token_partitions */
  63 #endif
  64   0,  /* arnr_max_frames */
  65   3,  /* arnr_strength */
  66   3,  /* arnr_type*/
  67   0,  /* tuning*/
  68   10, /* cq_level */
  69   0,  /* rc_max_intra_bitrate_pct */
  70   0,  /* gf_cbr_boost_pct */
  71   0,  /* screen_content_mode */
  72 };
  73
  74 struct vpx_codec_alg_priv {
  75   vpx_codec_priv_t base;
  76   vpx_codec_enc_cfg_t cfg;
  77   struct vp8_extracfg vp8_cfg;
  78   VP8_CONFIG oxcf;
  79   struct VP8_COMP *cpi;
  80   unsigned char *cx_data;
  81   unsigned int cx_data_sz;
  82   vpx_image_t preview_img;
  83   unsigned int next_frame_flag;
  84   vp8_postproc_cfg_t preview_ppcfg;
  85   /* pkt_list size depends on the maximum number of lagged frames allowed. */
  86   vpx_codec_pkt_list_decl(64) pkt_list;
  87   unsigned int fixed_kf_cntr;
  88   vpx_enc_frame_flags_t control_frame_flags;
  89 };
  90
  91 static vpx_codec_err_t update_error_state(
  92     vpx_codec_alg_priv_t *ctx, const struct vpx_internal_error_info *error) {
  93   vpx_codec_err_t res;
  94
  95   if ((res = error->error_code)) {
  96     ctx->base.err_detail = error->has_detail ? error->detail : NULL;
  97   }
  98
  99   return res;
 100 }
 101
 102 #undef ERROR
 103 #define ERROR(str)                  \
 104   do {                              \
 105     ctx->base.err_detail = str;     \
 106     return VPX_CODEC_INVALID_PARAM; \
 107   } while (0)
 108
 109 #define RANGE_CHECK(p, memb, lo, hi)                                 \
 110   do {                                                               \
 111     if (!(((p)->memb == lo || (p)->memb > (lo)) && (p)->memb <= hi)) \
 112       ERROR(#memb " out of range [" #lo ".." #hi "]");               \
 113   } while (0)
 114
 115 #define RANGE_CHECK_HI(p, memb, hi)                                     \
 116   do {                                                                  \
 117     if (!((p)->memb <= (hi))) ERROR(#memb " out of range [.." #hi "]"); \
 118   } while (0)
 119
 120 #define RANGE_CHECK_LO(p, memb, lo)                                     \
 121   do {                                                                  \
 122     if (!((p)->memb >= (lo))) ERROR(#memb " out of range [" #lo "..]"); \
 123   } while (0)
 124
 125 #define RANGE_CHECK_BOOL(p, memb)                                     \
 126   do {                                                                \
 127     if (!!((p)->memb) != (p)->memb) ERROR(#memb " expected boolean"); \
 128   } while (0)
 129
 130 static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx,
 131                                        const vpx_codec_enc_cfg_t *cfg,
 132                                        const struct vp8_extracfg *vp8_cfg,
 133                                        int finalize) {
 134   RANGE_CHECK(cfg, g_w, 1, 16383); /* 14 bits available */
 135   RANGE_CHECK(cfg, g_h, 1, 16383); /* 14 bits available */
 136   RANGE_CHECK(cfg, g_timebase.den, 1, 1000000000);
 137   RANGE_CHECK(cfg, g_timebase.num, 1, 1000000000);
 138   RANGE_CHECK_HI(cfg, g_profile, 3);
 139   RANGE_CHECK_HI(cfg, rc_max_quantizer, 63);
 140   RANGE_CHECK_HI(cfg, rc_min_quantizer, cfg->rc_max_quantizer);
 141   RANGE_CHECK_HI(cfg, g_threads, 64);
 142 #if CONFIG_REALTIME_ONLY
 143   RANGE_CHECK_HI(cfg, g_lag_in_frames, 0);
 144 #elif CONFIG_MULTI_RES_ENCODING
 145   if (ctx->base.enc.total_encoders > 1) RANGE_CHECK_HI(cfg, g_lag_in_frames, 0);
 146 #else
 147   RANGE_CHECK_HI(cfg, g_lag_in_frames, 25);
 148 #endif
 149   RANGE_CHECK(cfg, rc_end_usage, VPX_VBR, VPX_Q);
 150   RANGE_CHECK_HI(cfg, rc_undershoot_pct, 1000);
 151   RANGE_CHECK_HI(cfg, rc_overshoot_pct, 1000);
 152   RANGE_CHECK_HI(cfg, rc_2pass_vbr_bias_pct, 100);
 153   RANGE_CHECK(cfg, kf_mode, VPX_KF_DISABLED, VPX_KF_AUTO);
 154
 155 /* TODO: add spatial re-sampling support and frame dropping in
 156  * multi-res-encoder.*/
 157 #if CONFIG_MULTI_RES_ENCODING
 158   if (ctx->base.enc.total_encoders > 1)
 159     RANGE_CHECK_HI(cfg, rc_resize_allowed, 0);
 160 #else
 161   RANGE_CHECK_BOOL(cfg, rc_resize_allowed);
 162 #endif
 163   RANGE_CHECK_HI(cfg, rc_dropframe_thresh, 100);
 164   RANGE_CHECK_HI(cfg, rc_resize_up_thresh, 100);
 165   RANGE_CHECK_HI(cfg, rc_resize_down_thresh, 100);
 166
 167 #if CONFIG_REALTIME_ONLY
 168   RANGE_CHECK(cfg, g_pass, VPX_RC_ONE_PASS, VPX_RC_ONE_PASS);
 169 #elif CONFIG_MULTI_RES_ENCODING
 170   if (ctx->base.enc.total_encoders > 1)
 171     RANGE_CHECK(cfg, g_pass, VPX_RC_ONE_PASS, VPX_RC_ONE_PASS);
 172 #else
 173   RANGE_CHECK(cfg, g_pass, VPX_RC_ONE_PASS, VPX_RC_LAST_PASS);
 174 #endif
 175
 176   /* VP8 does not support a lower bound on the keyframe interval in
 177    * automatic keyframe placement mode.
 178    */
 179   if (cfg->kf_mode != VPX_KF_DISABLED && cfg->kf_min_dist != cfg->kf_max_dist &&
 180       cfg->kf_min_dist > 0)
 181     ERROR(
 182         "kf_min_dist not supported in auto mode, use 0 "
 183         "or kf_max_dist instead.");
 184
 185   RANGE_CHECK_BOOL(vp8_cfg, enable_auto_alt_ref);
 186   RANGE_CHECK(vp8_cfg, cpu_used, -16, 16);
 187
 188 #if CONFIG_REALTIME_ONLY && !CONFIG_TEMPORAL_DENOISING
 189   RANGE_CHECK(vp8_cfg, noise_sensitivity, 0, 0);
 190 #else
 191   RANGE_CHECK_HI(vp8_cfg, noise_sensitivity, 6);
 192 #endif
 193
 194   RANGE_CHECK(vp8_cfg, token_partitions, VP8_ONE_TOKENPARTITION,
 195               VP8_EIGHT_TOKENPARTITION);
 196   RANGE_CHECK_HI(vp8_cfg, Sharpness, 7);
 197   RANGE_CHECK(vp8_cfg, arnr_max_frames, 0, 15);
 198   RANGE_CHECK_HI(vp8_cfg, arnr_strength, 6);
 199   RANGE_CHECK(vp8_cfg, arnr_type, 1, 3);
 200   RANGE_CHECK(vp8_cfg, cq_level, 0, 63);
 201   RANGE_CHECK_HI(vp8_cfg, screen_content_mode, 2);
 202   if (finalize && (cfg->rc_end_usage == VPX_CQ || cfg->rc_end_usage == VPX_Q))
 203     RANGE_CHECK(vp8_cfg, cq_level, cfg->rc_min_quantizer,
 204                 cfg->rc_max_quantizer);
 205
 206 #if !(CONFIG_REALTIME_ONLY)
 207   if (cfg->g_pass == VPX_RC_LAST_PASS) {
 208     size_t packet_sz = sizeof(FIRSTPASS_STATS);
 209     int n_packets = (int)(cfg->rc_twopass_stats_in.sz / packet_sz);
 210     FIRSTPASS_STATS *stats;
 211
 212     if (!cfg->rc_twopass_stats_in.buf)
 213       ERROR("rc_twopass_stats_in.buf not set.");
 214
 215     if (cfg->rc_twopass_stats_in.sz % packet_sz)
 216       ERROR("rc_twopass_stats_in.sz indicates truncated packet.");
 217
 218     if (cfg->rc_twopass_stats_in.sz < 2 * packet_sz)
 219       ERROR("rc_twopass_stats_in requires at least two packets.");
 220
 221     stats = (void *)((char *)cfg->rc_twopass_stats_in.buf +
 222                      (n_packets - 1) * packet_sz);
 223
 224     if ((int)(stats->count + 0.5) != n_packets - 1)
 225       ERROR("rc_twopass_stats_in missing EOS stats packet");
 226   }
 227 #endif
 228
 229   RANGE_CHECK(cfg, ts_number_layers, 1, 5);
 230
 231   if (cfg->ts_number_layers > 1) {
 232     unsigned int i;
 233     RANGE_CHECK_HI(cfg, ts_periodicity, 16);
 234
 235     for (i = 1; i < cfg->ts_number_layers; ++i) {
 236       if (cfg->ts_target_bitrate[i] <= cfg->ts_target_bitrate[i - 1] &&
 237           cfg->rc_target_bitrate > 0)
 238         ERROR("ts_target_bitrate entries are not strictly increasing");
 239     }
 240
 241     RANGE_CHECK(cfg, ts_rate_decimator[cfg->ts_number_layers - 1], 1, 1);
 242     for (i = cfg->ts_number_layers - 2; i > 0; i--) {
 243       if (cfg->ts_rate_decimator[i - 1] != 2 * cfg->ts_rate_decimator[i])
 244         ERROR("ts_rate_decimator factors are not powers of 2");
 245     }
 246
 247     RANGE_CHECK_HI(cfg, ts_layer_id[i], cfg->ts_number_layers - 1);
 248   }
 249
 250 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
 251   if (cfg->g_threads > (1 << vp8_cfg->token_partitions))
 252     ERROR("g_threads cannot be bigger than number of token partitions");
 253 #endif
 254
 255   return VPX_CODEC_OK;
 256 }
 257
 258 static vpx_codec_err_t validate_img(vpx_codec_alg_priv_t *ctx,
 259                                     const vpx_image_t *img) {
 260   switch (img->fmt) {
 261     case VPX_IMG_FMT_YV12:
 262     case VPX_IMG_FMT_I420: break;
 263     default:
 264       ERROR("Invalid image format. Only YV12 and I420 images are supported");
 265   }
 266
 267   if ((img->d_w != ctx->cfg.g_w) || (img->d_h != ctx->cfg.g_h))
 268     ERROR("Image size must match encoder init configuration size");
 269
 270   return VPX_CODEC_OK;
 271 }
 272
 273 static vpx_codec_err_t set_vp8e_config(VP8_CONFIG *oxcf,
 274                                        vpx_codec_enc_cfg_t cfg,
 275                                        struct vp8_extracfg vp8_cfg,
 276                                        vpx_codec_priv_enc_mr_cfg_t *mr_cfg) {
 277   oxcf->multi_threaded = cfg.g_threads;
 278   oxcf->Version = cfg.g_profile;
 279
 280   oxcf->Width = cfg.g_w;
 281   oxcf->Height = cfg.g_h;
 282   oxcf->timebase = cfg.g_timebase;
 283
 284   oxcf->error_resilient_mode = cfg.g_error_resilient;
 285
 286   switch (cfg.g_pass) {
 287     case VPX_RC_ONE_PASS: oxcf->Mode = MODE_BESTQUALITY; break;
 288     case VPX_RC_FIRST_PASS: oxcf->Mode = MODE_FIRSTPASS; break;
 289     case VPX_RC_LAST_PASS: oxcf->Mode = MODE_SECONDPASS_BEST; break;
 290   }
 291
 292   if (cfg.g_pass == VPX_RC_FIRST_PASS || cfg.g_pass == VPX_RC_ONE_PASS) {
 293     oxcf->allow_lag = 0;
 294     oxcf->lag_in_frames = 0;
 295   } else {
 296     oxcf->allow_lag = (cfg.g_lag_in_frames) > 0;
 297     oxcf->lag_in_frames = cfg.g_lag_in_frames;
 298   }
 299
 300   oxcf->allow_df = (cfg.rc_dropframe_thresh > 0);
 301   oxcf->drop_frames_water_mark = cfg.rc_dropframe_thresh;
 302
 303   oxcf->allow_spatial_resampling = cfg.rc_resize_allowed;
 304   oxcf->resample_up_water_mark = cfg.rc_resize_up_thresh;
 305   oxcf->resample_down_water_mark = cfg.rc_resize_down_thresh;
 306
 307   if (cfg.rc_end_usage == VPX_VBR) {
 308     oxcf->end_usage = USAGE_LOCAL_FILE_PLAYBACK;
 309   } else if (cfg.rc_end_usage == VPX_CBR) {
 310     oxcf->end_usage = USAGE_STREAM_FROM_SERVER;
 311   } else if (cfg.rc_end_usage == VPX_CQ) {
 312     oxcf->end_usage = USAGE_CONSTRAINED_QUALITY;
 313   } else if (cfg.rc_end_usage == VPX_Q) {
 314     oxcf->end_usage = USAGE_CONSTANT_QUALITY;
 315   }
 316
 317   oxcf->target_bandwidth = cfg.rc_target_bitrate;
 318   oxcf->rc_max_intra_bitrate_pct = vp8_cfg.rc_max_intra_bitrate_pct;
 319   oxcf->gf_cbr_boost_pct = vp8_cfg.gf_cbr_boost_pct;
 320
 321   oxcf->best_allowed_q = cfg.rc_min_quantizer;
 322   oxcf->worst_allowed_q = cfg.rc_max_quantizer;
 323   oxcf->cq_level = vp8_cfg.cq_level;
 324   oxcf->fixed_q = -1;
 325
 326   oxcf->under_shoot_pct = cfg.rc_undershoot_pct;
 327   oxcf->over_shoot_pct = cfg.rc_overshoot_pct;
 328
 329   oxcf->maximum_buffer_size_in_ms = cfg.rc_buf_sz;
 330   oxcf->starting_buffer_level_in_ms = cfg.rc_buf_initial_sz;
 331   oxcf->optimal_buffer_level_in_ms = cfg.rc_buf_optimal_sz;
 332
 333   oxcf->maximum_buffer_size = cfg.rc_buf_sz;
 334   oxcf->starting_buffer_level = cfg.rc_buf_initial_sz;
 335   oxcf->optimal_buffer_level = cfg.rc_buf_optimal_sz;
 336
 337   oxcf->two_pass_vbrbias = cfg.rc_2pass_vbr_bias_pct;
 338   oxcf->two_pass_vbrmin_section = cfg.rc_2pass_vbr_minsection_pct;
 339   oxcf->two_pass_vbrmax_section = cfg.rc_2pass_vbr_maxsection_pct;
 340
 341   oxcf->auto_key =
 342       cfg.kf_mode == VPX_KF_AUTO && cfg.kf_min_dist != cfg.kf_max_dist;
 343   oxcf->key_freq = cfg.kf_max_dist;
 344
 345   oxcf->number_of_layers = cfg.ts_number_layers;
 346   oxcf->periodicity = cfg.ts_periodicity;
 347
 348   if (oxcf->number_of_layers > 1) {
 349     memcpy(oxcf->target_bitrate, cfg.ts_target_bitrate,
 350            sizeof(cfg.ts_target_bitrate));
 351     memcpy(oxcf->rate_decimator, cfg.ts_rate_decimator,
 352            sizeof(cfg.ts_rate_decimator));
 353     memcpy(oxcf->layer_id, cfg.ts_layer_id, sizeof(cfg.ts_layer_id));
 354   }
 355
 356 #if CONFIG_MULTI_RES_ENCODING
 357   /* When mr_cfg is NULL, oxcf->mr_total_resolutions and oxcf->mr_encoder_id
 358    * are both memset to 0, which ensures the correct logic under this
 359    * situation.
 360    */
 361   if (mr_cfg) {
 362     oxcf->mr_total_resolutions = mr_cfg->mr_total_resolutions;
 363     oxcf->mr_encoder_id = mr_cfg->mr_encoder_id;
 364     oxcf->mr_down_sampling_factor.num = mr_cfg->mr_down_sampling_factor.num;
 365     oxcf->mr_down_sampling_factor.den = mr_cfg->mr_down_sampling_factor.den;
 366     oxcf->mr_low_res_mode_info = mr_cfg->mr_low_res_mode_info;
 367   }
 368 #else
 369   (void)mr_cfg;
 370 #endif
 371
 372   oxcf->cpu_used = vp8_cfg.cpu_used;
 373   oxcf->encode_breakout = vp8_cfg.static_thresh;
 374   oxcf->play_alternate = vp8_cfg.enable_auto_alt_ref;
 375   oxcf->noise_sensitivity = vp8_cfg.noise_sensitivity;
 376   oxcf->Sharpness = vp8_cfg.Sharpness;
 377   oxcf->token_partitions = vp8_cfg.token_partitions;
 378
 379   oxcf->two_pass_stats_in = cfg.rc_twopass_stats_in;
 380   oxcf->output_pkt_list = vp8_cfg.pkt_list;
 381
 382   oxcf->arnr_max_frames = vp8_cfg.arnr_max_frames;
 383   oxcf->arnr_strength = vp8_cfg.arnr_strength;
 384   oxcf->arnr_type = vp8_cfg.arnr_type;
 385
 386   oxcf->tuning = vp8_cfg.tuning;
 387
 388   oxcf->screen_content_mode = vp8_cfg.screen_content_mode;
 389
 390   /*
 391       printf("Current VP8 Settings: \n");
 392       printf("target_bandwidth: %d\n", oxcf->target_bandwidth);
 393       printf("noise_sensitivity: %d\n", oxcf->noise_sensitivity);
 394       printf("Sharpness: %d\n",    oxcf->Sharpness);
 395       printf("cpu_used: %d\n",  oxcf->cpu_used);
 396       printf("Mode: %d\n",     oxcf->Mode);
 397       printf("auto_key: %d\n",  oxcf->auto_key);
 398       printf("key_freq: %d\n", oxcf->key_freq);
 399       printf("end_usage: %d\n", oxcf->end_usage);
 400       printf("under_shoot_pct: %d\n", oxcf->under_shoot_pct);
 401       printf("over_shoot_pct: %d\n", oxcf->over_shoot_pct);
 402       printf("starting_buffer_level: %d\n", oxcf->starting_buffer_level);
 403       printf("optimal_buffer_level: %d\n",  oxcf->optimal_buffer_level);
 404       printf("maximum_buffer_size: %d\n", oxcf->maximum_buffer_size);
 405       printf("fixed_q: %d\n",  oxcf->fixed_q);
 406       printf("worst_allowed_q: %d\n", oxcf->worst_allowed_q);
 407       printf("best_allowed_q: %d\n", oxcf->best_allowed_q);
 408       printf("allow_spatial_resampling: %d\n",  oxcf->allow_spatial_resampling);
 409       printf("resample_down_water_mark: %d\n", oxcf->resample_down_water_mark);
 410       printf("resample_up_water_mark: %d\n", oxcf->resample_up_water_mark);
 411       printf("allow_df: %d\n", oxcf->allow_df);
 412       printf("drop_frames_water_mark: %d\n", oxcf->drop_frames_water_mark);
 413       printf("two_pass_vbrbias: %d\n",  oxcf->two_pass_vbrbias);
 414       printf("two_pass_vbrmin_section: %d\n", oxcf->two_pass_vbrmin_section);
 415       printf("two_pass_vbrmax_section: %d\n", oxcf->two_pass_vbrmax_section);
 416       printf("allow_lag: %d\n", oxcf->allow_lag);
 417       printf("lag_in_frames: %d\n", oxcf->lag_in_frames);
 418       printf("play_alternate: %d\n", oxcf->play_alternate);
 419       printf("Version: %d\n", oxcf->Version);
 420       printf("multi_threaded: %d\n",   oxcf->multi_threaded);
 421       printf("encode_breakout: %d\n", oxcf->encode_breakout);
 422   */
 423   return VPX_CODEC_OK;
 424 }
 425
 426 static vpx_codec_err_t vp8e_set_config(vpx_codec_alg_priv_t *ctx,
 427                                        const vpx_codec_enc_cfg_t *cfg) {
 428   vpx_codec_err_t res;
 429
 430   if (cfg->g_w != ctx->cfg.g_w || cfg->g_h != ctx->cfg.g_h) {
 431     if (cfg->g_lag_in_frames > 1 || cfg->g_pass != VPX_RC_ONE_PASS)
 432       ERROR("Cannot change width or height after initialization");
 433     if ((ctx->cpi->initial_width && (int)cfg->g_w > ctx->cpi->initial_width) ||
 434         (ctx->cpi->initial_height && (int)cfg->g_h > ctx->cpi->initial_height))
 435       ERROR("Cannot increase width or height larger than their initial values");
 436   }
 437
 438   /* Prevent increasing lag_in_frames. This check is stricter than it needs
 439    * to be -- the limit is not increasing past the first lag_in_frames
 440    * value, but we don't track the initial config, only the last successful
 441    * config.
 442    */
 443   if ((cfg->g_lag_in_frames > ctx->cfg.g_lag_in_frames))
 444     ERROR("Cannot increase lag_in_frames");
 445
 446   res = validate_config(ctx, cfg, &ctx->vp8_cfg, 0);
 447
 448   if (!res) {
 449     ctx->cfg = *cfg;
 450     set_vp8e_config(&ctx->oxcf, ctx->cfg, ctx->vp8_cfg, NULL);
 451     vp8_change_config(ctx->cpi, &ctx->oxcf);
 452   }
 453
 454   return res;
 455 }
 456
 457 static vpx_codec_err_t get_quantizer(vpx_codec_alg_priv_t *ctx, va_list args) {
 458   int *const arg = va_arg(args, int *);
 459   if (arg == NULL) return VPX_CODEC_INVALID_PARAM;
 460   *arg = vp8_get_quantizer(ctx->cpi);
 461   return VPX_CODEC_OK;
 462 }
 463
 464 static vpx_codec_err_t get_quantizer64(vpx_codec_alg_priv_t *ctx,
 465                                        va_list args) {
 466   int *const arg = va_arg(args, int *);
 467   if (arg == NULL) return VPX_CODEC_INVALID_PARAM;
 468   *arg = vp8_reverse_trans(vp8_get_quantizer(ctx->cpi));
 469   return VPX_CODEC_OK;
 470 }
 471
 472 static vpx_codec_err_t update_extracfg(vpx_codec_alg_priv_t *ctx,
 473                                        const struct vp8_extracfg *extra_cfg) {
 474   const vpx_codec_err_t res = validate_config(ctx, &ctx->cfg, extra_cfg, 0);
 475   if (res == VPX_CODEC_OK) {
 476     ctx->vp8_cfg = *extra_cfg;
 477     set_vp8e_config(&ctx->oxcf, ctx->cfg, ctx->vp8_cfg, NULL);
 478     vp8_change_config(ctx->cpi, &ctx->oxcf);
 479   }
 480   return res;
 481 }
 482
 483 static vpx_codec_err_t set_cpu_used(vpx_codec_alg_priv_t *ctx, va_list args) {
 484   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 485   extra_cfg.cpu_used = CAST(VP8E_SET_CPUUSED, args);
 486   return update_extracfg(ctx, &extra_cfg);
 487 }
 488
 489 static vpx_codec_err_t set_enable_auto_alt_ref(vpx_codec_alg_priv_t *ctx,
 490                                                va_list args) {
 491   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 492   extra_cfg.enable_auto_alt_ref = CAST(VP8E_SET_ENABLEAUTOALTREF, args);
 493   return update_extracfg(ctx, &extra_cfg);
 494 }
 495
 496 static vpx_codec_err_t set_noise_sensitivity(vpx_codec_alg_priv_t *ctx,
 497                                              va_list args) {
 498   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 499   extra_cfg.noise_sensitivity = CAST(VP8E_SET_NOISE_SENSITIVITY, args);
 500   return update_extracfg(ctx, &extra_cfg);
 501 }
 502
 503 static vpx_codec_err_t set_sharpness(vpx_codec_alg_priv_t *ctx, va_list args) {
 504   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 505   extra_cfg.Sharpness = CAST(VP8E_SET_SHARPNESS, args);
 506   return update_extracfg(ctx, &extra_cfg);
 507 }
 508
 509 static vpx_codec_err_t set_static_thresh(vpx_codec_alg_priv_t *ctx,
 510                                          va_list args) {
 511   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 512   extra_cfg.static_thresh = CAST(VP8E_SET_STATIC_THRESHOLD, args);
 513   return update_extracfg(ctx, &extra_cfg);
 514 }
 515
 516 static vpx_codec_err_t set_token_partitions(vpx_codec_alg_priv_t *ctx,
 517                                             va_list args) {
 518   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 519   extra_cfg.token_partitions = CAST(VP8E_SET_TOKEN_PARTITIONS, args);
 520   return update_extracfg(ctx, &extra_cfg);
 521 }
 522
 523 static vpx_codec_err_t set_arnr_max_frames(vpx_codec_alg_priv_t *ctx,
 524                                            va_list args) {
 525   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 526   extra_cfg.arnr_max_frames = CAST(VP8E_SET_ARNR_MAXFRAMES, args);
 527   return update_extracfg(ctx, &extra_cfg);
 528 }
 529
 530 static vpx_codec_err_t set_arnr_strength(vpx_codec_alg_priv_t *ctx,
 531                                          va_list args) {
 532   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 533   extra_cfg.arnr_strength = CAST(VP8E_SET_ARNR_STRENGTH, args);
 534   return update_extracfg(ctx, &extra_cfg);
 535 }
 536
 537 static vpx_codec_err_t set_arnr_type(vpx_codec_alg_priv_t *ctx, va_list args) {
 538   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 539   extra_cfg.arnr_type = CAST(VP8E_SET_ARNR_TYPE, args);
 540   return update_extracfg(ctx, &extra_cfg);
 541 }
 542
 543 static vpx_codec_err_t set_tuning(vpx_codec_alg_priv_t *ctx, va_list args) {
 544   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 545   extra_cfg.tuning = CAST(VP8E_SET_TUNING, args);
 546   return update_extracfg(ctx, &extra_cfg);
 547 }
 548
 549 static vpx_codec_err_t set_cq_level(vpx_codec_alg_priv_t *ctx, va_list args) {
 550   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 551   extra_cfg.cq_level = CAST(VP8E_SET_CQ_LEVEL, args);
 552   return update_extracfg(ctx, &extra_cfg);
 553 }
 554
 555 static vpx_codec_err_t set_rc_max_intra_bitrate_pct(vpx_codec_alg_priv_t *ctx,
 556                                                     va_list args) {
 557   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 558   extra_cfg.rc_max_intra_bitrate_pct =
 559       CAST(VP8E_SET_MAX_INTRA_BITRATE_PCT, args);
 560   return update_extracfg(ctx, &extra_cfg);
 561 }
 562
 563 static vpx_codec_err_t ctrl_set_rc_gf_cbr_boost_pct(vpx_codec_alg_priv_t *ctx,
 564                                                     va_list args) {
 565   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 566   extra_cfg.gf_cbr_boost_pct = CAST(VP8E_SET_GF_CBR_BOOST_PCT, args);
 567   return update_extracfg(ctx, &extra_cfg);
 568 }
 569
 570 static vpx_codec_err_t set_screen_content_mode(vpx_codec_alg_priv_t *ctx,
 571                                                va_list args) {
 572   struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
 573   extra_cfg.screen_content_mode = CAST(VP8E_SET_SCREEN_CONTENT_MODE, args);
 574   return update_extracfg(ctx, &extra_cfg);
 575 }
 576
 577 static vpx_codec_err_t vp8e_mr_alloc_mem(const vpx_codec_enc_cfg_t *cfg,
 578                                          void **mem_loc) {
 579   vpx_codec_err_t res = 0;
 580
 581 #if CONFIG_MULTI_RES_ENCODING
 582   LOWER_RES_FRAME_INFO *shared_mem_loc;
 583   int mb_rows = ((cfg->g_w + 15) >> 4);
 584   int mb_cols = ((cfg->g_h + 15) >> 4);
 585
 586   shared_mem_loc = calloc(1, sizeof(LOWER_RES_FRAME_INFO));
 587   if (!shared_mem_loc) {
 588     res = VPX_CODEC_MEM_ERROR;
 589   }
 590
 591   shared_mem_loc->mb_info =
 592       calloc(mb_rows * mb_cols, sizeof(LOWER_RES_MB_INFO));
 593   if (!(shared_mem_loc->mb_info)) {
 594     res = VPX_CODEC_MEM_ERROR;
 595   } else {
 596     *mem_loc = (void *)shared_mem_loc;
 597     res = VPX_CODEC_OK;
 598   }
 599 #else
 600   (void)cfg;
 601   (void)mem_loc;
 602 #endif
 603   return res;
 604 }
 605
 606 static vpx_codec_err_t vp8e_init(vpx_codec_ctx_t *ctx,
 607                                  vpx_codec_priv_enc_mr_cfg_t *mr_cfg) {
 608   vpx_codec_err_t res = VPX_CODEC_OK;
 609
 610   vp8_rtcd();
 611   vpx_dsp_rtcd();
 612   vpx_scale_rtcd();
 613
 614   if (!ctx->priv) {
 615     struct vpx_codec_alg_priv *priv =
 616         (struct vpx_codec_alg_priv *)vpx_calloc(1, sizeof(*priv));
 617
 618     if (!priv) {
 619       return VPX_CODEC_MEM_ERROR;
 620     }
 621
 622     ctx->priv = (vpx_codec_priv_t *)priv;
 623     ctx->priv->init_flags = ctx->init_flags;
 624
 625     if (ctx->config.enc) {
 626       /* Update the reference to the config structure to an
 627        * internal copy.
 628        */
 629       priv->cfg = *ctx->config.enc;
 630       ctx->config.enc = &priv->cfg;
 631     }
 632
 633     priv->vp8_cfg = default_extracfg;
 634     priv->vp8_cfg.pkt_list = &priv->pkt_list.head;
 635
 636     priv->cx_data_sz = priv->cfg.g_w * priv->cfg.g_h * 3 / 2 * 2;
 637
 638     if (priv->cx_data_sz < 32768) priv->cx_data_sz = 32768;
 639
 640     priv->cx_data = malloc(priv->cx_data_sz);
 641
 642     if (!priv->cx_data) {
 643       return VPX_CODEC_MEM_ERROR;
 644     }
 645
 646     if (mr_cfg) {
 647       ctx->priv->enc.total_encoders = mr_cfg->mr_total_resolutions;
 648     } else {
 649       ctx->priv->enc.total_encoders = 1;
 650     }
 651
 652     once(vp8_initialize_enc);
 653
 654     res = validate_config(priv, &priv->cfg, &priv->vp8_cfg, 0);
 655
 656     if (!res) {
 657       set_vp8e_config(&priv->oxcf, priv->cfg, priv->vp8_cfg, mr_cfg);
 658       priv->cpi = vp8_create_compressor(&priv->oxcf);
 659       if (!priv->cpi) res = VPX_CODEC_MEM_ERROR;
 660     }
 661   }
 662
 663   return res;
 664 }
 665
 666 static vpx_codec_err_t vp8e_destroy(vpx_codec_alg_priv_t *ctx) {
 667 #if CONFIG_MULTI_RES_ENCODING
 668   /* Free multi-encoder shared memory */
 669   if (ctx->oxcf.mr_total_resolutions > 0 &&
 670       (ctx->oxcf.mr_encoder_id == ctx->oxcf.mr_total_resolutions - 1)) {
 671     LOWER_RES_FRAME_INFO *shared_mem_loc =
 672         (LOWER_RES_FRAME_INFO *)ctx->oxcf.mr_low_res_mode_info;
 673     free(shared_mem_loc->mb_info);
 674     free(ctx->oxcf.mr_low_res_mode_info);
 675   }
 676 #endif
 677
 678   free(ctx->cx_data);
 679   vp8_remove_compressor(&ctx->cpi);
 680   vpx_free(ctx);
 681   return VPX_CODEC_OK;
 682 }
 683
 684 static vpx_codec_err_t image2yuvconfig(const vpx_image_t *img,
 685                                        YV12_BUFFER_CONFIG *yv12) {
 686   const int y_w = img->d_w;
 687   const int y_h = img->d_h;
 688   const int uv_w = (img->d_w + 1) / 2;
 689   const int uv_h = (img->d_h + 1) / 2;
 690   vpx_codec_err_t res = VPX_CODEC_OK;
 691   yv12->y_buffer = img->planes[VPX_PLANE_Y];
 692   yv12->u_buffer = img->planes[VPX_PLANE_U];
 693   yv12->v_buffer = img->planes[VPX_PLANE_V];
 694
 695   yv12->y_crop_width = y_w;
 696   yv12->y_crop_height = y_h;
 697   yv12->y_width = y_w;
 698   yv12->y_height = y_h;
 699   yv12->uv_crop_width = uv_w;
 700   yv12->uv_crop_height = uv_h;
 701   yv12->uv_width = uv_w;
 702   yv12->uv_height = uv_h;
 703
 704   yv12->y_stride = img->stride[VPX_PLANE_Y];
 705   yv12->uv_stride = img->stride[VPX_PLANE_U];
 706
 707   yv12->border = (img->stride[VPX_PLANE_Y] - img->w) / 2;
 708   return res;
 709 }
 710
 711 static void pick_quickcompress_mode(vpx_codec_alg_priv_t *ctx,
 712                                     unsigned long duration,
 713                                     unsigned long deadline) {
 714   int new_qc;
 715
 716 #if !(CONFIG_REALTIME_ONLY)
 717   /* Use best quality mode if no deadline is given. */
 718   new_qc = MODE_BESTQUALITY;
 719
 720   if (deadline) {
 721     uint64_t duration_us;
 722
 723     /* Convert duration parameter from stream timebase to microseconds */
 724     duration_us = (uint64_t)duration * 1000000 *
 725                   (uint64_t)ctx->cfg.g_timebase.num /
 726                   (uint64_t)ctx->cfg.g_timebase.den;
 727
 728     /* If the deadline is more that the duration this frame is to be shown,
 729      * use good quality mode. Otherwise use realtime mode.
 730      */
 731     new_qc = (deadline > duration_us) ? MODE_GOODQUALITY : MODE_REALTIME;
 732   }
 733
 734 #else
 735   (void)duration;
 736   new_qc = MODE_REALTIME;
 737 #endif
 738
 739   if (deadline == VPX_DL_REALTIME) {
 740     new_qc = MODE_REALTIME;
 741   } else if (ctx->cfg.g_pass == VPX_RC_FIRST_PASS) {
 742     new_qc = MODE_FIRSTPASS;
 743   } else if (ctx->cfg.g_pass == VPX_RC_LAST_PASS) {
 744     new_qc =
 745         (new_qc == MODE_BESTQUALITY) ? MODE_SECONDPASS_BEST : MODE_SECONDPASS;
 746   }
 747
 748   if (ctx->oxcf.Mode != new_qc) {
 749     ctx->oxcf.Mode = new_qc;
 750     vp8_change_config(ctx->cpi, &ctx->oxcf);
 751   }
 752 }
 753
 754 static vpx_codec_err_t set_reference_and_update(vpx_codec_alg_priv_t *ctx,
 755                                                 vpx_enc_frame_flags_t flags) {
 756   /* Handle Flags */
 757   if (((flags & VP8_EFLAG_NO_UPD_GF) && (flags & VP8_EFLAG_FORCE_GF)) ||
 758       ((flags & VP8_EFLAG_NO_UPD_ARF) && (flags & VP8_EFLAG_FORCE_ARF))) {
 759     ctx->base.err_detail = "Conflicting flags.";
 760     return VPX_CODEC_INVALID_PARAM;
 761   }
 762
 763   if (flags &
 764       (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF)) {
 765     int ref = 7;
 766
 767     if (flags & VP8_EFLAG_NO_REF_LAST) ref ^= VP8_LAST_FRAME;
 768
 769     if (flags & VP8_EFLAG_NO_REF_GF) ref ^= VP8_GOLD_FRAME;
 770
 771     if (flags & VP8_EFLAG_NO_REF_ARF) ref ^= VP8_ALTR_FRAME;
 772
 773     vp8_use_as_reference(ctx->cpi, ref);
 774   }
 775
 776   if (flags &
 777       (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
 778        VP8_EFLAG_FORCE_GF | VP8_EFLAG_FORCE_ARF)) {
 779     int upd = 7;
 780
 781     if (flags & VP8_EFLAG_NO_UPD_LAST) upd ^= VP8_LAST_FRAME;
 782
 783     if (flags & VP8_EFLAG_NO_UPD_GF) upd ^= VP8_GOLD_FRAME;
 784
 785     if (flags & VP8_EFLAG_NO_UPD_ARF) upd ^= VP8_ALTR_FRAME;
 786
 787     vp8_update_reference(ctx->cpi, upd);
 788   }
 789
 790   if (flags & VP8_EFLAG_NO_UPD_ENTROPY) {
 791     vp8_update_entropy(ctx->cpi, 0);
 792   }
 793
 794   return VPX_CODEC_OK;
 795 }
 796
 797 static vpx_codec_err_t vp8e_encode(vpx_codec_alg_priv_t *ctx,
 798                                    const vpx_image_t *img, vpx_codec_pts_t pts,
 799                                    unsigned long duration,
 800                                    vpx_enc_frame_flags_t enc_flags,
 801                                    unsigned long deadline) {
 802   volatile vpx_codec_err_t res = VPX_CODEC_OK;
 803   // Make a copy as volatile to avoid -Wclobbered with longjmp.
 804   volatile vpx_enc_frame_flags_t flags = enc_flags;
 805
 806   if (!ctx->cfg.rc_target_bitrate) {
 807 #if CONFIG_MULTI_RES_ENCODING
 808     if (!ctx->cpi) return VPX_CODEC_ERROR;
 809     if (ctx->cpi->oxcf.mr_total_resolutions > 1) {
 810       LOWER_RES_FRAME_INFO *low_res_frame_info =
 811           (LOWER_RES_FRAME_INFO *)ctx->cpi->oxcf.mr_low_res_mode_info;
 812       if (!low_res_frame_info) return VPX_CODEC_ERROR;
 813       low_res_frame_info->skip_encoding_prev_stream = 1;
 814       if (ctx->cpi->oxcf.mr_encoder_id == 0)
 815         low_res_frame_info->skip_encoding_base_stream = 1;
 816     }
 817 #endif
 818     return res;
 819   }
 820
 821   if (img) res = validate_img(ctx, img);
 822
 823   if (!res) res = validate_config(ctx, &ctx->cfg, &ctx->vp8_cfg, 1);
 824
 825   pick_quickcompress_mode(ctx, duration, deadline);
 826   vpx_codec_pkt_list_init(&ctx->pkt_list);
 827
 828   // If no flags are set in the encode call, then use the frame flags as
 829   // defined via the control function: vp8e_set_frame_flags.
 830   if (!flags) {
 831     flags = ctx->control_frame_flags;
 832   }
 833   ctx->control_frame_flags = 0;
 834
 835   if (!res) res = set_reference_and_update(ctx, flags);
 836
 837   /* Handle fixed keyframe intervals */
 838   if (ctx->cfg.kf_mode == VPX_KF_AUTO &&
 839       ctx->cfg.kf_min_dist == ctx->cfg.kf_max_dist) {
 840     if (++ctx->fixed_kf_cntr > ctx->cfg.kf_min_dist) {
 841       flags |= VPX_EFLAG_FORCE_KF;
 842       ctx->fixed_kf_cntr = 1;
 843     }
 844   }
 845
 846   if (setjmp(ctx->cpi->common.error.jmp)) {
 847     ctx->cpi->common.error.setjmp = 0;
 848     vpx_clear_system_state();
 849     return VPX_CODEC_CORRUPT_FRAME;
 850   }
 851
 852   /* Initialize the encoder instance on the first frame*/
 853   if (!res && ctx->cpi) {
 854     unsigned int lib_flags;
 855     YV12_BUFFER_CONFIG sd;
 856     int64_t dst_time_stamp, dst_end_time_stamp;
 857     size_t size, cx_data_sz;
 858     unsigned char *cx_data;
 859     unsigned char *cx_data_end;
 860     int comp_data_state = 0;
 861
 862     /* Set up internal flags */
 863     if (ctx->base.init_flags & VPX_CODEC_USE_PSNR) {
 864       ((VP8_COMP *)ctx->cpi)->b_calculate_psnr = 1;
 865     }
 866
 867     if (ctx->base.init_flags & VPX_CODEC_USE_OUTPUT_PARTITION) {
 868       ((VP8_COMP *)ctx->cpi)->output_partition = 1;
 869     }
 870
 871     /* Convert API flags to internal codec lib flags */
 872     lib_flags = (flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;
 873
 874     /* vp8 use 10,000,000 ticks/second as time stamp */
 875     dst_time_stamp =
 876         pts * 10000000 * ctx->cfg.g_timebase.num / ctx->cfg.g_timebase.den;
 877     dst_end_time_stamp = (pts + duration) * 10000000 * ctx->cfg.g_timebase.num /
 878                          ctx->cfg.g_timebase.den;
 879
 880     if (img != NULL) {
 881       res = image2yuvconfig(img, &sd);
 882
 883       if (vp8_receive_raw_frame(ctx->cpi, ctx->next_frame_flag | lib_flags, &sd,
 884                                 dst_time_stamp, dst_end_time_stamp)) {
 885         VP8_COMP *cpi = (VP8_COMP *)ctx->cpi;
 886         res = update_error_state(ctx, &cpi->common.error);
 887       }
 888
 889       /* reset for next frame */
 890       ctx->next_frame_flag = 0;
 891     }
 892
 893     cx_data = ctx->cx_data;
 894     cx_data_sz = ctx->cx_data_sz;
 895     cx_data_end = ctx->cx_data + cx_data_sz;
 896     lib_flags = 0;
 897
 898     ctx->cpi->common.error.setjmp = 1;
 899
 900     while (cx_data_sz >= ctx->cx_data_sz / 2) {
 901       comp_data_state = vp8_get_compressed_data(
 902           ctx->cpi, &lib_flags, &size, cx_data, cx_data_end, &dst_time_stamp,
 903           &dst_end_time_stamp, !img);
 904
 905       if (comp_data_state == VPX_CODEC_CORRUPT_FRAME) {
 906         return VPX_CODEC_CORRUPT_FRAME;
 907       } else if (comp_data_state == -1) {
 908         break;
 909       }
 910
 911       if (size) {
 912         vpx_codec_pts_t round, delta;
 913         vpx_codec_cx_pkt_t pkt;
 914         VP8_COMP *cpi = (VP8_COMP *)ctx->cpi;
 915
 916         /* Add the frame packet to the list of returned packets. */
 917         round = (vpx_codec_pts_t)10000000 * ctx->cfg.g_timebase.num / 2 - 1;
 918         delta = (dst_end_time_stamp - dst_time_stamp);
 919         pkt.kind = VPX_CODEC_CX_FRAME_PKT;
 920         pkt.data.frame.pts =
 921             (dst_time_stamp * ctx->cfg.g_timebase.den + round) /
 922             ctx->cfg.g_timebase.num / 10000000;
 923         pkt.data.frame.duration =
 924             (unsigned long)((delta * ctx->cfg.g_timebase.den + round) /
 925                             ctx->cfg.g_timebase.num / 10000000);
 926         pkt.data.frame.flags = lib_flags << 16;
 927         pkt.data.frame.width[0] = cpi->common.Width;
 928         pkt.data.frame.height[0] = cpi->common.Height;
 929         pkt.data.frame.spatial_layer_encoded[0] = 1;
 930
 931         if (lib_flags & FRAMEFLAGS_KEY) {
 932           pkt.data.frame.flags |= VPX_FRAME_IS_KEY;
 933         }
 934
 935         if (!cpi->common.show_frame) {
 936           pkt.data.frame.flags |= VPX_FRAME_IS_INVISIBLE;
 937
 938           /* This timestamp should be as close as possible to the
 939            * prior PTS so that if a decoder uses pts to schedule when
 940            * to do this, we start right after last frame was decoded.
 941            * Invisible frames have no duration.
 942            */
 943           pkt.data.frame.pts =
 944               ((cpi->last_time_stamp_seen * ctx->cfg.g_timebase.den + round) /
 945                ctx->cfg.g_timebase.num / 10000000) +
 946               1;
 947           pkt.data.frame.duration = 0;
 948         }
 949
 950         if (cpi->droppable) pkt.data.frame.flags |= VPX_FRAME_IS_DROPPABLE;
 951
 952         if (cpi->output_partition) {
 953           int i;
 954           const int num_partitions =
 955               (1 << cpi->common.multi_token_partition) + 1;
 956
 957           pkt.data.frame.flags |= VPX_FRAME_IS_FRAGMENT;
 958
 959           for (i = 0; i < num_partitions; ++i) {
 960 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
 961             pkt.data.frame.buf = cpi->partition_d[i];
 962 #else
 963             pkt.data.frame.buf = cx_data;
 964             cx_data += cpi->partition_sz[i];
 965             cx_data_sz -= cpi->partition_sz[i];
 966 #endif
 967             pkt.data.frame.sz = cpi->partition_sz[i];
 968             pkt.data.frame.partition_id = i;
 969             /* don't set the fragment bit for the last partition */
 970             if (i == (num_partitions - 1)) {
 971               pkt.data.frame.flags &= ~VPX_FRAME_IS_FRAGMENT;
 972             }
 973             vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
 974           }
 975 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
 976           /* In lagged mode the encoder can buffer multiple frames.
 977            * We don't want this in partitioned output because
 978            * partitions are spread all over the output buffer.
 979            * So, force an exit!
 980            */
 981           cx_data_sz -= ctx->cx_data_sz / 2;
 982 #endif
 983         } else {
 984           pkt.data.frame.buf = cx_data;
 985           pkt.data.frame.sz = size;
 986           pkt.data.frame.partition_id = -1;
 987           vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
 988           cx_data += size;
 989           cx_data_sz -= size;
 990         }
 991       }
 992     }
 993   }
 994
 995   return res;
 996 }
 997
 998 static const vpx_codec_cx_pkt_t *vp8e_get_cxdata(vpx_codec_alg_priv_t *ctx,
 999                                                  vpx_codec_iter_t *iter) {
1000   return vpx_codec_pkt_list_get(&ctx->pkt_list.head, iter);
1001 }
1002
1003 static vpx_codec_err_t vp8e_set_reference(vpx_codec_alg_priv_t *ctx,
1004                                           va_list args) {
1005   vpx_ref_frame_t *data = va_arg(args, vpx_ref_frame_t *);
1006
1007   if (data) {
1008     vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data;
1009     YV12_BUFFER_CONFIG sd;
1010
1011     image2yuvconfig(&frame->img, &sd);
1012     vp8_set_reference(ctx->cpi, frame->frame_type, &sd);
1013     return VPX_CODEC_OK;
1014   } else {
1015     return VPX_CODEC_INVALID_PARAM;
1016   }
1017 }
1018
1019 static vpx_codec_err_t vp8e_get_reference(vpx_codec_alg_priv_t *ctx,
1020                                           va_list args) {
1021   vpx_ref_frame_t *data = va_arg(args, vpx_ref_frame_t *);
1022
1023   if (data) {
1024     vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data;
1025     YV12_BUFFER_CONFIG sd;
1026
1027     image2yuvconfig(&frame->img, &sd);
1028     vp8_get_reference(ctx->cpi, frame->frame_type, &sd);
1029     return VPX_CODEC_OK;
1030   } else {
1031     return VPX_CODEC_INVALID_PARAM;
1032   }
1033 }
1034
1035 static vpx_codec_err_t vp8e_set_previewpp(vpx_codec_alg_priv_t *ctx,
1036                                           va_list args) {
1037 #if CONFIG_POSTPROC
1038   vp8_postproc_cfg_t *data = va_arg(args, vp8_postproc_cfg_t *);
1039
1040   if (data) {
1041     ctx->preview_ppcfg = *((vp8_postproc_cfg_t *)data);
1042     return VPX_CODEC_OK;
1043   } else {
1044     return VPX_CODEC_INVALID_PARAM;
1045   }
1046 #else
1047   (void)ctx;
1048   (void)args;
1049   return VPX_CODEC_INCAPABLE;
1050 #endif
1051 }
1052
1053 static vpx_image_t *vp8e_get_preview(vpx_codec_alg_priv_t *ctx) {
1054   YV12_BUFFER_CONFIG sd;
1055   vp8_ppflags_t flags;
1056   vp8_zero(flags);
1057
1058   if (ctx->preview_ppcfg.post_proc_flag) {
1059     flags.post_proc_flag = ctx->preview_ppcfg.post_proc_flag;
1060     flags.deblocking_level = ctx->preview_ppcfg.deblocking_level;
1061     flags.noise_level = ctx->preview_ppcfg.noise_level;
1062   }
1063
1064   if (0 == vp8_get_preview_raw_frame(ctx->cpi, &sd, &flags)) {
1065     /*
1066     vpx_img_wrap(&ctx->preview_img, VPX_IMG_FMT_YV12,
1067         sd.y_width + 2*VP8BORDERINPIXELS,
1068         sd.y_height + 2*VP8BORDERINPIXELS,
1069         1,
1070         sd.buffer_alloc);
1071     vpx_img_set_rect(&ctx->preview_img,
1072         VP8BORDERINPIXELS, VP8BORDERINPIXELS,
1073         sd.y_width, sd.y_height);
1074         */
1075
1076     ctx->preview_img.bps = 12;
1077     ctx->preview_img.planes[VPX_PLANE_Y] = sd.y_buffer;
1078     ctx->preview_img.planes[VPX_PLANE_U] = sd.u_buffer;
1079     ctx->preview_img.planes[VPX_PLANE_V] = sd.v_buffer;
1080
1081     ctx->preview_img.fmt = VPX_IMG_FMT_I420;
1082     ctx->preview_img.x_chroma_shift = 1;
1083     ctx->preview_img.y_chroma_shift = 1;
1084
1085     ctx->preview_img.d_w = sd.y_width;
1086     ctx->preview_img.d_h = sd.y_height;
1087     ctx->preview_img.stride[VPX_PLANE_Y] = sd.y_stride;
1088     ctx->preview_img.stride[VPX_PLANE_U] = sd.uv_stride;
1089     ctx->preview_img.stride[VPX_PLANE_V] = sd.uv_stride;
1090     ctx->preview_img.w = sd.y_width;
1091     ctx->preview_img.h = sd.y_height;
1092
1093     return &ctx->preview_img;
1094   } else {
1095     return NULL;
1096   }
1097 }
1098
1099 static vpx_codec_err_t vp8e_set_frame_flags(vpx_codec_alg_priv_t *ctx,
1100                                             va_list args) {
1101   int frame_flags = va_arg(args, int);
1102   ctx->control_frame_flags = frame_flags;
1103   return set_reference_and_update(ctx, frame_flags);
1104 }
1105
1106 static vpx_codec_err_t vp8e_set_temporal_layer_id(vpx_codec_alg_priv_t *ctx,
1107                                                   va_list args) {
1108   int layer_id = va_arg(args, int);
1109   if (layer_id < 0 || layer_id >= (int)ctx->cfg.ts_number_layers) {
1110     return VPX_CODEC_INVALID_PARAM;
1111   }
1112   ctx->cpi->temporal_layer_id = layer_id;
1113   return VPX_CODEC_OK;
1114 }
1115
1116 static vpx_codec_err_t vp8e_set_roi_map(vpx_codec_alg_priv_t *ctx,
1117                                         va_list args) {
1118   vpx_roi_map_t *data = va_arg(args, vpx_roi_map_t *);
1119
1120   if (data) {
1121     vpx_roi_map_t *roi = (vpx_roi_map_t *)data;
1122
1123     if (!vp8_set_roimap(ctx->cpi, roi->roi_map, roi->rows, roi->cols,
1124                         roi->delta_q, roi->delta_lf, roi->static_threshold)) {
1125       return VPX_CODEC_OK;
1126     } else {
1127       return VPX_CODEC_INVALID_PARAM;
1128     }
1129   } else {
1130     return VPX_CODEC_INVALID_PARAM;
1131   }
1132 }
1133
1134 static vpx_codec_err_t vp8e_set_activemap(vpx_codec_alg_priv_t *ctx,
1135                                           va_list args) {
1136   vpx_active_map_t *data = va_arg(args, vpx_active_map_t *);
1137
1138   if (data) {
1139     vpx_active_map_t *map = (vpx_active_map_t *)data;
1140
1141     if (!vp8_set_active_map(ctx->cpi, map->active_map, map->rows, map->cols)) {
1142       return VPX_CODEC_OK;
1143     } else {
1144       return VPX_CODEC_INVALID_PARAM;
1145     }
1146   } else {
1147     return VPX_CODEC_INVALID_PARAM;
1148   }
1149 }
1150
1151 static vpx_codec_err_t vp8e_set_scalemode(vpx_codec_alg_priv_t *ctx,
1152                                           va_list args) {
1153   vpx_scaling_mode_t *data = va_arg(args, vpx_scaling_mode_t *);
1154
1155   if (data) {
1156     int res;
1157     vpx_scaling_mode_t scalemode = *(vpx_scaling_mode_t *)data;
1158     res = vp8_set_internal_size(ctx->cpi, (VPX_SCALING)scalemode.h_scaling_mode,
1159                                 (VPX_SCALING)scalemode.v_scaling_mode);
1160
1161     if (!res) {
1162       /*force next frame a key frame to effect scaling mode */
1163       ctx->next_frame_flag |= FRAMEFLAGS_KEY;
1164       return VPX_CODEC_OK;
1165     } else {
1166       return VPX_CODEC_INVALID_PARAM;
1167     }
1168   } else {
1169     return VPX_CODEC_INVALID_PARAM;
1170   }
1171 }
1172
1173 static vpx_codec_ctrl_fn_map_t vp8e_ctf_maps[] = {
1174   { VP8_SET_REFERENCE, vp8e_set_reference },
1175   { VP8_COPY_REFERENCE, vp8e_get_reference },
1176   { VP8_SET_POSTPROC, vp8e_set_previewpp },
1177   { VP8E_SET_FRAME_FLAGS, vp8e_set_frame_flags },
1178   { VP8E_SET_TEMPORAL_LAYER_ID, vp8e_set_temporal_layer_id },
1179   { VP8E_SET_ROI_MAP, vp8e_set_roi_map },
1180   { VP8E_SET_ACTIVEMAP, vp8e_set_activemap },
1181   { VP8E_SET_SCALEMODE, vp8e_set_scalemode },
1182   { VP8E_SET_CPUUSED, set_cpu_used },
1183   { VP8E_SET_NOISE_SENSITIVITY, set_noise_sensitivity },
1184   { VP8E_SET_ENABLEAUTOALTREF, set_enable_auto_alt_ref },
1185   { VP8E_SET_SHARPNESS, set_sharpness },
1186   { VP8E_SET_STATIC_THRESHOLD, set_static_thresh },
1187   { VP8E_SET_TOKEN_PARTITIONS, set_token_partitions },
1188   { VP8E_GET_LAST_QUANTIZER, get_quantizer },
1189   { VP8E_GET_LAST_QUANTIZER_64, get_quantizer64 },
1190   { VP8E_SET_ARNR_MAXFRAMES, set_arnr_max_frames },
1191   { VP8E_SET_ARNR_STRENGTH, set_arnr_strength },
1192   { VP8E_SET_ARNR_TYPE, set_arnr_type },
1193   { VP8E_SET_TUNING, set_tuning },
1194   { VP8E_SET_CQ_LEVEL, set_cq_level },
1195   { VP8E_SET_MAX_INTRA_BITRATE_PCT, set_rc_max_intra_bitrate_pct },
1196   { VP8E_SET_SCREEN_CONTENT_MODE, set_screen_content_mode },
1197   { VP8E_SET_GF_CBR_BOOST_PCT, ctrl_set_rc_gf_cbr_boost_pct },
1198   { -1, NULL },
1199 };
1200
1201 static vpx_codec_enc_cfg_map_t vp8e_usage_cfg_map[] = {
1202   { 0,
1203     {
1204         0, /* g_usage (unused) */
1205         0, /* g_threads */
1206         0, /* g_profile */
1207
1208         320,        /* g_width */
1209         240,        /* g_height */
1210         VPX_BITS_8, /* g_bit_depth */
1211         8,          /* g_input_bit_depth */
1212
1213         { 1, 30 }, /* g_timebase */
1214
1215         0, /* g_error_resilient */
1216
1217         VPX_RC_ONE_PASS, /* g_pass */
1218
1219         0, /* g_lag_in_frames */
1220
1221         0,  /* rc_dropframe_thresh */
1222         0,  /* rc_resize_allowed */
1223         1,  /* rc_scaled_width */
1224         1,  /* rc_scaled_height */
1225         60, /* rc_resize_down_thresold */
1226         30, /* rc_resize_up_thresold */
1227
1228         VPX_VBR,     /* rc_end_usage */
1229         { NULL, 0 }, /* rc_twopass_stats_in */
1230         { NULL, 0 }, /* rc_firstpass_mb_stats_in */
1231         256,         /* rc_target_bandwidth */
1232         4,           /* rc_min_quantizer */
1233         63,          /* rc_max_quantizer */
1234         100,         /* rc_undershoot_pct */
1235         100,         /* rc_overshoot_pct */
1236
1237         6000, /* rc_max_buffer_size */
1238         4000, /* rc_buffer_initial_size; */
1239         5000, /* rc_buffer_optimal_size; */
1240
1241         50,  /* rc_two_pass_vbrbias  */
1242         0,   /* rc_two_pass_vbrmin_section */
1243         400, /* rc_two_pass_vbrmax_section */
1244         0,   // rc_2pass_vbr_corpus_complexity (only has meaningfull for VP9)
1245
1246         /* keyframing settings (kf) */
1247         VPX_KF_AUTO, /* g_kfmode*/
1248         0,           /* kf_min_dist */
1249         128,         /* kf_max_dist */
1250
1251         VPX_SS_DEFAULT_LAYERS, /* ss_number_layers */
1252         { 0 },
1253         { 0 }, /* ss_target_bitrate */
1254         1,     /* ts_number_layers */
1255         { 0 }, /* ts_target_bitrate */
1256         { 0 }, /* ts_rate_decimator */
1257         0,     /* ts_periodicity */
1258         { 0 }, /* ts_layer_id */
1259         { 0 }, /* layer_target_bitrate */
1260         0      /* temporal_layering_mode */
1261     } },
1262 };
1263
1264 #ifndef VERSION_STRING
1265 #define VERSION_STRING
1266 #endif
1267 CODEC_INTERFACE(vpx_codec_vp8_cx) = {
1268   "WebM Project VP8 Encoder" VERSION_STRING,
1269   VPX_CODEC_INTERNAL_ABI_VERSION,
1270   VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR | VPX_CODEC_CAP_OUTPUT_PARTITION,
1271   /* vpx_codec_caps_t          caps; */
1272   vp8e_init,     /* vpx_codec_init_fn_t       init; */
1273   vp8e_destroy,  /* vpx_codec_destroy_fn_t    destroy; */
1274   vp8e_ctf_maps, /* vpx_codec_ctrl_fn_map_t  *ctrl_maps; */
1275   {
1276       NULL, /* vpx_codec_peek_si_fn_t    peek_si; */
1277       NULL, /* vpx_codec_get_si_fn_t     get_si; */
1278       NULL, /* vpx_codec_decode_fn_t     decode; */
1279       NULL, /* vpx_codec_frame_get_fn_t  frame_get; */
1280       NULL, /* vpx_codec_set_fb_fn_t     set_fb_fn; */
1281   },
1282   {
1283       1,                  /* 1 cfg map */
1284       vp8e_usage_cfg_map, /* vpx_codec_enc_cfg_map_t    cfg_maps; */
1285       vp8e_encode,        /* vpx_codec_encode_fn_t      encode; */
1286       vp8e_get_cxdata,    /* vpx_codec_get_cx_data_fn_t   get_cx_data; */
1287       vp8e_set_config,
1288       NULL,
1289       vp8e_get_preview,
1290       vp8e_mr_alloc_mem,
1291   } /* encoder functions */
1292 };