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