vp8_cx_iface.c 45.9 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10 11
 */


12
#include "./vpx_config.h"
13
#include "vp8_rtcd.h"
14 15
#include "vpx/vpx_codec.h"
#include "vpx/internal/vpx_codec_internal.h"
John Koleszar's avatar
John Koleszar committed
16
#include "vpx_version.h"
17
#include "vp8/encoder/onyx_int.h"
18
#include "vpx/vp8cx.h"
19
#include "vp8/encoder/firstpass.h"
20
#include "vp8/common/onyx.h"
John Koleszar's avatar
John Koleszar committed
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
#include <stdlib.h>
#include <string.h>

struct vp8_extracfg
{
    struct vpx_codec_pkt_list *pkt_list;
    int                         cpu_used;                    /** available cpu percentage in 1/16*/
    unsigned int                enable_auto_alt_ref;           /** if encoder decides to uses alternate reference frame */
    unsigned int                noise_sensitivity;
    unsigned int                Sharpness;
    unsigned int                static_thresh;
    unsigned int                token_partitions;
    unsigned int                arnr_max_frames;    /* alt_ref Noise Reduction Max Frame Count */
    unsigned int                arnr_strength;    /* alt_ref Noise Reduction Strength */
    unsigned int                arnr_type;        /* alt_ref filter type */
36
    vp8e_tuning                 tuning;
Paul Wilkins's avatar
Paul Wilkins committed
37
    unsigned int                cq_level;         /* constrained quality level */
38
    unsigned int                rc_max_intra_bitrate_pct;
John Koleszar's avatar
John Koleszar committed
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

};

struct extraconfig_map
{
    int                 usage;
    struct vp8_extracfg cfg;
};

static const struct extraconfig_map extracfg_map[] =
{
    {
        0,
        {
            NULL,
#if !(CONFIG_REALTIME_ONLY)
55
            0,                          /* cpu_used      */
John Koleszar's avatar
John Koleszar committed
56
#else
57
            4,                          /* cpu_used      */
John Koleszar's avatar
John Koleszar committed
58 59 60 61
#endif
            0,                          /* enable_auto_alt_ref */
            0,                          /* noise_sensitivity */
            0,                          /* Sharpness */
62
            0,                          /* static_thresh */
63 64 65
#if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
            VP8_EIGHT_TOKENPARTITION,
#else
John Koleszar's avatar
John Koleszar committed
66
            VP8_ONE_TOKENPARTITION,     /* token_partitions */
67
#endif
68 69 70
            0,                          /* arnr_max_frames */
            3,                          /* arnr_strength */
            3,                          /* arnr_type*/
71
            0,                          /* tuning*/
Paul Wilkins's avatar
Paul Wilkins committed
72
            10,                         /* cq_level */
73
            0,                          /* rc_max_intra_bitrate_pct */
John Koleszar's avatar
John Koleszar committed
74 75 76 77 78 79 80 81 82 83
        }
    }
};

struct vpx_codec_alg_priv
{
    vpx_codec_priv_t        base;
    vpx_codec_enc_cfg_t     cfg;
    struct vp8_extracfg     vp8_cfg;
    VP8_CONFIG              oxcf;
84
    struct VP8_COMP        *cpi;
John Koleszar's avatar
John Koleszar committed
85 86 87 88 89
    unsigned char          *cx_data;
    unsigned int            cx_data_sz;
    vpx_image_t             preview_img;
    unsigned int            next_frame_flag;
    vp8_postproc_cfg_t      preview_ppcfg;
90 91
    /* pkt_list size depends on the maximum number of lagged frames allowed. */
    vpx_codec_pkt_list_decl(64) pkt_list;
John Koleszar's avatar
John Koleszar committed
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
    unsigned int                fixed_kf_cntr;
};


static vpx_codec_err_t
update_error_state(vpx_codec_alg_priv_t                 *ctx,
                   const struct vpx_internal_error_info *error)
{
    vpx_codec_err_t res;

    if ((res = error->error_code))
        ctx->base.err_detail = error->has_detail
                               ? error->detail
                               : NULL;

    return res;
}


111
#undef ERROR
John Koleszar's avatar
John Koleszar committed
112 113 114 115 116 117
#define ERROR(str) do {\
        ctx->base.err_detail = str;\
        return VPX_CODEC_INVALID_PARAM;\
    } while(0)

#define RANGE_CHECK(p,memb,lo,hi) do {\
118
        if(!(((p)->memb == lo || (p)->memb > (lo)) && (p)->memb <= hi)) \
John Koleszar's avatar
John Koleszar committed
119 120 121
            ERROR(#memb " out of range ["#lo".."#hi"]");\
    } while(0)

122 123 124 125 126
#define RANGE_CHECK_HI(p,memb,hi) do {\
        if(!((p)->memb <= (hi))) \
            ERROR(#memb " out of range [.."#hi"]");\
    } while(0)

John Koleszar's avatar
John Koleszar committed
127 128 129 130 131 132 133 134 135 136 137
#define RANGE_CHECK_LO(p,memb,lo) do {\
        if(!((p)->memb >= (lo))) \
            ERROR(#memb " out of range ["#lo"..]");\
    } while(0)

#define RANGE_CHECK_BOOL(p,memb) do {\
        if(!!((p)->memb) != (p)->memb) ERROR(#memb " expected boolean");\
    } while(0)

static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t      *ctx,
                                       const vpx_codec_enc_cfg_t *cfg,
138 139
                                       const struct vp8_extracfg *vp8_cfg,
                                       int                        finalize)
John Koleszar's avatar
John Koleszar committed
140
{
141 142
    RANGE_CHECK(cfg, g_w,                   1, 16383); /* 14 bits available */
    RANGE_CHECK(cfg, g_h,                   1, 16383); /* 14 bits available */
John Koleszar's avatar
John Koleszar committed
143 144
    RANGE_CHECK(cfg, g_timebase.den,        1, 1000000000);
    RANGE_CHECK(cfg, g_timebase.num,        1, cfg->g_timebase.den);
145 146
    RANGE_CHECK_HI(cfg, g_profile,          3);
    RANGE_CHECK_HI(cfg, rc_max_quantizer,   63);
147
    RANGE_CHECK_HI(cfg, rc_min_quantizer,   cfg->rc_max_quantizer);
148
    RANGE_CHECK_HI(cfg, g_threads,          64);
149
#if CONFIG_REALTIME_ONLY
150
    RANGE_CHECK_HI(cfg, g_lag_in_frames,    0);
151 152 153 154 155
#elif CONFIG_MULTI_RES_ENCODING
    if (ctx->base.enc.total_encoders > 1)
        RANGE_CHECK_HI(cfg, g_lag_in_frames,    0);
#else
    RANGE_CHECK_HI(cfg, g_lag_in_frames,    25);
John Koleszar's avatar
John Koleszar committed
156
#endif
157
    RANGE_CHECK(cfg, rc_end_usage,          VPX_VBR, VPX_Q);
158 159
    RANGE_CHECK_HI(cfg, rc_undershoot_pct,  1000);
    RANGE_CHECK_HI(cfg, rc_overshoot_pct,   1000);
160
    RANGE_CHECK_HI(cfg, rc_2pass_vbr_bias_pct, 100);
John Koleszar's avatar
John Koleszar committed
161
    RANGE_CHECK(cfg, kf_mode,               VPX_KF_DISABLED, VPX_KF_AUTO);
162 163 164 165 166 167 168 169 170

/* TODO: add spatial re-sampling support and frame dropping in
 * multi-res-encoder.*/
#if CONFIG_MULTI_RES_ENCODING
    if (ctx->base.enc.total_encoders > 1)
        RANGE_CHECK_HI(cfg, rc_resize_allowed,     0);
#else
    RANGE_CHECK_BOOL(cfg, rc_resize_allowed);
#endif
171
    RANGE_CHECK_HI(cfg, rc_dropframe_thresh,   100);
172 173
    RANGE_CHECK_HI(cfg, rc_resize_up_thresh,   100);
    RANGE_CHECK_HI(cfg, rc_resize_down_thresh, 100);
174 175

#if CONFIG_REALTIME_ONLY
John Koleszar's avatar
John Koleszar committed
176
    RANGE_CHECK(cfg,        g_pass,         VPX_RC_ONE_PASS, VPX_RC_ONE_PASS);
177 178 179 180 181
#elif CONFIG_MULTI_RES_ENCODING
    if (ctx->base.enc.total_encoders > 1)
        RANGE_CHECK(cfg,    g_pass,         VPX_RC_ONE_PASS, VPX_RC_ONE_PASS);
#else
    RANGE_CHECK(cfg,        g_pass,         VPX_RC_ONE_PASS, VPX_RC_LAST_PASS);
John Koleszar's avatar
John Koleszar committed
182 183 184 185 186 187 188 189 190 191 192
#endif

    /* VP8 does not support a lower bound on the keyframe interval in
     * automatic keyframe placement mode.
     */
    if (cfg->kf_mode != VPX_KF_DISABLED && cfg->kf_min_dist != cfg->kf_max_dist
        && cfg->kf_min_dist > 0)
        ERROR("kf_min_dist not supported in auto mode, use 0 "
              "or kf_max_dist instead.");

    RANGE_CHECK_BOOL(vp8_cfg,               enable_auto_alt_ref);
193
    RANGE_CHECK(vp8_cfg, cpu_used,           -16, 16);
194 195 196 197 198

#if CONFIG_REALTIME_ONLY && !CONFIG_TEMPORAL_DENOISING
    RANGE_CHECK(vp8_cfg, noise_sensitivity,  0, 0);
#else
    RANGE_CHECK_HI(vp8_cfg, noise_sensitivity,  6);
John Koleszar's avatar
John Koleszar committed
199 200
#endif

201 202
    RANGE_CHECK(vp8_cfg, token_partitions,   VP8_ONE_TOKENPARTITION,
                VP8_EIGHT_TOKENPARTITION);
203
    RANGE_CHECK_HI(vp8_cfg, Sharpness,       7);
204
    RANGE_CHECK(vp8_cfg, arnr_max_frames, 0, 15);
205
    RANGE_CHECK_HI(vp8_cfg, arnr_strength,   6);
206
    RANGE_CHECK(vp8_cfg, arnr_type,       1, 3);
Paul Wilkins's avatar
Paul Wilkins committed
207
    RANGE_CHECK(vp8_cfg, cq_level, 0, 63);
208
    if (finalize && (cfg->rc_end_usage == VPX_CQ || cfg->rc_end_usage == VPX_Q))
209 210
        RANGE_CHECK(vp8_cfg, cq_level,
                    cfg->rc_min_quantizer, cfg->rc_max_quantizer);
John Koleszar's avatar
John Koleszar committed
211

212
#if !(CONFIG_REALTIME_ONLY)
John Koleszar's avatar
John Koleszar committed
213 214
    if (cfg->g_pass == VPX_RC_LAST_PASS)
    {
215
        size_t           packet_sz = sizeof(FIRSTPASS_STATS);
216 217
        int              n_packets = (int)(cfg->rc_twopass_stats_in.sz /
                                          packet_sz);
218
        FIRSTPASS_STATS *stats;
John Koleszar's avatar
John Koleszar committed
219 220 221 222

        if (!cfg->rc_twopass_stats_in.buf)
            ERROR("rc_twopass_stats_in.buf not set.");

223
        if (cfg->rc_twopass_stats_in.sz % packet_sz)
John Koleszar's avatar
John Koleszar committed
224 225
            ERROR("rc_twopass_stats_in.sz indicates truncated packet.");

226
        if (cfg->rc_twopass_stats_in.sz < 2 * packet_sz)
John Koleszar's avatar
John Koleszar committed
227 228
            ERROR("rc_twopass_stats_in requires at least two packets.");

229 230
        stats = (void*)((char *)cfg->rc_twopass_stats_in.buf
                + (n_packets - 1) * packet_sz);
John Koleszar's avatar
John Koleszar committed
231

232
        if ((int)(stats->count + 0.5) != n_packets - 1)
John Koleszar's avatar
John Koleszar committed
233 234
            ERROR("rc_twopass_stats_in missing EOS stats packet");
    }
235
#endif
John Koleszar's avatar
John Koleszar committed
236

237 238 239 240
    RANGE_CHECK(cfg, ts_number_layers, 1, 5);

    if (cfg->ts_number_layers > 1)
    {
241
        unsigned int i;
242 243 244 245 246 247 248 249 250 251 252 253 254 255
        RANGE_CHECK_HI(cfg, ts_periodicity, 16);

        for (i=1; i<cfg->ts_number_layers; i++)
            if (cfg->ts_target_bitrate[i] <= cfg->ts_target_bitrate[i-1])
                ERROR("ts_target_bitrate entries are not strictly increasing");

        RANGE_CHECK(cfg, ts_rate_decimator[cfg->ts_number_layers-1], 1, 1);
        for (i=cfg->ts_number_layers-2; i>0; i--)
            if (cfg->ts_rate_decimator[i-1] != 2*cfg->ts_rate_decimator[i])
                ERROR("ts_rate_decimator factors are not powers of 2");

        RANGE_CHECK_HI(cfg, ts_layer_id[i], cfg->ts_number_layers-1);
    }

256 257 258 259 260
#if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
    if(cfg->g_threads > (1 << vp8_cfg->token_partitions))
        ERROR("g_threads cannot be bigger than number of token partitions");
#endif

John Koleszar's avatar
John Koleszar committed
261 262 263 264 265 266 267 268 269
    return VPX_CODEC_OK;
}


static vpx_codec_err_t validate_img(vpx_codec_alg_priv_t *ctx,
                                    const vpx_image_t    *img)
{
    switch (img->fmt)
    {
270 271 272 273
    case VPX_IMG_FMT_YV12:
    case VPX_IMG_FMT_I420:
    case VPX_IMG_FMT_VPXI420:
    case VPX_IMG_FMT_VPXYV12:
John Koleszar's avatar
John Koleszar committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287
        break;
    default:
        ERROR("Invalid image format. Only YV12 and I420 images are supported");
    }

    if ((img->d_w != ctx->cfg.g_w) || (img->d_h != ctx->cfg.g_h))
        ERROR("Image size must match encoder init configuration size");

    return VPX_CODEC_OK;
}


static vpx_codec_err_t set_vp8e_config(VP8_CONFIG *oxcf,
                                       vpx_codec_enc_cfg_t cfg,
288 289
                                       struct vp8_extracfg vp8_cfg,
                                       vpx_codec_priv_enc_mr_cfg_t *mr_cfg)
John Koleszar's avatar
John Koleszar committed
290 291 292 293 294 295
{
    oxcf->multi_threaded         = cfg.g_threads;
    oxcf->Version               = cfg.g_profile;

    oxcf->Width                 = cfg.g_w;
    oxcf->Height                = cfg.g_h;
296
    oxcf->timebase              = cfg.g_timebase;
John Koleszar's avatar
John Koleszar committed
297

298
    oxcf->error_resilient_mode = cfg.g_error_resilient;
John Koleszar's avatar
John Koleszar committed
299 300 301 302 303 304 305 306 307 308 309 310 311 312

    switch (cfg.g_pass)
    {
    case VPX_RC_ONE_PASS:
        oxcf->Mode = MODE_BESTQUALITY;
        break;
    case VPX_RC_FIRST_PASS:
        oxcf->Mode = MODE_FIRSTPASS;
        break;
    case VPX_RC_LAST_PASS:
        oxcf->Mode = MODE_SECONDPASS_BEST;
        break;
    }

313
    if (cfg.g_pass == VPX_RC_FIRST_PASS || cfg.g_pass == VPX_RC_ONE_PASS)
John Koleszar's avatar
John Koleszar committed
314
    {
315 316
        oxcf->allow_lag     = 0;
        oxcf->lag_in_frames = 0;
John Koleszar's avatar
John Koleszar committed
317 318 319
    }
    else
    {
320 321
        oxcf->allow_lag     = (cfg.g_lag_in_frames) > 0;
        oxcf->lag_in_frames = cfg.g_lag_in_frames;
John Koleszar's avatar
John Koleszar committed
322 323 324 325 326 327 328 329 330
    }

    oxcf->allow_df               = (cfg.rc_dropframe_thresh > 0);
    oxcf->drop_frames_water_mark   = cfg.rc_dropframe_thresh;

    oxcf->allow_spatial_resampling = cfg.rc_resize_allowed;
    oxcf->resample_up_water_mark   = cfg.rc_resize_up_thresh;
    oxcf->resample_down_water_mark = cfg.rc_resize_down_thresh;

331 332 333 334 335 336 337 338
    if (cfg.rc_end_usage == VPX_VBR) {
      oxcf->end_usage = USAGE_LOCAL_FILE_PLAYBACK;
    } else if (cfg.rc_end_usage == VPX_CBR) {
      oxcf->end_usage = USAGE_STREAM_FROM_SERVER;
    } else if (cfg.rc_end_usage == VPX_CQ) {
      oxcf->end_usage = USAGE_CONSTRAINED_QUALITY;
    } else if (cfg.rc_end_usage == VPX_Q) {
      oxcf->end_usage = USAGE_CONSTANT_QUALITY;
Paul Wilkins's avatar
Paul Wilkins committed
339
    }
John Koleszar's avatar
John Koleszar committed
340

341
    oxcf->target_bandwidth         = cfg.rc_target_bitrate;
342
    oxcf->rc_max_intra_bitrate_pct = vp8_cfg.rc_max_intra_bitrate_pct;
John Koleszar's avatar
John Koleszar committed
343

344 345 346
    oxcf->best_allowed_q           = cfg.rc_min_quantizer;
    oxcf->worst_allowed_q          = cfg.rc_max_quantizer;
    oxcf->cq_level                 = vp8_cfg.cq_level;
John Koleszar's avatar
John Koleszar committed
347 348
    oxcf->fixed_q = -1;

349 350
    oxcf->under_shoot_pct          = cfg.rc_undershoot_pct;
    oxcf->over_shoot_pct           = cfg.rc_overshoot_pct;
John Koleszar's avatar
John Koleszar committed
351

352 353 354 355
    oxcf->maximum_buffer_size_in_ms   = cfg.rc_buf_sz;
    oxcf->starting_buffer_level_in_ms = cfg.rc_buf_initial_sz;
    oxcf->optimal_buffer_level_in_ms  = cfg.rc_buf_optimal_sz;

356 357 358
    oxcf->maximum_buffer_size      = cfg.rc_buf_sz;
    oxcf->starting_buffer_level    = cfg.rc_buf_initial_sz;
    oxcf->optimal_buffer_level     = cfg.rc_buf_optimal_sz;
John Koleszar's avatar
John Koleszar committed
359

360
    oxcf->two_pass_vbrbias         = cfg.rc_2pass_vbr_bias_pct;
John Koleszar's avatar
John Koleszar committed
361 362 363
    oxcf->two_pass_vbrmin_section  = cfg.rc_2pass_vbr_minsection_pct;
    oxcf->two_pass_vbrmax_section  = cfg.rc_2pass_vbr_maxsection_pct;

364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
    oxcf->auto_key                 = cfg.kf_mode == VPX_KF_AUTO
                                       && cfg.kf_min_dist != cfg.kf_max_dist;
    oxcf->key_freq                 = cfg.kf_max_dist;

    oxcf->number_of_layers         = cfg.ts_number_layers;
    oxcf->periodicity              = cfg.ts_periodicity;

    if (oxcf->number_of_layers > 1)
    {
        memcpy (oxcf->target_bitrate, cfg.ts_target_bitrate,
                          sizeof(cfg.ts_target_bitrate));
        memcpy (oxcf->rate_decimator, cfg.ts_rate_decimator,
                          sizeof(cfg.ts_rate_decimator));
        memcpy (oxcf->layer_id, cfg.ts_layer_id, sizeof(cfg.ts_layer_id));
    }
John Koleszar's avatar
John Koleszar committed
379

380
#if CONFIG_MULTI_RES_ENCODING
381 382 383 384
    /* When mr_cfg is NULL, oxcf->mr_total_resolutions and oxcf->mr_encoder_id
     * are both memset to 0, which ensures the correct logic under this
     * situation.
     */
385 386 387 388 389 390 391 392 393 394
    if(mr_cfg)
    {
        oxcf->mr_total_resolutions        = mr_cfg->mr_total_resolutions;
        oxcf->mr_encoder_id               = mr_cfg->mr_encoder_id;
        oxcf->mr_down_sampling_factor.num = mr_cfg->mr_down_sampling_factor.num;
        oxcf->mr_down_sampling_factor.den = mr_cfg->mr_down_sampling_factor.den;
        oxcf->mr_low_res_mode_info        = mr_cfg->mr_low_res_mode_info;
    }
#endif

395 396 397 398 399 400
    oxcf->cpu_used               = vp8_cfg.cpu_used;
    oxcf->encode_breakout        = vp8_cfg.static_thresh;
    oxcf->play_alternate         = vp8_cfg.enable_auto_alt_ref;
    oxcf->noise_sensitivity      = vp8_cfg.noise_sensitivity;
    oxcf->Sharpness              = vp8_cfg.Sharpness;
    oxcf->token_partitions       = vp8_cfg.token_partitions;
John Koleszar's avatar
John Koleszar committed
401

402 403
    oxcf->two_pass_stats_in      = cfg.rc_twopass_stats_in;
    oxcf->output_pkt_list        = vp8_cfg.pkt_list;
John Koleszar's avatar
John Koleszar committed
404

405 406 407
    oxcf->arnr_max_frames        = vp8_cfg.arnr_max_frames;
    oxcf->arnr_strength          = vp8_cfg.arnr_strength;
    oxcf->arnr_type              = vp8_cfg.arnr_type;
John Koleszar's avatar
John Koleszar committed
408

409
    oxcf->tuning                 = vp8_cfg.tuning;
John Koleszar's avatar
John Koleszar committed
410 411 412 413 414 415 416 417 418 419 420 421

    /*
        printf("Current VP8 Settings: \n");
        printf("target_bandwidth: %d\n", oxcf->target_bandwidth);
        printf("noise_sensitivity: %d\n", oxcf->noise_sensitivity);
        printf("Sharpness: %d\n",    oxcf->Sharpness);
        printf("cpu_used: %d\n",  oxcf->cpu_used);
        printf("Mode: %d\n",     oxcf->Mode);
        printf("auto_key: %d\n",  oxcf->auto_key);
        printf("key_freq: %d\n", oxcf->key_freq);
        printf("end_usage: %d\n", oxcf->end_usage);
        printf("under_shoot_pct: %d\n", oxcf->under_shoot_pct);
422
        printf("over_shoot_pct: %d\n", oxcf->over_shoot_pct);
John Koleszar's avatar
John Koleszar committed
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
        printf("starting_buffer_level: %d\n", oxcf->starting_buffer_level);
        printf("optimal_buffer_level: %d\n",  oxcf->optimal_buffer_level);
        printf("maximum_buffer_size: %d\n", oxcf->maximum_buffer_size);
        printf("fixed_q: %d\n",  oxcf->fixed_q);
        printf("worst_allowed_q: %d\n", oxcf->worst_allowed_q);
        printf("best_allowed_q: %d\n", oxcf->best_allowed_q);
        printf("allow_spatial_resampling: %d\n",  oxcf->allow_spatial_resampling);
        printf("resample_down_water_mark: %d\n", oxcf->resample_down_water_mark);
        printf("resample_up_water_mark: %d\n", oxcf->resample_up_water_mark);
        printf("allow_df: %d\n", oxcf->allow_df);
        printf("drop_frames_water_mark: %d\n", oxcf->drop_frames_water_mark);
        printf("two_pass_vbrbias: %d\n",  oxcf->two_pass_vbrbias);
        printf("two_pass_vbrmin_section: %d\n", oxcf->two_pass_vbrmin_section);
        printf("two_pass_vbrmax_section: %d\n", oxcf->two_pass_vbrmax_section);
        printf("allow_lag: %d\n", oxcf->allow_lag);
        printf("lag_in_frames: %d\n", oxcf->lag_in_frames);
        printf("play_alternate: %d\n", oxcf->play_alternate);
        printf("Version: %d\n", oxcf->Version);
        printf("multi_threaded: %d\n",   oxcf->multi_threaded);
        printf("encode_breakout: %d\n", oxcf->encode_breakout);
    */
    return VPX_CODEC_OK;
}

static vpx_codec_err_t vp8e_set_config(vpx_codec_alg_priv_t       *ctx,
                                       const vpx_codec_enc_cfg_t  *cfg)
{
    vpx_codec_err_t res;

452
    if (((cfg->g_w != ctx->cfg.g_w) || (cfg->g_h != ctx->cfg.g_h))
453
        && (cfg->g_lag_in_frames > 1 || cfg->g_pass != VPX_RC_ONE_PASS))
John Koleszar's avatar
John Koleszar committed
454 455 456 457 458 459 460 461 462 463
        ERROR("Cannot change width or height after initialization");

    /* Prevent increasing lag_in_frames. This check is stricter than it needs
     * to be -- the limit is not increasing past the first lag_in_frames
     * value, but we don't track the initial config, only the last successful
     * config.
     */
    if ((cfg->g_lag_in_frames > ctx->cfg.g_lag_in_frames))
        ERROR("Cannot increase lag_in_frames");

464
    res = validate_config(ctx, cfg, &ctx->vp8_cfg, 0);
John Koleszar's avatar
John Koleszar committed
465 466 467 468

    if (!res)
    {
        ctx->cfg = *cfg;
469
        set_vp8e_config(&ctx->oxcf, ctx->cfg, ctx->vp8_cfg, NULL);
John Koleszar's avatar
John Koleszar committed
470 471 472 473 474 475 476 477
        vp8_change_config(ctx->cpi, &ctx->oxcf);
    }

    return res;
}

int vp8_reverse_trans(int);

478 479 480 481 482 483 484 485
static vpx_codec_err_t get_quantizer(vpx_codec_alg_priv_t *ctx, va_list args)
{
  int *const arg = va_arg(args, int *);
  if (arg == NULL)
    return VPX_CODEC_INVALID_PARAM;
  *arg = vp8_get_quantizer(ctx->cpi);
  return VPX_CODEC_OK;
}
John Koleszar's avatar
John Koleszar committed
486

487
static vpx_codec_err_t get_quantizer64(vpx_codec_alg_priv_t *ctx, va_list args)
John Koleszar's avatar
John Koleszar committed
488
{
489 490 491 492 493 494
  int *const arg = va_arg(args, int *);
  if (arg == NULL)
    return VPX_CODEC_INVALID_PARAM;
  *arg = vp8_reverse_trans(vp8_get_quantizer(ctx->cpi));
  return VPX_CODEC_OK;
}
John Koleszar's avatar
John Koleszar committed
495

496 497 498 499 500 501 502 503 504 505 506
static vpx_codec_err_t update_extracfg(vpx_codec_alg_priv_t *ctx,
                                       const struct vp8_extracfg *extra_cfg)
{
  const vpx_codec_err_t res = validate_config(ctx, &ctx->cfg, extra_cfg, 0);
  if (res == VPX_CODEC_OK) {
    ctx->vp8_cfg = *extra_cfg;
    set_vp8e_config(&ctx->oxcf, ctx->cfg, ctx->vp8_cfg, NULL);
    vp8_change_config(ctx->cpi, &ctx->oxcf);
  }
  return res;
}
John Koleszar's avatar
John Koleszar committed
507

508 509 510 511 512 513
static vpx_codec_err_t set_cpu_used(vpx_codec_alg_priv_t *ctx, va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.cpu_used = CAST(VP8E_SET_CPUUSED, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
514

515 516 517 518 519 520 521
static vpx_codec_err_t set_enable_auto_alt_ref(vpx_codec_alg_priv_t *ctx,
                                               va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.enable_auto_alt_ref = CAST(VP8E_SET_ENABLEAUTOALTREF, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
522

523 524 525 526 527 528
static vpx_codec_err_t set_noise_sensitivity(vpx_codec_alg_priv_t *ctx,
                                             va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.noise_sensitivity = CAST(VP8E_SET_NOISE_SENSITIVITY, args);
  return update_extracfg(ctx, &extra_cfg);
John Koleszar's avatar
John Koleszar committed
529 530
}

531 532 533 534 535 536 537 538 539 540 541 542 543 544
static vpx_codec_err_t set_sharpness(vpx_codec_alg_priv_t *ctx, va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.Sharpness = CAST(VP8E_SET_SHARPNESS, args);
  return update_extracfg(ctx, &extra_cfg);
}

static vpx_codec_err_t set_static_thresh(vpx_codec_alg_priv_t *ctx,
                                         va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.static_thresh = CAST(VP8E_SET_STATIC_THRESHOLD, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
545

546 547
static vpx_codec_err_t set_token_partitions(vpx_codec_alg_priv_t *ctx,
                                            va_list args)
John Koleszar's avatar
John Koleszar committed
548
{
549 550 551 552
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.token_partitions = CAST(VP8E_SET_TOKEN_PARTITIONS, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
553

554 555 556 557 558 559 560
static vpx_codec_err_t set_arnr_max_frames(vpx_codec_alg_priv_t *ctx,
                                           va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.arnr_max_frames = CAST(VP8E_SET_ARNR_MAXFRAMES, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
561

562 563 564 565 566 567 568
static vpx_codec_err_t set_arnr_strength(vpx_codec_alg_priv_t *ctx,
                                         va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.arnr_strength = CAST(VP8E_SET_ARNR_STRENGTH, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
569

570 571 572 573 574 575
static vpx_codec_err_t set_arnr_type(vpx_codec_alg_priv_t *ctx, va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.arnr_type = CAST(VP8E_SET_ARNR_TYPE, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
576

577 578 579 580 581 582
static vpx_codec_err_t set_tuning(vpx_codec_alg_priv_t *ctx, va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.tuning = CAST(VP8E_SET_TUNING, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
583

584 585 586 587 588 589
static vpx_codec_err_t set_cq_level(vpx_codec_alg_priv_t *ctx, va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.cq_level = CAST(VP8E_SET_CQ_LEVEL, args);
  return update_extracfg(ctx, &extra_cfg);
}
John Koleszar's avatar
John Koleszar committed
590

591 592 593 594 595 596 597
static vpx_codec_err_t set_rc_max_intra_bitrate_pct(vpx_codec_alg_priv_t *ctx,
                                                    va_list args)
{
  struct vp8_extracfg extra_cfg = ctx->vp8_cfg;
  extra_cfg.rc_max_intra_bitrate_pct =
      CAST(VP8E_SET_MAX_INTRA_BITRATE_PCT, args);
  return update_extracfg(ctx, &extra_cfg);
John Koleszar's avatar
John Koleszar committed
598
}
599 600 601 602

static vpx_codec_err_t vp8e_mr_alloc_mem(const vpx_codec_enc_cfg_t *cfg,
                                        void **mem_loc)
{
603 604
    vpx_codec_err_t res = 0;

605
#if CONFIG_MULTI_RES_ENCODING
606
    LOWER_RES_FRAME_INFO *shared_mem_loc;
607 608 609
    int mb_rows = ((cfg->g_w + 15) >>4);
    int mb_cols = ((cfg->g_h + 15) >>4);

610 611
    shared_mem_loc = calloc(1, sizeof(LOWER_RES_FRAME_INFO));
    if(!shared_mem_loc)
612
    {
613
        res = VPX_CODEC_MEM_ERROR;
614 615 616 617 618
    }

    shared_mem_loc->mb_info = calloc(mb_rows*mb_cols, sizeof(LOWER_RES_MB_INFO));
    if(!(shared_mem_loc->mb_info))
    {
619
        res = VPX_CODEC_MEM_ERROR;
620 621
    }
    else
622 623
    {
        *mem_loc = (void *)shared_mem_loc;
624
        res = VPX_CODEC_OK;
625
    }
626
#endif
627
    return res;
628 629 630 631
}

static vpx_codec_err_t vp8e_init(vpx_codec_ctx_t *ctx,
                                 vpx_codec_priv_enc_mr_cfg_t *mr_cfg)
John Koleszar's avatar
John Koleszar committed
632
{
633
    vpx_codec_err_t        res = VPX_CODEC_OK;
John Koleszar's avatar
John Koleszar committed
634 635 636 637
    struct vpx_codec_alg_priv *priv;
    vpx_codec_enc_cfg_t       *cfg;
    unsigned int               i;

638
    struct VP8_COMP *optr;
John Koleszar's avatar
John Koleszar committed
639

640
    vp8_rtcd();
641

John Koleszar's avatar
John Koleszar committed
642 643 644 645
    if (!ctx->priv)
    {
        priv = calloc(1, sizeof(struct vpx_codec_alg_priv));

646
        if (!priv)
John Koleszar's avatar
John Koleszar committed
647
        {
648 649 650 651 652 653 654 655 656 657 658 659 660
            return VPX_CODEC_MEM_ERROR;
        }

        ctx->priv = &priv->base;
        ctx->priv->sz = sizeof(*ctx->priv);
        ctx->priv->iface = ctx->iface;
        ctx->priv->alg_priv = priv;
        ctx->priv->init_flags = ctx->init_flags;

        if (ctx->config.enc)
        {
            /* Update the reference to the config structure to an
             * internal copy.
John Koleszar's avatar
John Koleszar committed
661
             */
662 663 664
            ctx->priv->alg_priv->cfg = *ctx->config.enc;
            ctx->config.enc = &ctx->priv->alg_priv->cfg;
        }
John Koleszar's avatar
John Koleszar committed
665

666
        cfg =  &ctx->priv->alg_priv->cfg;
John Koleszar's avatar
John Koleszar committed
667

668
        /* Select the extra vp8 configuration table based on the current
669 670 671 672 673 674
         * usage value. If the current usage value isn't found, use the
         * values for usage case 0.
         */
        for (i = 0;
             extracfg_map[i].usage && extracfg_map[i].usage != cfg->g_usage;
             i++);
John Koleszar's avatar
John Koleszar committed
675

676 677
        priv->vp8_cfg = extracfg_map[i].cfg;
        priv->vp8_cfg.pkt_list = &priv->pkt_list.head;
John Koleszar's avatar
John Koleszar committed
678

679
        priv->cx_data_sz = priv->cfg.g_w * priv->cfg.g_h * 3 / 2 * 2;
John Koleszar's avatar
John Koleszar committed
680

681
        if (priv->cx_data_sz < 32768) priv->cx_data_sz = 32768;
John Koleszar's avatar
John Koleszar committed
682

683
        priv->cx_data = malloc(priv->cx_data_sz);
John Koleszar's avatar
John Koleszar committed
684

685 686 687 688 689
        if (!priv->cx_data)
        {
            return VPX_CODEC_MEM_ERROR;
        }

690 691 692 693 694
        if(mr_cfg)
            ctx->priv->enc.total_encoders   = mr_cfg->mr_total_resolutions;
        else
            ctx->priv->enc.total_encoders   = 1;

695
        res = validate_config(priv, &priv->cfg, &priv->vp8_cfg, 0);
696 697 698 699 700

        if (!res)
        {
            set_vp8e_config(&ctx->priv->alg_priv->oxcf,
                             ctx->priv->alg_priv->cfg,
701 702 703
                             ctx->priv->alg_priv->vp8_cfg,
                             mr_cfg);

704 705 706 707 708 709
            optr = vp8_create_compressor(&ctx->priv->alg_priv->oxcf);

            if (!optr)
                res = VPX_CODEC_MEM_ERROR;
            else
                ctx->priv->alg_priv->cpi = optr;
John Koleszar's avatar
John Koleszar committed
710 711 712 713 714 715 716 717
        }
    }

    return res;
}

static vpx_codec_err_t vp8e_destroy(vpx_codec_alg_priv_t *ctx)
{
718 719 720
#if CONFIG_MULTI_RES_ENCODING
    /* Free multi-encoder shared memory */
    if (ctx->oxcf.mr_total_resolutions > 0 && (ctx->oxcf.mr_encoder_id == ctx->oxcf.mr_total_resolutions-1))
721 722 723
    {
        LOWER_RES_FRAME_INFO *shared_mem_loc = (LOWER_RES_FRAME_INFO *)ctx->oxcf.mr_low_res_mode_info;
        free(shared_mem_loc->mb_info);
724
        free(ctx->oxcf.mr_low_res_mode_info);
725
    }
726
#endif
John Koleszar's avatar
John Koleszar committed
727 728 729 730 731 732 733 734 735 736 737

    free(ctx->cx_data);
    vp8_remove_compressor(&ctx->cpi);
    free(ctx);
    return VPX_CODEC_OK;
}

static vpx_codec_err_t image2yuvconfig(const vpx_image_t   *img,
                                       YV12_BUFFER_CONFIG  *yv12)
{
    vpx_codec_err_t        res = VPX_CODEC_OK;
738 739 740
    yv12->y_buffer = img->planes[VPX_PLANE_Y];
    yv12->u_buffer = img->planes[VPX_PLANE_U];
    yv12->v_buffer = img->planes[VPX_PLANE_V];
John Koleszar's avatar
John Koleszar committed
741

742 743
    yv12->y_crop_width  = img->d_w;
    yv12->y_crop_height = img->d_h;
John Koleszar's avatar
John Koleszar committed
744 745 746 747 748
    yv12->y_width  = img->d_w;
    yv12->y_height = img->d_h;
    yv12->uv_width = (1 + yv12->y_width) / 2;
    yv12->uv_height = (1 + yv12->y_height) / 2;

749 750
    yv12->y_stride = img->stride[VPX_PLANE_Y];
    yv12->uv_stride = img->stride[VPX_PLANE_U];
John Koleszar's avatar
John Koleszar committed
751

752
    yv12->border  = (img->stride[VPX_PLANE_Y] - img->w) / 2;
John Koleszar's avatar
John Koleszar committed
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
    return res;
}

static void pick_quickcompress_mode(vpx_codec_alg_priv_t  *ctx,
                                    unsigned long          duration,
                                    unsigned long          deadline)
{
    unsigned int new_qc;

#if !(CONFIG_REALTIME_ONLY)
    /* Use best quality mode if no deadline is given. */
    new_qc = MODE_BESTQUALITY;

    if (deadline)
    {
        uint64_t     duration_us;

        /* Convert duration parameter from stream timebase to microseconds */
        duration_us = (uint64_t)duration * 1000000
                      * (uint64_t)ctx->cfg.g_timebase.num
                      / (uint64_t)ctx->cfg.g_timebase.den;

        /* If the deadline is more that the duration this frame is to be shown,
         * use good quality mode. Otherwise use realtime mode.
         */
        new_qc = (deadline > duration_us) ? MODE_GOODQUALITY : MODE_REALTIME;
    }

#else
    new_qc = MODE_REALTIME;
#endif

    if (ctx->cfg.g_pass == VPX_RC_FIRST_PASS)
        new_qc = MODE_FIRSTPASS;
    else if (ctx->cfg.g_pass == VPX_RC_LAST_PASS)
        new_qc = (new_qc == MODE_BESTQUALITY)
                 ? MODE_SECONDPASS_BEST
                 : MODE_SECONDPASS;

    if (ctx->oxcf.Mode != new_qc)
    {
        ctx->oxcf.Mode = new_qc;
        vp8_change_config(ctx->cpi, &ctx->oxcf);
    }
}


static vpx_codec_err_t vp8e_encode(vpx_codec_alg_priv_t  *ctx,
                                   const vpx_image_t     *img,
                                   vpx_codec_pts_t        pts,
                                   unsigned long          duration,
                                   vpx_enc_frame_flags_t  flags,
                                   unsigned long          deadline)
{
    vpx_codec_err_t res = VPX_CODEC_OK;

809 810 811
    if (!ctx->cfg.rc_target_bitrate)
        return res;

John Koleszar's avatar
John Koleszar committed
812 813 814
    if (img)
        res = validate_img(ctx, img);

815 816 817
    if (!res)
        res = validate_config(ctx, &ctx->cfg, &ctx->vp8_cfg, 1);

John Koleszar's avatar
John Koleszar committed
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
    pick_quickcompress_mode(ctx, duration, deadline);
    vpx_codec_pkt_list_init(&ctx->pkt_list);

    /* Handle Flags */
    if (((flags & VP8_EFLAG_NO_UPD_GF) && (flags & VP8_EFLAG_FORCE_GF))
        || ((flags & VP8_EFLAG_NO_UPD_ARF) && (flags & VP8_EFLAG_FORCE_ARF)))
    {
        ctx->base.err_detail = "Conflicting flags.";
        return VPX_CODEC_INVALID_PARAM;
    }

    if (flags & (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF
                 | VP8_EFLAG_NO_REF_ARF))
    {
        int ref = 7;

        if (flags & VP8_EFLAG_NO_REF_LAST)
Johann's avatar
Johann committed
835
            ref ^= VP8_LAST_FRAME;
John Koleszar's avatar
John Koleszar committed
836 837

        if (flags & VP8_EFLAG_NO_REF_GF)
Johann's avatar
Johann committed
838
            ref ^= VP8_GOLD_FRAME;
John Koleszar's avatar
John Koleszar committed
839 840

        if (flags & VP8_EFLAG_NO_REF_ARF)
Johann's avatar
Johann committed
841
            ref ^= VP8_ALTR_FRAME;
John Koleszar's avatar
John Koleszar committed
842 843 844 845 846 847 848 849 850 851 852

        vp8_use_as_reference(ctx->cpi, ref);
    }

    if (flags & (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF
                 | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_FORCE_GF
                 | VP8_EFLAG_FORCE_ARF))
    {
        int upd = 7;

        if (flags & VP8_EFLAG_NO_UPD_LAST)
Johann's avatar
Johann committed
853
            upd ^= VP8_LAST_FRAME;
John Koleszar's avatar
John Koleszar committed
854 855

        if (flags & VP8_EFLAG_NO_UPD_GF)
Johann's avatar
Johann committed
856
            upd ^= VP8_GOLD_FRAME;
John Koleszar's avatar
John Koleszar committed
857 858

        if (flags & VP8_EFLAG_NO_UPD_ARF)
Johann's avatar
Johann committed
859
            upd ^= VP8_ALTR_FRAME;
John Koleszar's avatar
John Koleszar committed
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875

        vp8_update_reference(ctx->cpi, upd);
    }

    if (flags & VP8_EFLAG_NO_UPD_ENTROPY)
    {
        vp8_update_entropy(ctx->cpi, 0);
    }

    /* Handle fixed keyframe intervals */
    if (ctx->cfg.kf_mode == VPX_KF_AUTO
        && ctx->cfg.kf_min_dist == ctx->cfg.kf_max_dist)
    {
        if (++ctx->fixed_kf_cntr > ctx->cfg.kf_min_dist)
        {
            flags |= VPX_EFLAG_FORCE_KF;
876
            ctx->fixed_kf_cntr = 1;
John Koleszar's avatar
John Koleszar committed
877 878 879 880 881 882 883 884
        }
    }

    /* Initialize the encoder instance on the first frame*/
    if (!res && ctx->cpi)
    {
        unsigned int lib_flags;
        YV12_BUFFER_CONFIG sd;
885
        int64_t dst_time_stamp, dst_end_time_stamp;
John Koleszar's avatar
John Koleszar committed
886 887
        unsigned long size, cx_data_sz;
        unsigned char *cx_data;
888 889
        unsigned char *cx_data_end;
        int comp_data_state = 0;
John Koleszar's avatar
John Koleszar committed
890 891 892 893 894

        /* Set up internal flags */
        if (ctx->base.init_flags & VPX_CODEC_USE_PSNR)
            ((VP8_COMP *)ctx->cpi)->b_calculate_psnr = 1;

895 896 897
        if (ctx->base.init_flags & VPX_CODEC_USE_OUTPUT_PARTITION)
            ((VP8_COMP *)ctx->cpi)->output_partition = 1;

John Koleszar's avatar
John Koleszar committed
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
        /* Convert API flags to internal codec lib flags */
        lib_flags = (flags & VPX_EFLAG_FORCE_KF) ? FRAMEFLAGS_KEY : 0;

        /* vp8 use 10,000,000 ticks/second as time stamp */
        dst_time_stamp    = pts * 10000000 * ctx->cfg.g_timebase.num / ctx->cfg.g_timebase.den;
        dst_end_time_stamp = (pts + duration) * 10000000 * ctx->cfg.g_timebase.num / ctx->cfg.g_timebase.den;

        if (img != NULL)
        {
            res = image2yuvconfig(img, &sd);

            if (vp8_receive_raw_frame(ctx->cpi, ctx->next_frame_flag | lib_flags,
                                      &sd, dst_time_stamp, dst_end_time_stamp))
            {
                VP8_COMP *cpi = (VP8_COMP *)ctx->cpi;
                res = update_error_state(ctx, &cpi->common.error);
            }

            /* reset for next frame */
            ctx->next_frame_flag = 0;
        }

        cx_data = ctx->cx_data;
        cx_data_sz = ctx->cx_data_sz;
922
        cx_data_end = ctx->cx_data + cx_data_sz;
John Koleszar's avatar
John Koleszar committed
923 924
        lib_flags = 0;

925
        while (cx_data_sz >= ctx->cx_data_sz / 2)
John Koleszar's avatar
John Koleszar committed
926
        {
927 928 929 930 931 932 933 934 935 936 937 938 939 940
            comp_data_state = vp8_get_compressed_data(ctx->cpi,
                                                  &lib_flags,
                                                  &size,
                                                  cx_data,
                                                  cx_data_end,
                                                  &dst_time_stamp,
                                                  &dst_end_time_stamp,
                                                  !img);

            if(comp_data_state == VPX_CODEC_CORRUPT_FRAME)
                return VPX_CODEC_CORRUPT_FRAME;
            else if(comp_data_state == -1)
                break;

John Koleszar's avatar
John Koleszar committed
941 942 943 944 945 946 947
            if (size)
            {
                vpx_codec_pts_t    round, delta;
                vpx_codec_cx_pkt_t pkt;
                VP8_COMP *cpi = (VP8_COMP *)ctx->cpi;

                /* Add the frame packet to the list of returned packets. */
948
                round = (vpx_codec_pts_t)10000000
949
                        * ctx->cfg.g_timebase.num / 2 - 1;
John Koleszar's avatar
John Koleszar committed
950 951 952 953 954
                delta = (dst_end_time_stamp - dst_time_stamp);
                pkt.kind = VPX_CODEC_CX_FRAME_PKT;
                pkt.data.frame.pts =
                    (dst_time_stamp * ctx->cfg.g_timebase.den + round)
                    / ctx->cfg.g_timebase.num / 10000000;
955 956 957
                pkt.data.frame.duration = (unsigned long)
                    ((delta * ctx->cfg.g_timebase.den + round)
                    / ctx->cfg.g_timebase.num / 10000000);
John Koleszar's avatar
John Koleszar committed
958 959 960 961 962 963 964 965 966
                pkt.data.frame.flags = lib_flags << 16;

                if (lib_flags & FRAMEFLAGS_KEY)
                    pkt.data.frame.flags |= VPX_FRAME_IS_KEY;

                if (!cpi->common.show_frame)
                {
                    pkt.data.frame.flags |= VPX_FRAME_IS_INVISIBLE;

967 968 969 970 971
                    /* This timestamp should be as close as possible to the
                     * prior PTS so that if a decoder uses pts to schedule when
                     * to do this, we start right after last frame was decoded.
                     * Invisible frames have no duration.
                     */
972 973 974
                    pkt.data.frame.pts = ((cpi->last_time_stamp_seen
                        * ctx->cfg.g_timebase.den + round)
                        / ctx->cfg.g_timebase.num / 10000000) + 1;
John Koleszar's avatar
John Koleszar committed
975 976 977
                    pkt.data.frame.duration = 0;
                }

978 979 980
                if (cpi->droppable)
                    pkt.data.frame.flags |= VPX_FRAME_IS_DROPPABLE;

981 982 983 984 985
                if (cpi->output_partition)
                {
                    int i;
                    const int num_partitions =
                            (1 << cpi->common.multi_token_partition) + 1;
986 987 988

                    pkt.data.frame.flags |= VPX_FRAME_IS_FRAGMENT;

989 990
                    for (i = 0; i < num_partitions; ++i)
                    {
991 992 993
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
                        pkt.data.frame.buf = cpi->partition_d[i];
#else
994
                        pkt.data.frame.buf = cx_data;
995 996 997
                        cx_data += cpi->partition_sz[i];
                        cx_data_sz -= cpi->partition_sz[i];
#endif
998 999 1000
                        pkt.data.frame.sz = cpi->partition_sz[i];
                        pkt.data.frame.partition_id = i;
                        /* don't set the fragment bit for the last partition */
1001 1002
                        if (i == (num_partitions - 1))
                            pkt.data.frame.flags &= ~VPX_FRAME_IS_FRAGMENT;
1003 1004
                        vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
                    }
1005 1006 1007 1008 1009 1010 1011 1012
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
                    /* In lagged mode the encoder can buffer multiple frames.
                     * We don't want this in partitioned output because
                     * partitions are spread all over the output buffer.
                     * So, force an exit!
                     */
                    cx_data_sz -= ctx->cx_data_sz / 2;
#endif
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
                }
                else
                {
                    pkt.data.frame.buf = cx_data;
                    pkt.data.frame.sz  = size;
                    pkt.data.frame.partition_id = -1;
                    vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
                    cx_data += size;
                    cx_data_sz -= size;
                }
John Koleszar's avatar
John Koleszar committed
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
            }
        }
    }

    return res;
}


static const vpx_codec_cx_pkt_t *vp8e_get_cxdata(vpx_codec_alg_priv_t  *ctx,
        vpx_codec_iter_t      *iter)
{
    return vpx_codec_pkt_list_get(&ctx->pkt_list.head, iter);
}

static vpx_codec_err_t vp8e_set_reference(vpx_codec_alg_priv_t *ctx,
1038
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
{
    vpx_ref_frame_t *data = va_arg(args, vpx_ref_frame_t *);

    if (data)
    {
        vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data;
        YV12_BUFFER_CONFIG sd;

        image2yuvconfig(&frame->img, &sd);
        vp8_set_reference(ctx->cpi, frame->frame_type, &sd);
        return VPX_CODEC_OK;
    }
    else
        return VPX_CODEC_INVALID_PARAM;

}

static vpx_codec_err_t vp8e_get_reference(vpx_codec_alg_priv_t *ctx,
1057
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
{

    vpx_ref_frame_t *data = va_arg(args, vpx_ref_frame_t *);

    if (data)
    {
        vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data;
        YV12_BUFFER_CONFIG sd;

        image2yuvconfig(&frame->img, &sd);
        vp8_get_reference(ctx->cpi, frame->frame_type, &sd);
        return VPX_CODEC_OK;
    }
    else
        return VPX_CODEC_INVALID_PARAM;
}

static vpx_codec_err_t vp8e_set_previewpp(vpx_codec_alg_priv_t *ctx,
1076
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1077
{
1078
#if CONFIG_POSTPROC
John Koleszar's avatar
John Koleszar committed
1079 1080 1081 1082 1083 1084 1085 1086 1087
    vp8_postproc_cfg_t *data = va_arg(args, vp8_postproc_cfg_t *);

    if (data)
    {
        ctx->preview_ppcfg = *((vp8_postproc_cfg_t *)data);
        return VPX_CODEC_OK;
    }
    else
        return VPX_CODEC_INVALID_PARAM;
1088 1089 1090 1091 1092
#else
    (void)ctx;
    (void)args;
    return VPX_CODEC_INCAPABLE;
#endif
John Koleszar's avatar
John Koleszar committed
1093 1094 1095 1096 1097 1098 1099
}


static vpx_image_t *vp8e_get_preview(vpx_codec_alg_priv_t *ctx)
{

    YV12_BUFFER_CONFIG sd;
1100
    vp8_ppflags_t flags = {0};
John Koleszar's avatar
John Koleszar committed
1101

1102 1103 1104 1105 1106 1107 1108 1109
    if (ctx->preview_ppcfg.post_proc_flag)
    {
        flags.post_proc_flag        = ctx->preview_ppcfg.post_proc_flag;
        flags.deblocking_level      = ctx->preview_ppcfg.deblocking_level;
        flags.noise_level           = ctx->preview_ppcfg.noise_level;
    }

    if (0 == vp8_get_preview_raw_frame(ctx->cpi, &sd, &flags))
John Koleszar's avatar
John Koleszar committed
1110 1111 1112
    {

        /*
1113
        vpx_img_wrap(&ctx->preview_img, VPX_IMG_FMT_YV12,
John Koleszar's avatar
John Koleszar committed
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
            sd.y_width + 2*VP8BORDERINPIXELS,
            sd.y_height + 2*VP8BORDERINPIXELS,
            1,
            sd.buffer_alloc);
        vpx_img_set_rect(&ctx->preview_img,
            VP8BORDERINPIXELS, VP8BORDERINPIXELS,
            sd.y_width, sd.y_height);
            */

        ctx->preview_img.bps = 12;
1124 1125 1126
        ctx->preview_img.planes[VPX_PLANE_Y] = sd.y_buffer;
        ctx->preview_img.planes[VPX_PLANE_U] = sd.u_buffer;
        ctx->preview_img.planes[VPX_PLANE_V] = sd.v_buffer;
John Koleszar's avatar
John Koleszar committed
1127

James Zern's avatar
James Zern committed
1128
        ctx->preview_img.fmt = VPX_IMG_FMT_I420;
John Koleszar's avatar
John Koleszar committed
1129 1130 1131
        ctx->preview_img.x_chroma_shift = 1;
        ctx->preview_img.y_chroma_shift = 1;

1132 1133
        ctx->preview_img.d_w = sd.y_width;
        ctx->preview_img.d_h = sd.y_height;
1134 1135 1136
        ctx->preview_img.stride[VPX_PLANE_Y] = sd.y_stride;
        ctx->preview_img.stride[VPX_PLANE_U] = sd.uv_stride;
        ctx->preview_img.stride[VPX_PLANE_V] = sd.uv_stride;
John Koleszar's avatar
John Koleszar committed
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
        ctx->preview_img.w   = sd.y_width;
        ctx->preview_img.h   = sd.y_height;

        return &ctx->preview_img;
    }
    else
        return NULL;
}

static vpx_codec_err_t vp8e_update_entropy(vpx_codec_alg_priv_t *ctx,
1147
                                           va_list args)
John Koleszar's avatar
John Koleszar committed
1148 1149 1150 1151 1152 1153 1154 1155
{
    int update = va_arg(args, int);
    vp8_update_entropy(ctx->cpi, update);
    return VPX_CODEC_OK;

}

static vpx_codec_err_t vp8e_update_reference(vpx_codec_alg_priv_t *ctx,
1156
                                             va_list args)
John Koleszar's avatar
John Koleszar committed
1157 1158 1159 1160 1161 1162 1163
{
    int update = va_arg(args, int);
    vp8_update_reference(ctx->cpi, update);
    return VPX_CODEC_OK;
}

static vpx_codec_err_t vp8e_use_reference(vpx_codec_alg_priv_t *ctx,
1164
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
{
    int reference_flag = va_arg(args, int);
    vp8_use_as_reference(ctx->cpi, reference_flag);
    return VPX_CODEC_OK;
}

static vpx_codec_err_t vp8e_set_roi_map(vpx_codec_alg_priv_t *ctx,
                                        va_list args)
{
    vpx_roi_map_t *data = va_arg(args, vpx_roi_map_t *);

    if (data)
    {
        vpx_roi_map_t *roi = (vpx_roi_map_t *)data;

        if (!vp8_set_roimap(ctx->cpi, roi->roi_map, roi->rows, roi->cols, roi->delta_q, roi->delta_lf, roi->static_threshold))
            return VPX_CODEC_OK;
        else
            return VPX_CODEC_INVALID_PARAM;
    }
    else
        return VPX_CODEC_INVALID_PARAM;
}


static vpx_codec_err_t vp8e_set_activemap(vpx_codec_alg_priv_t *ctx,
1191
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
{
    vpx_active_map_t *data = va_arg(args, vpx_active_map_t *);

    if (data)
    {

        vpx_active_map_t *map = (vpx_active_map_t *)data;

        if (!vp8_set_active_map(ctx->cpi, map->active_map, map->rows, map->cols))
            return VPX_CODEC_OK;
        else
            return VPX_CODEC_INVALID_PARAM;
    }
    else
        return VPX_CODEC_INVALID_PARAM;
}

static vpx_codec_err_t vp8e_set_scalemode(vpx_codec_alg_priv_t *ctx,
1210
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1211 1212 1213 1214 1215 1216 1217 1218
{

    vpx_scaling_mode_t *data =  va_arg(args, vpx_scaling_mode_t *);

    if (data)
    {
        int res;
        vpx_scaling_mode_t scalemode = *(vpx_scaling_mode_t *)data ;
1219 1220 1221
        res = vp8_set_internal_size(ctx->cpi,
                                    (VPX_SCALING)scalemode.h_scaling_mode,
                                    (VPX_SCALING)scalemode.v_scaling_mode);
John Koleszar's avatar
John Koleszar committed
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247

        if (!res)
        {
            /*force next frame a key frame to effect scaling mode */
            ctx->next_frame_flag |= FRAMEFLAGS_KEY;
            return VPX_CODEC_OK;
        }
        else
            return VPX_CODEC_INVALID_PARAM;
    }
    else
        return VPX_CODEC_INVALID_PARAM;
}


static vpx_codec_ctrl_fn_map_t vp8e_ctf_maps[] =
{
    {VP8_SET_REFERENCE,                 vp8e_set_reference},
    {VP8_COPY_REFERENCE,                vp8e_get_reference},
    {VP8_SET_POSTPROC,                  vp8e_set_previewpp},
    {VP8E_UPD_ENTROPY,                  vp8e_update_entropy},
    {VP8E_UPD_REFERENCE,                vp8e_update_reference},
    {VP8E_USE_REFERENCE,                vp8e_use_reference},
    {VP8E_SET_ROI_MAP,                  vp8e_set_roi_map},
    {VP8E_SET_ACTIVEMAP,                vp8e_set_activemap},
    {VP8E_SET_SCALEMODE,                vp8e_set_scalemode},
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
    {VP8E_SET_CPUUSED,                  set_cpu_used},
    {VP8E_SET_NOISE_SENSITIVITY,        set_noise_sensitivity},
    {VP8E_SET_ENABLEAUTOALTREF,         set_enable_auto_alt_ref},
    {VP8E_SET_SHARPNESS,                set_sharpness},
    {VP8E_SET_STATIC_THRESHOLD,         set_static_thresh},
    {VP8E_SET_TOKEN_PARTITIONS,         set_token_partitions},
    {VP8E_GET_LAST_QUANTIZER,           get_quantizer},
    {VP8E_GET_LAST_QUANTIZER_64,        get_quantizer64},
    {VP8E_SET_ARNR_MAXFRAMES,           set_arnr_max_frames},
    {VP8E_SET_ARNR_STRENGTH ,           set_arnr_strength},
    {VP8E_SET_ARNR_TYPE     ,           set_arnr_type},
    {VP8E_SET_TUNING,                   set_tuning},
    {VP8E_SET_CQ_LEVEL,                 set_cq_level},
    {VP8E_SET_MAX_INTRA_BITRATE_PCT,    set_rc_max_intra_bitrate_pct},
John Koleszar's avatar
John Koleszar committed
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
    { -1, NULL},
};

static vpx_codec_enc_cfg_map_t vp8e_usage_cfg_map[] =
{
    {
    0,
    {
        0,                  /* g_usage */
        0,                  /* g_threads */
        0,                  /* g_profile */

        320,                /* g_width */
        240,                /* g_height */
        {1, 30},            /* g_timebase */

        0,                  /* g_error_resilient */

        VPX_RC_ONE_PASS,    /* g_pass */

        0,                  /* g_lag_in_frames */

1284
        0,                  /* rc_dropframe_thresh */
John Koleszar's avatar
John Koleszar committed
1285
        0,                  /* rc_resize_allowed */
1286 1287
        1,                  /* rc_scaled_width */
        1,                  /* rc_scaled_height */
John Koleszar's avatar
John Koleszar committed
1288 1289 1290 1291 1292 1293
        60,                 /* rc_resize_down_thresold */
        30,                 /* rc_resize_up_thresold */

        VPX_VBR,            /* rc_end_usage */
#if VPX_ENCODER_ABI_VERSION > (1 + VPX_CODEC_ABI_VERSION)
        {0},                /* rc_twopass_stats_in */
1294
        {0},                /* rc_firstpass_mb_stats_in */
John Koleszar's avatar
John Koleszar committed
1295 1296 1297 1298
#endif
        256,                /* rc_target_bandwidth */
        4,                  /* rc_min_quantizer */
        63,                 /* rc_max_quantizer */
1299 1300
        100,                /* rc_undershoot_pct */
        100,                /* rc_overshoot_pct */
John Koleszar's avatar
John Koleszar committed
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312

        6000,               /* rc_max_buffer_size */
        4000,               /* rc_buffer_initial_size; */
        5000,               /* rc_buffer_optimal_size; */

        50,                 /* rc_two_pass_vbrbias  */
        0,                  /* rc_two_pass_vbrmin_section */
        400,                /* rc_two_pass_vbrmax_section */

        /* keyframing settings (kf) */
        VPX_KF_AUTO,        /* g_kfmode*/
        0,                  /* kf_min_dist */
1313
        128,                /* kf_max_dist */
John Koleszar's avatar
John Koleszar committed
1314 1315 1316 1317

#if VPX_ENCODER_ABI_VERSION == (1 + VPX_CODEC_ABI_VERSION)
        "vp8.fpf"           /* first pass filename */
#endif
1318
        VPX_SS_DEFAULT_LAYERS, /* ss_number_layers */
1319
        {0},
1320
        {0},                /* ss_target_bitrate */
1321 1322 1323 1324 1325
        1,                  /* ts_number_layers */
        {0},                /* ts_target_bitrate */
        {0},                /* ts_rate_decimator */
        0,                  /* ts_periodicity */
        {0},                /* ts_layer_id */
John Koleszar's avatar
John Koleszar committed
1326 1327 1328 1329 1330 1331 1332
    }},
};


#ifndef VERSION_STRING
#define VERSION_STRING
#endif
1333
CODEC_INTERFACE(vpx_codec_vp8_cx) =
John Koleszar's avatar
John Koleszar committed
1334
{
1335
    "WebM Project VP8 Encoder" VERSION_STRING,
John Koleszar's avatar
John Koleszar committed
1336
    VPX_CODEC_INTERNAL_ABI_VERSION,
1337 1338
    VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR |
    VPX_CODEC_CAP_OUTPUT_PARTITION,
John Koleszar's avatar
John Koleszar committed
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
    /* vpx_codec_caps_t          caps; */
    vp8e_init,          /* vpx_codec_init_fn_t       init; */
    vp8e_destroy,       /* vpx_codec_destroy_fn_t    destroy; */
    vp8e_ctf_maps,      /* vpx_codec_ctrl_fn_map_t  *ctrl_maps; */
    {
        NOT_IMPLEMENTED,    /* vpx_codec_peek_si_fn_t    peek_si; */
        NOT_IMPLEMENTED,    /* vpx_codec_get_si_fn_t     get_si; */
        NOT_IMPLEMENTED,    /* vpx_codec_decode_fn_t     decode; */
        NOT_IMPLEMENTED,    /* vpx_codec_frame_get_fn_t  frame_get; */
    },
    {
1350
        1,                  /* 1 cfg map */
John Koleszar's avatar
John Koleszar committed
1351 1352 1353 1354 1355 1356
        vp8e_usage_cfg_map, /* vpx_codec_enc_cfg_map_t    peek_si; */
        vp8e_encode,        /* vpx_codec_encode_fn_t      encode; */
        vp8e_get_cxdata,    /* vpx_codec_get_cx_data_fn_t   frame_get; */
        vp8e_set_config,
        NOT_IMPLEMENTED,
        vp8e_get_preview,
1357
        vp8e_mr_alloc_mem,
John Koleszar's avatar
John Koleszar committed
1358 1359
    } /* encoder functions */
};