vp8_cx_iface.c 46 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 "vp8_rtcd.h"
13
14
#include "vpx/vpx_codec.h"
#include "vpx/internal/vpx_codec_internal.h"
John Koleszar's avatar
John Koleszar committed
15
#include "vpx_version.h"
John Koleszar's avatar
John Koleszar committed
16
#include "vp8/encoder/onyx_int.h"
17
#include "vpx/vp8cx.h"
18
#include "vp8/encoder/firstpass.h"
John Koleszar's avatar
John Koleszar committed
19
#include "vp8/common/onyx.h"
John Koleszar's avatar
John Koleszar committed
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#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 */
John Koleszar's avatar
John Koleszar committed
35
    vp8e_tuning                 tuning;
Paul Wilkins's avatar
CQ Mode    
Paul Wilkins committed
36
    unsigned int                cq_level;         /* constrained quality level */
37
    unsigned int                rc_max_intra_bitrate_pct;
John Koleszar's avatar
John Koleszar committed
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

};

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

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

struct vpx_codec_alg_priv
{
    vpx_codec_priv_t        base;
    vpx_codec_enc_cfg_t     cfg;
    struct vp8_extracfg     vp8_cfg;
    VP8_CONFIG              oxcf;
John Koleszar's avatar
John Koleszar committed
83
    struct VP8_COMP        *cpi;
John Koleszar's avatar
John Koleszar committed
84
85
86
87
88
    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;
John Koleszar's avatar
John Koleszar committed
89
90
    /* 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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
    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;
}


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

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

121
122
123
124
125
#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
126
127
128
129
130
131
132
133
134
135
136
#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,
137
138
                                       const struct vp8_extracfg *vp8_cfg,
                                       int                        finalize)
John Koleszar's avatar
John Koleszar committed
139
{
140
141
    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
142
143
    RANGE_CHECK(cfg, g_timebase.den,        1, 1000000000);
    RANGE_CHECK(cfg, g_timebase.num,        1, cfg->g_timebase.den);
144
145
    RANGE_CHECK_HI(cfg, g_profile,          3);
    RANGE_CHECK_HI(cfg, rc_max_quantizer,   63);
John Koleszar's avatar
John Koleszar committed
146
    RANGE_CHECK_HI(cfg, rc_min_quantizer,   cfg->rc_max_quantizer);
147
    RANGE_CHECK_HI(cfg, g_threads,          64);
148
#if CONFIG_REALTIME_ONLY
149
    RANGE_CHECK_HI(cfg, g_lag_in_frames,    0);
150
151
152
153
154
#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
155
#endif
156
    RANGE_CHECK(cfg, rc_end_usage,          VPX_VBR, VPX_Q);
157
158
    RANGE_CHECK_HI(cfg, rc_undershoot_pct,  1000);
    RANGE_CHECK_HI(cfg, rc_overshoot_pct,   1000);
159
    RANGE_CHECK_HI(cfg, rc_2pass_vbr_bias_pct, 100);
John Koleszar's avatar
John Koleszar committed
160
    RANGE_CHECK(cfg, kf_mode,               VPX_KF_DISABLED, VPX_KF_AUTO);
161
162
163
164
165
166
167
168
169

/* 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
170
    RANGE_CHECK_HI(cfg, rc_dropframe_thresh,   100);
171
172
    RANGE_CHECK_HI(cfg, rc_resize_up_thresh,   100);
    RANGE_CHECK_HI(cfg, rc_resize_down_thresh, 100);
173
174

#if CONFIG_REALTIME_ONLY
John Koleszar's avatar
John Koleszar committed
175
    RANGE_CHECK(cfg,        g_pass,         VPX_RC_ONE_PASS, VPX_RC_ONE_PASS);
176
177
178
179
180
#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
181
182
183
184
185
186
187
188
189
190
191
#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);
192
    RANGE_CHECK(vp8_cfg, cpu_used,           -16, 16);
193
194
195
196
197

#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
198
199
#endif

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

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

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

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

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

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

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

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

    if (cfg->ts_number_layers > 1)
    {
240
        unsigned int i;
241
242
243
244
245
246
247
248
249
250
251
252
253
254
        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);
    }

255
256
257
258
259
#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
260
261
262
263
264
265
266
267
268
    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)
    {
James Zern's avatar
James Zern committed
269
270
271
272
    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
273
274
275
276
277
278
279
280
281
282
283
284
285
286
        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,
Yunqing Wang's avatar
Yunqing Wang committed
287
288
                                       struct vp8_extracfg vp8_cfg,
                                       vpx_codec_priv_enc_mr_cfg_t *mr_cfg)
John Koleszar's avatar
John Koleszar committed
289
290
291
292
293
294
{
    oxcf->multi_threaded         = cfg.g_threads;
    oxcf->Version               = cfg.g_profile;

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

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

    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;
    }

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

    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;

330
331
332
333
334
335
336
337
    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
CQ Mode    
Paul Wilkins committed
338
    }
John Koleszar's avatar
John Koleszar committed
339

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

343
344
345
    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
346
347
    oxcf->fixed_q = -1;

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

351
352
353
354
    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;

355
356
357
    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
358

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

363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
    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
378

Yunqing Wang's avatar
Yunqing Wang committed
379
#if CONFIG_MULTI_RES_ENCODING
380
381
382
383
    /* 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.
     */
Yunqing Wang's avatar
Yunqing Wang committed
384
385
386
387
388
389
390
391
392
393
    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

394
395
396
397
398
399
    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
400

401
402
    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
403

404
405
406
    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
407

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

    /*
        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);
421
        printf("over_shoot_pct: %d\n", oxcf->over_shoot_pct);
John Koleszar's avatar
John Koleszar committed
422
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
        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;

451
    if (((cfg->g_w != ctx->cfg.g_w) || (cfg->g_h != ctx->cfg.g_h))
452
        && (cfg->g_lag_in_frames > 1 || cfg->g_pass != VPX_RC_ONE_PASS))
John Koleszar's avatar
John Koleszar committed
453
454
455
456
457
458
459
460
461
462
        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");

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

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

    return res;
}

int vp8_reverse_trans(int);

477
478
479
480
481
482
483
484
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
485

486
static vpx_codec_err_t get_quantizer64(vpx_codec_alg_priv_t *ctx, va_list args)
John Koleszar's avatar
John Koleszar committed
487
{
488
489
490
491
492
493
  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
494

495
496
497
498
499
500
501
502
503
504
505
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
506

507
508
509
510
511
512
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
513

514
515
516
517
518
519
520
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
521

522
523
524
525
526
527
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
528
529
}

530
531
532
533
534
535
536
537
538
539
540
541
542
543
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
544

545
546
static vpx_codec_err_t set_token_partitions(vpx_codec_alg_priv_t *ctx,
                                            va_list args)
John Koleszar's avatar
John Koleszar committed
547
{
548
549
550
551
  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
552

553
554
555
556
557
558
559
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
560

561
562
563
564
565
566
567
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
568

569
570
571
572
573
574
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
575

576
577
578
579
580
581
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
582

583
584
585
586
587
588
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
589

590
591
592
593
594
595
596
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
597
}
Yunqing Wang's avatar
Yunqing Wang committed
598
599
600
601

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

Yunqing Wang's avatar
Yunqing Wang committed
604
#if CONFIG_MULTI_RES_ENCODING
605
    LOWER_RES_FRAME_INFO *shared_mem_loc;
Yunqing Wang's avatar
Yunqing Wang committed
606
607
608
    int mb_rows = ((cfg->g_w + 15) >>4);
    int mb_cols = ((cfg->g_h + 15) >>4);

609
610
    shared_mem_loc = calloc(1, sizeof(LOWER_RES_FRAME_INFO));
    if(!shared_mem_loc)
Yunqing Wang's avatar
Yunqing Wang committed
611
    {
612
        res = VPX_CODEC_MEM_ERROR;
613
614
615
616
617
    }

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

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
631
{
632
    vpx_codec_err_t        res = VPX_CODEC_OK;
John Koleszar's avatar
John Koleszar committed
633
634
635
636
    struct vpx_codec_alg_priv *priv;
    vpx_codec_enc_cfg_t       *cfg;
    unsigned int               i;

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

639
    vp8_rtcd();
640

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

645
        if (!priv)
John Koleszar's avatar
John Koleszar committed
646
        {
647
648
649
650
651
652
653
654
655
656
657
658
659
            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
660
             */
661
662
663
            ctx->priv->alg_priv->cfg = *ctx->config.enc;
            ctx->config.enc = &ctx->priv->alg_priv->cfg;
        }
John Koleszar's avatar
John Koleszar committed
664

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

667
        /* Select the extra vp8 configuration table based on the current
668
669
670
671
672
673
         * 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
674

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

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

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

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

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

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

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

        if (!res)
        {
            set_vp8e_config(&ctx->priv->alg_priv->oxcf,
                             ctx->priv->alg_priv->cfg,
Yunqing Wang's avatar
Yunqing Wang committed
700
701
702
                             ctx->priv->alg_priv->vp8_cfg,
                             mr_cfg);

703
704
705
706
707
708
            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
709
710
711
712
713
714
715
716
        }
    }

    return res;
}

static vpx_codec_err_t vp8e_destroy(vpx_codec_alg_priv_t *ctx)
{
Yunqing Wang's avatar
Yunqing Wang committed
717
718
719
#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))
720
721
722
    {
        LOWER_RES_FRAME_INFO *shared_mem_loc = (LOWER_RES_FRAME_INFO *)ctx->oxcf.mr_low_res_mode_info;
        free(shared_mem_loc->mb_info);
Yunqing Wang's avatar
Yunqing Wang committed
723
        free(ctx->oxcf.mr_low_res_mode_info);
724
    }
Yunqing Wang's avatar
Yunqing Wang committed
725
#endif
John Koleszar's avatar
John Koleszar committed
726
727
728
729
730
731
732
733
734
735
736

    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;
737
738
739
    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
740

741
742
    yv12->y_crop_width  = img->d_w;
    yv12->y_crop_height = img->d_h;
John Koleszar's avatar
John Koleszar committed
743
744
745
746
747
    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;

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

751
    yv12->border  = (img->stride[VPX_PLANE_Y] - img->w) / 2;
John Koleszar's avatar
John Koleszar committed
752
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
    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;

John Koleszar's avatar
John Koleszar committed
808
809
810
    if (!ctx->cfg.rc_target_bitrate)
        return res;

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

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

John Koleszar's avatar
John Koleszar committed
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
    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
834
            ref ^= VP8_LAST_FRAME;
John Koleszar's avatar
John Koleszar committed
835
836

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

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

        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
852
            upd ^= VP8_LAST_FRAME;
John Koleszar's avatar
John Koleszar committed
853
854

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

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

        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;
875
            ctx->fixed_kf_cntr = 1;
John Koleszar's avatar
John Koleszar committed
876
877
878
879
880
881
882
883
        }
    }

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

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

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

John Koleszar's avatar
John Koleszar committed
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
        /* 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;
921
        cx_data_end = ctx->cx_data + cx_data_sz;
John Koleszar's avatar
John Koleszar committed
922
923
        lib_flags = 0;

924
        while (cx_data_sz >= ctx->cx_data_sz / 2)
John Koleszar's avatar
John Koleszar committed
925
        {
926
927
928
929
930
931
932
933
934
935
936
937
938
939
            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
940
941
942
943
944
945
946
            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. */
947
                round = (vpx_codec_pts_t)10000000
948
                        * ctx->cfg.g_timebase.num / 2 - 1;
John Koleszar's avatar
John Koleszar committed
949
950
951
952
953
                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;
954
955
956
                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
957
958
959
960
961
962
963
964
965
                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;

John Koleszar's avatar
John Koleszar committed
966
967
968
969
970
                    /* 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.
                     */
971
972
973
                    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
974
975
976
                    pkt.data.frame.duration = 0;
                }

John Koleszar's avatar
John Koleszar committed
977
978
979
                if (cpi->droppable)
                    pkt.data.frame.flags |= VPX_FRAME_IS_DROPPABLE;

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

                    pkt.data.frame.flags |= VPX_FRAME_IS_FRAGMENT;

988
989
                    for (i = 0; i < num_partitions; ++i)
                    {
990
991
992
#if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
                        pkt.data.frame.buf = cpi->partition_d[i];
#else
993
                        pkt.data.frame.buf = cx_data;
994
995
996
                        cx_data += cpi->partition_sz[i];
                        cx_data_sz -= cpi->partition_sz[i];
#endif
997
998
999
                        pkt.data.frame.sz = cpi->partition_sz[i];
                        pkt.data.frame.partition_id = i;
                        /* don't set the fragment bit for the last partition */
1000
1001
                        if (i == (num_partitions - 1))
                            pkt.data.frame.flags &= ~VPX_FRAME_IS_FRAGMENT;
1002
1003
                        vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
                    }
1004
1005
1006
1007
1008
1009
1010
1011
#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
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
                }
                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
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
            }
        }
    }

    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,
1037
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
{
    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,
1056
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
{

    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,
1075
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1076
{
1077
#if CONFIG_POSTPROC
John Koleszar's avatar
John Koleszar committed
1078
1079
1080
1081
1082
1083
1084
1085
1086
    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;
1087
1088
1089
1090
1091
#else
    (void)ctx;
    (void)args;
    return VPX_CODEC_INCAPABLE;
#endif
John Koleszar's avatar
John Koleszar committed
1092
1093
1094
1095
1096
1097
1098
}


static vpx_image_t *vp8e_get_preview(vpx_codec_alg_priv_t *ctx)
{

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

1101
1102
1103
1104
1105
1106
1107
1108
    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
1109
1110
1111
    {

        /*
James Zern's avatar
James Zern committed
1112
        vpx_img_wrap(&ctx->preview_img, VPX_IMG_FMT_YV12,
John Koleszar's avatar
John Koleszar committed
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
            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;
1123
1124
1125
        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
1126

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

1131
1132
        ctx->preview_img.d_w = sd.y_width;
        ctx->preview_img.d_h = sd.y_height;
1133
1134
1135
        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
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
        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,
1146
                                           va_list args)
John Koleszar's avatar
John Koleszar committed
1147
1148
1149
1150
1151
1152
1153
1154
{
    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,
1155
                                             va_list args)
John Koleszar's avatar
John Koleszar committed
1156
1157
1158
1159
1160
1161
1162
{
    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,
1163
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1164
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
{
    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,
1190
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
{
    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,
1209
                                          va_list args)
John Koleszar's avatar
John Koleszar committed
1210
1211
1212
1213
1214
1215
1216
1217
{

    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 ;
1218
1219
1220
        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
1221
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

        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},
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
    {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
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
    { -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 */

1283
        0,                  /* rc_dropframe_thresh */
John Koleszar's avatar
John Koleszar committed
1284
        0,                  /* rc_resize_allowed */
1285
1286
        1,                  /* rc_scaled_width */
        1,                  /* rc_scaled_height */
John Koleszar's avatar
John Koleszar committed
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
        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 */
#endif
        256,                /* rc_target_bandwidth */
        4,                  /* rc_min_quantizer */
        63,                 /* rc_max_quantizer */
1297
1298
        100,                /* rc_undershoot_pct */
        100,                /* rc_overshoot_pct */
John Koleszar's avatar
John Koleszar committed
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310

        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 */
1311
        128,                /* kf_max_dist */
John Koleszar's avatar
John Koleszar committed
1312
1313
1314
1315

#if VPX_ENCODER_ABI_VERSION == (1 + VPX_CODEC_ABI_VERSION)
        "vp8.fpf"           /* first pass filename */
#endif
1316
        VPX_SS_DEFAULT_LAYERS, /* ss_number_layers */
1317
        {0},                /* ss_target_bitrate */
1318
1319
1320
1321
1322
        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
1323
1324
1325
1326
1327
1328
1329
1330
    }},
    { -1, {NOT_IMPLEMENTED}}
};


#ifndef VERSION_STRING
#define VERSION_STRING
#endif
1331
CODEC_INTERFACE(vpx_codec_vp8_cx) =
John Koleszar's avatar
John Koleszar committed
1332
{
1333
    "WebM Project VP8 Encoder" VERSION_STRING,
John Koleszar's avatar
John Koleszar committed
1334
    VPX_CODEC_INTERNAL_ABI_VERSION,
1335
1336
    VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR |
    VPX_CODEC_CAP_OUTPUT_PARTITION,
John Koleszar's avatar
John Koleszar committed
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
    /* 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_get_mmap_fn_t   get_mmap; */
    NOT_IMPLEMENTED,    /* vpx_codec_set_mmap_fn_t   set_mmap; */
    {
        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; */
    },
    {
        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,
Yunqing Wang's avatar
Yunqing Wang committed
1356
        vp8e_mr_alloc_mem,
John Koleszar's avatar
John Koleszar committed
1357
1358
    } /* encoder functions */
};