ext/vpx/gstvp8enc.c

   1 /* VP8
   2  * Copyright (C) 2006 David Schleef <ds@schleef.org>
   3  * Copyright (C) 2010 Entropy Wave Inc
   4  * Copyright (C) 2010-2012 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  *
  21  */
  22 /**
  23  * SECTION:element-vp8enc
  24  * @see_also: vp8dec, webmmux, oggmux
  25  *
  26  * This element encodes raw video into a VP8 stream.
  27  * <ulink url="http://www.webmproject.org">VP8</ulink> is a royalty-free
  28  * video codec maintained by <ulink url="http://www.google.com/">Google
  29  * </ulink>. It's the successor of On2 VP3, which was the base of the
  30  * Theora video codec.
  31  *
  32  * To control the quality of the encoding, the #GstVP8Enc::bitrate and
  33  * #GstVP8Enc::quality properties can be used. These two properties are
  34  * mutualy exclusive. Setting the bitrate property will produce a constant
  35  * bitrate (CBR) stream while setting the quality property will produce a
  36  * variable bitrate (VBR) stream.
  37  *
  38  * <refsect2>
  39  * <title>Example pipeline</title>
  40  * |[
  41  * gst-launch -v videotestsrc num-buffers=1000 ! vp8enc ! webmmux ! filesink location=videotestsrc.webm
  42  * ]| This example pipeline will encode a test video source to VP8 muxed in an
  43  * WebM container.
  44  * </refsect2>
  45  */
  46
  47 #ifdef HAVE_CONFIG_H
  48 #include "config.h"
  49 #endif
  50
  51 #ifdef HAVE_VP8_ENCODER
  52
  53 #include <gst/tag/tag.h>
  54 #include <string.h>
  55
  56 #include "gstvp8utils.h"
  57 #include "gstvp8enc.h"
  58
  59 #include <gst/video/gstvideometa.h>
  60
  61 GST_DEBUG_CATEGORY_STATIC (gst_vp8enc_debug);
  62 #define GST_CAT_DEFAULT gst_vp8enc_debug
  63
  64 typedef struct
  65 {
  66   vpx_image_t *image;
  67   GList *invisible;
  68 } GstVP8EncUserData;
  69
  70 static void
  71 _gst_mini_object_unref0 (GstMiniObject * obj)
  72 {
  73   if (obj)
  74     gst_mini_object_unref (obj);
  75 }
  76
  77 static void
  78 gst_vp8_enc_user_data_free (GstVP8EncUserData * user_data)
  79 {
  80   if (user_data->image)
  81     g_slice_free (vpx_image_t, user_data->image);
  82
  83   g_list_foreach (user_data->invisible, (GFunc) _gst_mini_object_unref0, NULL);
  84   g_list_free (user_data->invisible);
  85   g_slice_free (GstVP8EncUserData, user_data);
  86 }
  87
  88 /* From vp8/vp8_cx_iface.c */
  89 #define DEFAULT_PROFILE 0
  90
  91 #define DEFAULT_RC_END_USAGE VPX_VBR
  92 #define DEFAULT_RC_TARGET_BITRATE 256000
  93 #define DEFAULT_RC_MIN_QUANTIZER 4
  94 #define DEFAULT_RC_MAX_QUANTIZER 63
  95
  96 #define DEFAULT_RC_DROPFRAME_THRESH 0
  97 #define DEFAULT_RC_RESIZE_ALLOWED 0
  98 #define DEFAULT_RC_RESIZE_UP_THRESH 30
  99 #define DEFAULT_RC_RESIZE_DOWN_THRESH 60
 100 #define DEFAULT_RC_UNDERSHOOT_PCT 100
 101 #define DEFAULT_RC_OVERSHOOT_PCT 100
 102 #define DEFAULT_RC_BUF_SZ 6000
 103 #define DEFAULT_RC_BUF_INITIAL_SZ 4000
 104 #define DEFAULT_RC_BUF_OPTIMAL_SZ 5000
 105 #define DEFAULT_RC_2PASS_VBR_BIAS_PCT 50
 106 #define DEFAULT_RC_2PASS_VBR_MINSECTION_PCT 0
 107 #define DEFAULT_RC_2PASS_VBR_MAXSECTION_PCT 400
 108
 109 #define DEFAULT_KF_MODE VPX_KF_AUTO
 110 #define DEFAULT_KF_MAX_DIST 128
 111
 112 #define DEFAULT_MULTIPASS_MODE VPX_RC_ONE_PASS
 113 #define DEFAULT_MULTIPASS_CACHE_FILE "multipass.cache"
 114
 115 #define DEFAULT_TS_NUMBER_LAYERS 1
 116 #define DEFAULT_TS_TARGET_BITRATE NULL
 117 #define DEFAULT_TS_RATE_DECIMATOR NULL
 118 #define DEFAULT_TS_PERIODICITY 0
 119 #define DEFAULT_TS_LAYER_ID NULL
 120
 121 #define DEFAULT_ERROR_RESILIENT 0
 122 #define DEFAULT_LAG_IN_FRAMES 0
 123
 124 #define DEFAULT_THREADS 0
 125
 126 #define DEFAULT_H_SCALING_MODE VP8E_NORMAL
 127 #define DEFAULT_V_SCALING_MODE VP8E_NORMAL
 128 #define DEFAULT_CPU_USED 0
 129 #define DEFAULT_ENABLE_AUTO_ALT_REF FALSE
 130 #define DEFAULT_DEADLINE VPX_DL_BEST_QUALITY
 131 #define DEFAULT_NOISE_SENSITIVITY 0
 132 #define DEFAULT_SHARPNESS 0
 133 #define DEFAULT_STATIC_THRESHOLD 0
 134 #define DEFAULT_TOKEN_PARTITIONS 0
 135 #define DEFAULT_ARNR_MAXFRAMES 0
 136 #define DEFAULT_ARNR_STRENGTH 3
 137 #define DEFAULT_ARNR_TYPE 3
 138 #define DEFAULT_TUNING VP8_TUNE_PSNR
 139 #define DEFAULT_CQ_LEVEL 10
 140 #define DEFAULT_MAX_INTRA_BITRATE_PCT 0
 141
 142 enum
 143 {
 144   PROP_0,
 145   PROP_RC_END_USAGE,
 146   PROP_RC_TARGET_BITRATE,
 147   PROP_RC_MIN_QUANTIZER,
 148   PROP_RC_MAX_QUANTIZER,
 149   PROP_RC_DROPFRAME_THRESH,
 150   PROP_RC_RESIZE_ALLOWED,
 151   PROP_RC_RESIZE_UP_THRESH,
 152   PROP_RC_RESIZE_DOWN_THRESH,
 153   PROP_RC_UNDERSHOOT_PCT,
 154   PROP_RC_OVERSHOOT_PCT,
 155   PROP_RC_BUF_SZ,
 156   PROP_RC_BUF_INITIAL_SZ,
 157   PROP_RC_BUF_OPTIMAL_SZ,
 158   PROP_RC_2PASS_VBR_BIAS_PCT,
 159   PROP_RC_2PASS_VBR_MINSECTION_PCT,
 160   PROP_RC_2PASS_VBR_MAXSECTION_PCT,
 161   PROP_KF_MODE,
 162   PROP_KF_MAX_DIST,
 163   PROP_TS_NUMBER_LAYERS,
 164   PROP_TS_TARGET_BITRATE,
 165   PROP_TS_RATE_DECIMATOR,
 166   PROP_TS_PERIODICITY,
 167   PROP_TS_LAYER_ID,
 168   PROP_MULTIPASS_MODE,
 169   PROP_MULTIPASS_CACHE_FILE,
 170   PROP_ERROR_RESILIENT,
 171   PROP_LAG_IN_FRAMES,
 172   PROP_THREADS,
 173   PROP_DEADLINE,
 174   PROP_H_SCALING_MODE,
 175   PROP_V_SCALING_MODE,
 176   PROP_CPU_USED,
 177   PROP_ENABLE_AUTO_ALT_REF,
 178   PROP_NOISE_SENSITIVITY,
 179   PROP_SHARPNESS,
 180   PROP_STATIC_THRESHOLD,
 181   PROP_TOKEN_PARTITIONS,
 182   PROP_ARNR_MAXFRAMES,
 183   PROP_ARNR_STRENGTH,
 184   PROP_ARNR_TYPE,
 185   PROP_TUNING,
 186   PROP_CQ_LEVEL,
 187   PROP_MAX_INTRA_BITRATE_PCT
 188 };
 189
 190 #define GST_VP8_ENC_END_USAGE_TYPE (gst_vp8_enc_end_usage_get_type())
 191 static GType
 192 gst_vp8_enc_end_usage_get_type (void)
 193 {
 194   static const GEnumValue values[] = {
 195     {VPX_VBR, "Variable Bit Rate (VBR) mode", "vbr"},
 196     {VPX_CBR, "Constant Bit Rate (CBR) mode", "cbr"},
 197     {VPX_CQ, "Constant Quality Mode (CQ) mode", "cq"},
 198     {0, NULL, NULL}
 199   };
 200   static volatile GType id = 0;
 201
 202   if (g_once_init_enter ((gsize *) & id)) {
 203     GType _id;
 204
 205     _id = g_enum_register_static ("GstVP8EncEndUsage", values);
 206
 207     g_once_init_leave ((gsize *) & id, _id);
 208   }
 209
 210   return id;
 211 }
 212
 213 #define GST_VP8_ENC_MULTIPASS_MODE_TYPE (gst_vp8_enc_multipass_mode_get_type())
 214 static GType
 215 gst_vp8_enc_multipass_mode_get_type (void)
 216 {
 217   static const GEnumValue values[] = {
 218     {VPX_RC_ONE_PASS, "One pass encoding (default)", "one-pass"},
 219     {VPX_RC_FIRST_PASS, "First pass of multipass encoding", "first-pass"},
 220     {VPX_RC_LAST_PASS, "Last pass of multipass encoding", "last-pass"},
 221     {0, NULL, NULL}
 222   };
 223   static volatile GType id = 0;
 224
 225   if (g_once_init_enter ((gsize *) & id)) {
 226     GType _id;
 227
 228     _id = g_enum_register_static ("GstVP8EncMultipassMode", values);
 229
 230     g_once_init_leave ((gsize *) & id, _id);
 231   }
 232
 233   return id;
 234 }
 235
 236 #define GST_VP8_ENC_KF_MODE_TYPE (gst_vp8_enc_kf_mode_get_type())
 237 static GType
 238 gst_vp8_enc_kf_mode_get_type (void)
 239 {
 240   static const GEnumValue values[] = {
 241     {VPX_KF_AUTO, "Determine optimal placement automatically", "auto"},
 242     {VPX_KF_DISABLED, "Don't automatically place keyframes", "disabled"},
 243     {0, NULL, NULL}
 244   };
 245   static volatile GType id = 0;
 246
 247   if (g_once_init_enter ((gsize *) & id)) {
 248     GType _id;
 249
 250     _id = g_enum_register_static ("GstVP8EncKfMode", values);
 251
 252     g_once_init_leave ((gsize *) & id, _id);
 253   }
 254
 255   return id;
 256 }
 257
 258 #define GST_VP8_ENC_TUNING_TYPE (gst_vp8_enc_tuning_get_type())
 259 static GType
 260 gst_vp8_enc_tuning_get_type (void)
 261 {
 262   static const GEnumValue values[] = {
 263     {VP8_TUNE_PSNR, "Tune for PSNR", "psnr"},
 264     {VP8_TUNE_SSIM, "Tune for SSIM", "ssim"},
 265     {0, NULL, NULL}
 266   };
 267   static volatile GType id = 0;
 268
 269   if (g_once_init_enter ((gsize *) & id)) {
 270     GType _id;
 271
 272     _id = g_enum_register_static ("GstVP8EncTuning", values);
 273
 274     g_once_init_leave ((gsize *) & id, _id);
 275   }
 276
 277   return id;
 278 }
 279
 280 #define GST_VP8_ENC_SCALING_MODE_TYPE (gst_vp8_enc_scaling_mode_get_type())
 281 static GType
 282 gst_vp8_enc_scaling_mode_get_type (void)
 283 {
 284   static const GEnumValue values[] = {
 285     {VP8E_NORMAL, "Normal", "normal"},
 286     {VP8E_FOURFIVE, "4:5", "4:5"},
 287     {VP8E_THREEFIVE, "3:5", "3:5"},
 288     {VP8E_ONETWO, "1:2", "1:2"},
 289     {0, NULL, NULL}
 290   };
 291   static volatile GType id = 0;
 292
 293   if (g_once_init_enter ((gsize *) & id)) {
 294     GType _id;
 295
 296     _id = g_enum_register_static ("GstVP8EncScalingMode", values);
 297
 298     g_once_init_leave ((gsize *) & id, _id);
 299   }
 300
 301   return id;
 302 }
 303
 304 #define GST_VP8_ENC_TOKEN_PARTITIONS_TYPE (gst_vp8_enc_token_partitions_get_type())
 305 static GType
 306 gst_vp8_enc_token_partitions_get_type (void)
 307 {
 308   static const GEnumValue values[] = {
 309     {VP8_ONE_TOKENPARTITION, "One token partition", "1"},
 310     {VP8_TWO_TOKENPARTITION, "Two token partitions", "2"},
 311     {VP8_FOUR_TOKENPARTITION, "Four token partitions", "4"},
 312     {VP8_EIGHT_TOKENPARTITION, "Eight token partitions", "8"},
 313     {0, NULL, NULL}
 314   };
 315   static volatile GType id = 0;
 316
 317   if (g_once_init_enter ((gsize *) & id)) {
 318     GType _id;
 319
 320     _id = g_enum_register_static ("GstVP8EncTokenPartitions", values);
 321
 322     g_once_init_leave ((gsize *) & id, _id);
 323   }
 324
 325   return id;
 326 }
 327
 328 #define GST_VP8_ENC_ER_FLAGS_TYPE (gst_vp8_enc_er_flags_get_type())
 329 static GType
 330 gst_vp8_enc_er_flags_get_type (void)
 331 {
 332   static const GFlagsValue values[] = {
 333     {VPX_ERROR_RESILIENT_DEFAULT, "Default error resilience", "default"},
 334     {VPX_ERROR_RESILIENT_PARTITIONS,
 335         "Allow partitions to be decoded independently", "partitions"},
 336     {0, NULL, NULL}
 337   };
 338   static volatile GType id = 0;
 339
 340   if (g_once_init_enter ((gsize *) & id)) {
 341     GType _id;
 342
 343     _id = g_flags_register_static ("GstVP8EncErFlags", values);
 344
 345     g_once_init_leave ((gsize *) & id, _id);
 346   }
 347
 348   return id;
 349 }
 350
 351 static void gst_vp8_enc_finalize (GObject * object);
 352 static void gst_vp8_enc_set_property (GObject * object, guint prop_id,
 353     const GValue * value, GParamSpec * pspec);
 354 static void gst_vp8_enc_get_property (GObject * object, guint prop_id,
 355     GValue * value, GParamSpec * pspec);
 356
 357 static gboolean gst_vp8_enc_start (GstVideoEncoder * encoder);
 358 static gboolean gst_vp8_enc_stop (GstVideoEncoder * encoder);
 359 static gboolean gst_vp8_enc_set_format (GstVideoEncoder *
 360     video_encoder, GstVideoCodecState * state);
 361 static gboolean gst_vp8_enc_finish (GstVideoEncoder * video_encoder);
 362 static GstFlowReturn gst_vp8_enc_handle_frame (GstVideoEncoder *
 363     video_encoder, GstVideoCodecFrame * frame);
 364 static GstFlowReturn gst_vp8_enc_pre_push (GstVideoEncoder * encoder,
 365     GstVideoCodecFrame * frame);
 366 static gboolean gst_vp8_enc_sink_event (GstVideoEncoder *
 367     video_encoder, GstEvent * event);
 368 static gboolean gst_vp8_enc_propose_allocation (GstVideoEncoder * encoder,
 369     GstQuery * query);
 370
 371 static GstStaticPadTemplate gst_vp8_enc_sink_template =
 372 GST_STATIC_PAD_TEMPLATE ("sink",
 373     GST_PAD_SINK,
 374     GST_PAD_ALWAYS,
 375     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420"))
 376     );
 377
 378 static GstStaticPadTemplate gst_vp8_enc_src_template =
 379 GST_STATIC_PAD_TEMPLATE ("src",
 380     GST_PAD_SRC,
 381     GST_PAD_ALWAYS,
 382     GST_STATIC_CAPS ("video/x-vp8, " "profile = (string) {0, 1, 2, 3}")
 383     );
 384
 385 #define parent_class gst_vp8_enc_parent_class
 386 G_DEFINE_TYPE_WITH_CODE (GstVP8Enc, gst_vp8_enc, GST_TYPE_VIDEO_ENCODER,
 387     G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL);
 388     G_IMPLEMENT_INTERFACE (GST_TYPE_PRESET, NULL););
 389
 390 static void
 391 gst_vp8_enc_class_init (GstVP8EncClass * klass)
 392 {
 393   GObjectClass *gobject_class;
 394   GstElementClass *element_class;
 395   GstVideoEncoderClass *video_encoder_class;
 396
 397   gobject_class = G_OBJECT_CLASS (klass);
 398   element_class = GST_ELEMENT_CLASS (klass);
 399   video_encoder_class = GST_VIDEO_ENCODER_CLASS (klass);
 400
 401   gobject_class->set_property = gst_vp8_enc_set_property;
 402   gobject_class->get_property = gst_vp8_enc_get_property;
 403   gobject_class->finalize = gst_vp8_enc_finalize;
 404
 405   gst_element_class_add_pad_template (element_class,
 406       gst_static_pad_template_get (&gst_vp8_enc_src_template));
 407   gst_element_class_add_pad_template (element_class,
 408       gst_static_pad_template_get (&gst_vp8_enc_sink_template));
 409
 410   gst_element_class_set_metadata (element_class,
 411       "On2 VP8 Encoder",
 412       "Codec/Encoder/Video",
 413       "Encode VP8 video streams", "David Schleef <ds@entropywave.com>, "
 414       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 415
 416   video_encoder_class->start = gst_vp8_enc_start;
 417   video_encoder_class->stop = gst_vp8_enc_stop;
 418   video_encoder_class->handle_frame = gst_vp8_enc_handle_frame;
 419   video_encoder_class->set_format = gst_vp8_enc_set_format;
 420   video_encoder_class->finish = gst_vp8_enc_finish;
 421   video_encoder_class->pre_push = gst_vp8_enc_pre_push;
 422   video_encoder_class->sink_event = gst_vp8_enc_sink_event;
 423   video_encoder_class->propose_allocation = gst_vp8_enc_propose_allocation;
 424
 425
 426   g_object_class_install_property (gobject_class, PROP_RC_END_USAGE,
 427       g_param_spec_enum ("end-usage", "Rate control mode",
 428           "Rate control mode",
 429           GST_VP8_ENC_END_USAGE_TYPE, DEFAULT_RC_END_USAGE,
 430           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 431
 432   g_object_class_install_property (gobject_class, PROP_RC_TARGET_BITRATE,
 433       g_param_spec_int ("target-bitrate", "Target bitrate",
 434           "Target bitrate (in bits/sec)",
 435           0, G_MAXINT, DEFAULT_RC_TARGET_BITRATE,
 436           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 437
 438   g_object_class_install_property (gobject_class, PROP_RC_MIN_QUANTIZER,
 439       g_param_spec_int ("min-quantizer", "Minimum Quantizer",
 440           "Minimum Quantizer (best)",
 441           0, 63, DEFAULT_RC_MIN_QUANTIZER,
 442           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 443
 444   g_object_class_install_property (gobject_class, PROP_RC_MAX_QUANTIZER,
 445       g_param_spec_int ("max-quantizer", "Maximum Quantizer",
 446           "Maximum Quantizer (worst)",
 447           0, 63, DEFAULT_RC_MAX_QUANTIZER,
 448           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 449
 450   g_object_class_install_property (gobject_class, PROP_RC_DROPFRAME_THRESH,
 451       g_param_spec_int ("dropframe-threshold", "Drop Frame Threshold",
 452           "Temporal resampling threshold (buf %)",
 453           0, 100, DEFAULT_RC_DROPFRAME_THRESH,
 454           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 455
 456   g_object_class_install_property (gobject_class, PROP_RC_RESIZE_ALLOWED,
 457       g_param_spec_boolean ("resize-allowed", "Resize Allowed",
 458           "Allow spatial resampling",
 459           DEFAULT_RC_RESIZE_ALLOWED,
 460           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 461
 462   g_object_class_install_property (gobject_class, PROP_RC_RESIZE_UP_THRESH,
 463       g_param_spec_int ("resize-up-threshold", "Resize Up Threshold",
 464           "Upscale threshold (buf %)",
 465           0, 100, DEFAULT_RC_RESIZE_UP_THRESH,
 466           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 467
 468   g_object_class_install_property (gobject_class, PROP_RC_RESIZE_DOWN_THRESH,
 469       g_param_spec_int ("resize-down-threshold", "Resize Down Threshold",
 470           "Downscale threshold (buf %)",
 471           0, 100, DEFAULT_RC_RESIZE_DOWN_THRESH,
 472           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 473
 474   g_object_class_install_property (gobject_class, PROP_RC_UNDERSHOOT_PCT,
 475       g_param_spec_int ("undershoot", "Undershoot PCT",
 476           "Datarate undershoot (min) target (%)",
 477           0, 1000, DEFAULT_RC_UNDERSHOOT_PCT,
 478           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 479
 480   g_object_class_install_property (gobject_class, PROP_RC_OVERSHOOT_PCT,
 481       g_param_spec_int ("overshoot", "Overshoot PCT",
 482           "Datarate overshoot (max) target (%)",
 483           0, 1000, DEFAULT_RC_OVERSHOOT_PCT,
 484           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 485
 486   g_object_class_install_property (gobject_class, PROP_RC_BUF_SZ,
 487       g_param_spec_int ("buffer-size", "Buffer size",
 488           "Client buffer size (ms)",
 489           0, G_MAXINT, DEFAULT_RC_BUF_SZ,
 490           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 491
 492   g_object_class_install_property (gobject_class, PROP_RC_BUF_INITIAL_SZ,
 493       g_param_spec_int ("buffer-initial-size", "Buffer initial size",
 494           "Initial client buffer size (ms)",
 495           0, G_MAXINT, DEFAULT_RC_BUF_INITIAL_SZ,
 496           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 497
 498   g_object_class_install_property (gobject_class, PROP_RC_BUF_OPTIMAL_SZ,
 499       g_param_spec_int ("buffer-optimal-size", "Buffer optimal size",
 500           "Optimal client buffer size (ms)",
 501           0, G_MAXINT, DEFAULT_RC_BUF_OPTIMAL_SZ,
 502           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 503
 504   g_object_class_install_property (gobject_class, PROP_RC_2PASS_VBR_BIAS_PCT,
 505       g_param_spec_int ("twopass-vbr-bias", "2-pass VBR bias",
 506           "CBR/VBR bias (0=CBR, 100=VBR)",
 507           0, 100, DEFAULT_RC_2PASS_VBR_BIAS_PCT,
 508           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 509
 510   g_object_class_install_property (gobject_class,
 511       PROP_RC_2PASS_VBR_MINSECTION_PCT,
 512       g_param_spec_int ("twopass-vbr-minsection", "2-pass GOP min bitrate",
 513           "GOP minimum bitrate (% target)", 0, G_MAXINT,
 514           DEFAULT_RC_2PASS_VBR_MINSECTION_PCT,
 515           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 516
 517   g_object_class_install_property (gobject_class,
 518       PROP_RC_2PASS_VBR_MAXSECTION_PCT,
 519       g_param_spec_int ("twopass-vbr-maxsection", "2-pass GOP max bitrate",
 520           "GOP maximum bitrate (% target)", 0, G_MAXINT,
 521           DEFAULT_RC_2PASS_VBR_MINSECTION_PCT,
 522           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 523
 524   g_object_class_install_property (gobject_class, PROP_KF_MODE,
 525       g_param_spec_enum ("keyframe-mode", "Keyframe Mode",
 526           "Keyframe placement",
 527           GST_VP8_ENC_KF_MODE_TYPE, DEFAULT_KF_MODE,
 528           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 529
 530   g_object_class_install_property (gobject_class, PROP_KF_MAX_DIST,
 531       g_param_spec_int ("keyframe-max-dist", "Keyframe max distance",
 532           "Maximum distance between keyframes (number of frames)",
 533           0, G_MAXINT, DEFAULT_KF_MAX_DIST,
 534           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 535
 536   g_object_class_install_property (gobject_class, PROP_MULTIPASS_MODE,
 537       g_param_spec_enum ("multipass-mode", "Multipass Mode",
 538           "Multipass encode mode",
 539           GST_VP8_ENC_MULTIPASS_MODE_TYPE, DEFAULT_MULTIPASS_MODE,
 540           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 541
 542   g_object_class_install_property (gobject_class, PROP_MULTIPASS_CACHE_FILE,
 543       g_param_spec_string ("multipass-cache-file", "Multipass Cache File",
 544           "Multipass cache file",
 545           DEFAULT_MULTIPASS_CACHE_FILE,
 546           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 547
 548   g_object_class_install_property (gobject_class, PROP_TS_NUMBER_LAYERS,
 549       g_param_spec_int ("temporal-scalability-number-layers",
 550           "Number of coding layers", "Number of coding layers to use", 1, 5,
 551           DEFAULT_TS_NUMBER_LAYERS,
 552           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 553
 554   g_object_class_install_property (gobject_class, PROP_TS_TARGET_BITRATE,
 555       g_param_spec_value_array ("temporal-scalability-target-bitrate",
 556           "Coding layer target bitrates",
 557           "Target bitrates for coding layers (one per layer, decreasing)",
 558           g_param_spec_int ("target-bitrate", "Target bitrate",
 559               "Target bitrate", 0, G_MAXINT, DEFAULT_RC_TARGET_BITRATE,
 560               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
 561           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 562
 563   g_object_class_install_property (gobject_class, PROP_TS_RATE_DECIMATOR,
 564       g_param_spec_value_array ("temporal-scalability-rate-decimator",
 565           "Coding layer rate decimator",
 566           "Rate decimation factors for each layer",
 567           g_param_spec_int ("rate-decimator", "Rate decimator",
 568               "Rate decimator", 0, 1000000000, 0,
 569               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
 570           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 571
 572   g_object_class_install_property (gobject_class, PROP_TS_PERIODICITY,
 573       g_param_spec_int ("temporal-scalability-periodicity",
 574           "Coding layer periodicity",
 575           "Length of sequence that defines layer membership periodicity", 0, 16,
 576           DEFAULT_TS_PERIODICITY,
 577           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 578
 579   g_object_class_install_property (gobject_class, PROP_TS_LAYER_ID,
 580       g_param_spec_value_array ("temporal-scalability-layer-id",
 581           "Coding layer identification",
 582           "Sequence defining coding layer membership",
 583           g_param_spec_int ("layer-id", "Layer ID", "Layer ID", 0, 4, 0,
 584               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
 585           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 586
 587   g_object_class_install_property (gobject_class, PROP_LAG_IN_FRAMES,
 588       g_param_spec_int ("lag-in-frames", "Lag in frames",
 589           "Maximum number of frames to lag",
 590           0, 25, DEFAULT_LAG_IN_FRAMES,
 591           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 592
 593   g_object_class_install_property (gobject_class, PROP_ERROR_RESILIENT,
 594       g_param_spec_flags ("error-resilient", "Error resilient",
 595           "Error resilience flags",
 596           GST_VP8_ENC_ER_FLAGS_TYPE, DEFAULT_ERROR_RESILIENT,
 597           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 598
 599   g_object_class_install_property (gobject_class, PROP_THREADS,
 600       g_param_spec_int ("threads", "Threads",
 601           "Number of threads to use",
 602           0, 64, DEFAULT_THREADS,
 603           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 604
 605   g_object_class_install_property (gobject_class, PROP_DEADLINE,
 606       g_param_spec_int64 ("deadline", "Deadline",
 607           "Deadline per frame (usec, 0=disabled)",
 608           0, G_MAXINT64, DEFAULT_DEADLINE,
 609           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 610
 611   g_object_class_install_property (gobject_class, PROP_H_SCALING_MODE,
 612       g_param_spec_enum ("horizontal-scaling-mode", "Horizontal scaling mode",
 613           "Horizontal scaling mode",
 614           GST_VP8_ENC_SCALING_MODE_TYPE, DEFAULT_H_SCALING_MODE,
 615           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 616
 617   g_object_class_install_property (gobject_class, PROP_V_SCALING_MODE,
 618       g_param_spec_enum ("vertical-scaling-mode", "Vertical scaling mode",
 619           "Vertical scaling mode",
 620           GST_VP8_ENC_SCALING_MODE_TYPE, DEFAULT_V_SCALING_MODE,
 621           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 622
 623   g_object_class_install_property (gobject_class, PROP_CPU_USED,
 624       g_param_spec_int ("cpu-used", "CPU used",
 625           "CPU used",
 626           -16, 16, DEFAULT_CPU_USED,
 627           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 628
 629   g_object_class_install_property (gobject_class, PROP_ENABLE_AUTO_ALT_REF,
 630       g_param_spec_boolean ("auto-alt-ref", "Auto alt reference frames",
 631           "Automatically generate AltRef frames",
 632           DEFAULT_ENABLE_AUTO_ALT_REF,
 633           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 634
 635   g_object_class_install_property (gobject_class, PROP_NOISE_SENSITIVITY,
 636       g_param_spec_int ("noise-sensitivity", "Noise sensitivity",
 637           "Noise sensisivity (frames to blur)",
 638           0, 6, DEFAULT_NOISE_SENSITIVITY,
 639           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 640
 641   g_object_class_install_property (gobject_class, PROP_SHARPNESS,
 642       g_param_spec_int ("sharpness", "Sharpness",
 643           "Filter sharpness",
 644           0, 7, DEFAULT_SHARPNESS,
 645           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 646
 647   g_object_class_install_property (gobject_class, PROP_STATIC_THRESHOLD,
 648       g_param_spec_int ("static-threshold", "Static Threshold",
 649           "Motion detection threshold",
 650           0, G_MAXINT, DEFAULT_STATIC_THRESHOLD,
 651           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 652
 653   g_object_class_install_property (gobject_class, PROP_TOKEN_PARTITIONS,
 654       g_param_spec_enum ("token-partitions", "Token partitions",
 655           "Number of token partitions",
 656           GST_VP8_ENC_TOKEN_PARTITIONS_TYPE, DEFAULT_TOKEN_PARTITIONS,
 657           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 658
 659   g_object_class_install_property (gobject_class, PROP_ARNR_MAXFRAMES,
 660       g_param_spec_int ("arnr-maxframes", "AltRef max frames",
 661           "AltRef maximum number of frames",
 662           0, 15, DEFAULT_ARNR_MAXFRAMES,
 663           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 664
 665   g_object_class_install_property (gobject_class, PROP_ARNR_STRENGTH,
 666       g_param_spec_int ("arnr-strength", "AltRef strength",
 667           "AltRef strength",
 668           0, 6, DEFAULT_ARNR_STRENGTH,
 669           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 670
 671   g_object_class_install_property (gobject_class, PROP_ARNR_TYPE,
 672       g_param_spec_int ("arnr-type", "AltRef type",
 673           "AltRef type",
 674           1, 3, DEFAULT_ARNR_TYPE,
 675           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 676
 677   g_object_class_install_property (gobject_class, PROP_TUNING,
 678       g_param_spec_enum ("tuning", "Tuning",
 679           "Tuning",
 680           GST_VP8_ENC_TUNING_TYPE, DEFAULT_TUNING,
 681           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 682
 683   g_object_class_install_property (gobject_class, PROP_CQ_LEVEL,
 684       g_param_spec_int ("cq-level", "Constrained quality level",
 685           "Constrained quality level",
 686           0, 63, DEFAULT_CQ_LEVEL,
 687           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 688
 689   g_object_class_install_property (gobject_class, PROP_MAX_INTRA_BITRATE_PCT,
 690       g_param_spec_int ("max-intra-bitrate", "Max Intra bitrate",
 691           "Maximum Intra frame bitrate",
 692           0, G_MAXINT, DEFAULT_MAX_INTRA_BITRATE_PCT,
 693           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 694
 695   GST_DEBUG_CATEGORY_INIT (gst_vp8enc_debug, "vp8enc", 0, "VP8 Encoder");
 696 }
 697
 698 static void
 699 gst_vp8_enc_init (GstVP8Enc * gst_vp8_enc)
 700 {
 701
 702   GST_DEBUG_OBJECT (gst_vp8_enc, "init");
 703
 704   gst_vp8_enc->rc_end_usage = DEFAULT_RC_END_USAGE;
 705   gst_vp8_enc->rc_target_bitrate = DEFAULT_RC_TARGET_BITRATE;
 706   gst_vp8_enc->rc_target_bitrate_set = FALSE;
 707   gst_vp8_enc->rc_min_quantizer = DEFAULT_RC_MIN_QUANTIZER;
 708   gst_vp8_enc->rc_max_quantizer = DEFAULT_RC_MAX_QUANTIZER;
 709   gst_vp8_enc->rc_dropframe_thresh = DEFAULT_RC_DROPFRAME_THRESH;
 710   gst_vp8_enc->rc_resize_allowed = DEFAULT_RC_RESIZE_ALLOWED;
 711   gst_vp8_enc->rc_resize_up_thresh = DEFAULT_RC_RESIZE_UP_THRESH;
 712   gst_vp8_enc->rc_resize_down_thresh = DEFAULT_RC_RESIZE_DOWN_THRESH;
 713   gst_vp8_enc->rc_undershoot_pct = DEFAULT_RC_UNDERSHOOT_PCT;
 714   gst_vp8_enc->rc_overshoot_pct = DEFAULT_RC_OVERSHOOT_PCT;
 715   gst_vp8_enc->rc_buf_sz = DEFAULT_RC_BUF_SZ;
 716   gst_vp8_enc->rc_buf_initial_sz = DEFAULT_RC_BUF_INITIAL_SZ;
 717   gst_vp8_enc->rc_buf_optimal_sz = DEFAULT_RC_BUF_OPTIMAL_SZ;
 718   gst_vp8_enc->rc_2pass_vbr_bias_pct = DEFAULT_RC_2PASS_VBR_BIAS_PCT;
 719   gst_vp8_enc->rc_2pass_vbr_minsection_pct =
 720       DEFAULT_RC_2PASS_VBR_MINSECTION_PCT;
 721   gst_vp8_enc->rc_2pass_vbr_maxsection_pct =
 722       DEFAULT_RC_2PASS_VBR_MAXSECTION_PCT;
 723   gst_vp8_enc->kf_mode = DEFAULT_KF_MODE;
 724   gst_vp8_enc->kf_max_dist = DEFAULT_KF_MAX_DIST;
 725   gst_vp8_enc->multipass_mode = DEFAULT_MULTIPASS_MODE;
 726   gst_vp8_enc->multipass_cache_file = g_strdup (DEFAULT_MULTIPASS_CACHE_FILE);
 727   gst_vp8_enc->ts_number_layers = DEFAULT_TS_NUMBER_LAYERS;
 728   gst_vp8_enc->n_ts_target_bitrate = 0;
 729   gst_vp8_enc->n_ts_rate_decimator = 0;
 730   gst_vp8_enc->ts_periodicity = DEFAULT_TS_PERIODICITY;
 731   gst_vp8_enc->n_ts_layer_id = 0;
 732   gst_vp8_enc->error_resilient = DEFAULT_ERROR_RESILIENT;
 733   gst_vp8_enc->lag_in_frames = DEFAULT_LAG_IN_FRAMES;
 734   gst_vp8_enc->threads = DEFAULT_THREADS;
 735   gst_vp8_enc->deadline = DEFAULT_DEADLINE;
 736   gst_vp8_enc->h_scaling_mode = DEFAULT_H_SCALING_MODE;
 737   gst_vp8_enc->v_scaling_mode = DEFAULT_V_SCALING_MODE;
 738   gst_vp8_enc->cpu_used = DEFAULT_CPU_USED;
 739   gst_vp8_enc->enable_auto_alt_ref = DEFAULT_ENABLE_AUTO_ALT_REF;
 740   gst_vp8_enc->noise_sensitivity = DEFAULT_NOISE_SENSITIVITY;
 741   gst_vp8_enc->sharpness = DEFAULT_SHARPNESS;
 742   gst_vp8_enc->static_threshold = DEFAULT_STATIC_THRESHOLD;
 743   gst_vp8_enc->token_partitions = DEFAULT_TOKEN_PARTITIONS;
 744   gst_vp8_enc->arnr_maxframes = DEFAULT_ARNR_MAXFRAMES;
 745   gst_vp8_enc->arnr_strength = DEFAULT_ARNR_STRENGTH;
 746   gst_vp8_enc->arnr_type = DEFAULT_ARNR_TYPE;
 747   gst_vp8_enc->tuning = DEFAULT_TUNING;
 748   gst_vp8_enc->cq_level = DEFAULT_CQ_LEVEL;
 749   gst_vp8_enc->max_intra_bitrate_pct = DEFAULT_MAX_INTRA_BITRATE_PCT;
 750
 751   gst_vp8_enc->profile = DEFAULT_PROFILE;
 752 }
 753
 754 static void
 755 gst_vp8_enc_finalize (GObject * object)
 756 {
 757   GstVP8Enc *gst_vp8_enc;
 758
 759   GST_DEBUG_OBJECT (object, "finalize");
 760
 761   g_return_if_fail (GST_IS_VP8_ENC (object));
 762   gst_vp8_enc = GST_VP8_ENC (object);
 763
 764   g_free (gst_vp8_enc->multipass_cache_file);
 765   gst_vp8_enc->multipass_cache_file = NULL;
 766
 767   if (gst_vp8_enc->input_state)
 768     gst_video_codec_state_unref (gst_vp8_enc->input_state);
 769
 770   G_OBJECT_CLASS (parent_class)->finalize (object);
 771
 772 }
 773
 774 static void
 775 gst_vp8_enc_set_property (GObject * object, guint prop_id,
 776     const GValue * value, GParamSpec * pspec)
 777 {
 778   GstVP8Enc *gst_vp8_enc;
 779
 780   g_return_if_fail (GST_IS_VP8_ENC (object));
 781   gst_vp8_enc = GST_VP8_ENC (object);
 782
 783   GST_DEBUG_OBJECT (object, "gst_vp8_enc_set_property");
 784   switch (prop_id) {
 785     case PROP_RC_END_USAGE:
 786       gst_vp8_enc->rc_end_usage = g_value_get_enum (value);
 787       break;
 788     case PROP_RC_TARGET_BITRATE:
 789       gst_vp8_enc->rc_target_bitrate = g_value_get_int (value);
 790       gst_vp8_enc->rc_target_bitrate_set = TRUE;
 791       break;
 792     case PROP_RC_MIN_QUANTIZER:
 793       gst_vp8_enc->rc_min_quantizer = g_value_get_int (value);
 794       break;
 795     case PROP_RC_MAX_QUANTIZER:
 796       gst_vp8_enc->rc_max_quantizer = g_value_get_int (value);
 797       break;
 798     case PROP_RC_DROPFRAME_THRESH:
 799       gst_vp8_enc->rc_dropframe_thresh = g_value_get_int (value);
 800       break;
 801     case PROP_RC_RESIZE_ALLOWED:
 802       gst_vp8_enc->rc_resize_allowed = g_value_get_boolean (value);
 803       break;
 804     case PROP_RC_RESIZE_UP_THRESH:
 805       gst_vp8_enc->rc_resize_up_thresh = g_value_get_int (value);
 806       break;
 807     case PROP_RC_RESIZE_DOWN_THRESH:
 808       gst_vp8_enc->rc_resize_down_thresh = g_value_get_int (value);
 809       break;
 810     case PROP_RC_UNDERSHOOT_PCT:
 811       gst_vp8_enc->rc_undershoot_pct = g_value_get_int (value);
 812       break;
 813     case PROP_RC_OVERSHOOT_PCT:
 814       gst_vp8_enc->rc_overshoot_pct = g_value_get_int (value);
 815       break;
 816     case PROP_RC_BUF_SZ:
 817       gst_vp8_enc->rc_buf_sz = g_value_get_int (value);
 818       break;
 819     case PROP_RC_BUF_INITIAL_SZ:
 820       gst_vp8_enc->rc_buf_initial_sz = g_value_get_int (value);
 821       break;
 822     case PROP_RC_BUF_OPTIMAL_SZ:
 823       gst_vp8_enc->rc_buf_optimal_sz = g_value_get_int (value);
 824       break;
 825     case PROP_RC_2PASS_VBR_BIAS_PCT:
 826       gst_vp8_enc->rc_2pass_vbr_bias_pct = g_value_get_int (value);
 827       break;
 828     case PROP_RC_2PASS_VBR_MINSECTION_PCT:
 829       gst_vp8_enc->rc_2pass_vbr_minsection_pct = g_value_get_int (value);
 830       break;
 831     case PROP_RC_2PASS_VBR_MAXSECTION_PCT:
 832       gst_vp8_enc->rc_2pass_vbr_maxsection_pct = g_value_get_int (value);
 833       break;
 834     case PROP_KF_MODE:
 835       gst_vp8_enc->kf_mode = g_value_get_enum (value);
 836       break;
 837     case PROP_KF_MAX_DIST:
 838       gst_vp8_enc->kf_max_dist = g_value_get_int (value);
 839       break;
 840     case PROP_MULTIPASS_MODE:
 841       gst_vp8_enc->multipass_mode = g_value_get_enum (value);
 842       break;
 843     case PROP_MULTIPASS_CACHE_FILE:
 844       if (gst_vp8_enc->multipass_cache_file)
 845         g_free (gst_vp8_enc->multipass_cache_file);
 846       gst_vp8_enc->multipass_cache_file = g_value_dup_string (value);
 847       break;
 848     case PROP_TS_NUMBER_LAYERS:
 849       gst_vp8_enc->ts_number_layers = g_value_get_int (value);
 850       break;
 851     case PROP_TS_TARGET_BITRATE:{
 852       GValueArray *va = g_value_get_boxed (value);
 853
 854       if (va->n_values > VPX_TS_MAX_LAYERS) {
 855         g_warning ("%s: Only %d layers allowed at maximum",
 856             GST_ELEMENT_NAME (gst_vp8_enc), VPX_TS_MAX_LAYERS);
 857       } else if (va) {
 858         gint i;
 859
 860         for (i = 0; i < va->n_values; i++)
 861           gst_vp8_enc->ts_target_bitrate[i] =
 862               g_value_get_int (g_value_array_get_nth (va, i));
 863         gst_vp8_enc->n_ts_target_bitrate = va->n_values;
 864       } else {
 865         gst_vp8_enc->n_ts_target_bitrate = 0;
 866       }
 867       break;
 868     }
 869     case PROP_TS_RATE_DECIMATOR:{
 870       GValueArray *va = g_value_get_boxed (value);
 871
 872       if (va->n_values > VPX_TS_MAX_LAYERS) {
 873         g_warning ("%s: Only %d layers allowed at maximum",
 874             GST_ELEMENT_NAME (gst_vp8_enc), VPX_TS_MAX_LAYERS);
 875       } else if (va) {
 876         gint i;
 877
 878         for (i = 0; i < va->n_values; i++)
 879           gst_vp8_enc->ts_rate_decimator[i] =
 880               g_value_get_int (g_value_array_get_nth (va, i));
 881         gst_vp8_enc->n_ts_rate_decimator = va->n_values;
 882       } else {
 883         gst_vp8_enc->n_ts_rate_decimator = 0;
 884       }
 885       break;
 886     }
 887     case PROP_TS_PERIODICITY:
 888       gst_vp8_enc->ts_periodicity = g_value_get_int (value);
 889       break;
 890     case PROP_TS_LAYER_ID:{
 891       GValueArray *va = g_value_get_boxed (value);
 892
 893       if (va->n_values > VPX_TS_MAX_PERIODICITY) {
 894         g_warning ("%s: Only %d sized layer sequences allowed at maximum",
 895             GST_ELEMENT_NAME (gst_vp8_enc), VPX_TS_MAX_PERIODICITY);
 896       } else if (va) {
 897         gint i;
 898
 899         for (i = 0; i < va->n_values; i++)
 900           gst_vp8_enc->ts_layer_id[i] =
 901               g_value_get_int (g_value_array_get_nth (va, i));
 902         gst_vp8_enc->n_ts_layer_id = va->n_values;
 903       } else {
 904         gst_vp8_enc->n_ts_layer_id = 0;
 905       }
 906       break;
 907     }
 908     case PROP_ERROR_RESILIENT:
 909       gst_vp8_enc->error_resilient = g_value_get_flags (value);
 910       break;
 911     case PROP_LAG_IN_FRAMES:
 912       gst_vp8_enc->lag_in_frames = g_value_get_int (value);
 913       break;
 914     case PROP_THREADS:
 915       gst_vp8_enc->threads = g_value_get_int (value);
 916       break;
 917     case PROP_DEADLINE:
 918       gst_vp8_enc->deadline = g_value_get_int64 (value);
 919       break;
 920     case PROP_H_SCALING_MODE:
 921       gst_vp8_enc->h_scaling_mode = g_value_get_enum (value);
 922       break;
 923     case PROP_V_SCALING_MODE:
 924       gst_vp8_enc->v_scaling_mode = g_value_get_enum (value);
 925       break;
 926     case PROP_CPU_USED:
 927       gst_vp8_enc->cpu_used = g_value_get_int (value);
 928       break;
 929     case PROP_ENABLE_AUTO_ALT_REF:
 930       gst_vp8_enc->enable_auto_alt_ref = g_value_get_boolean (value);
 931       break;
 932     case PROP_NOISE_SENSITIVITY:
 933       gst_vp8_enc->noise_sensitivity = g_value_get_int (value);
 934       break;
 935     case PROP_SHARPNESS:
 936       gst_vp8_enc->sharpness = g_value_get_int (value);
 937       break;
 938     case PROP_STATIC_THRESHOLD:
 939       gst_vp8_enc->static_threshold = g_value_get_int (value);
 940       break;
 941     case PROP_TOKEN_PARTITIONS:
 942       gst_vp8_enc->token_partitions = g_value_get_enum (value);
 943       break;
 944     case PROP_ARNR_MAXFRAMES:
 945       gst_vp8_enc->arnr_maxframes = g_value_get_int (value);
 946       break;
 947     case PROP_ARNR_STRENGTH:
 948       gst_vp8_enc->arnr_strength = g_value_get_int (value);
 949       break;
 950     case PROP_ARNR_TYPE:
 951       gst_vp8_enc->arnr_type = g_value_get_int (value);
 952       break;
 953     case PROP_TUNING:
 954       gst_vp8_enc->tuning = g_value_get_enum (value);
 955       break;
 956     case PROP_CQ_LEVEL:
 957       gst_vp8_enc->cq_level = g_value_get_int (value);
 958       break;
 959     case PROP_MAX_INTRA_BITRATE_PCT:
 960       gst_vp8_enc->max_intra_bitrate_pct = g_value_get_int (value);
 961       break;
 962     default:
 963       break;
 964   }
 965 }
 966
 967 static void
 968 gst_vp8_enc_get_property (GObject * object, guint prop_id, GValue * value,
 969     GParamSpec * pspec)
 970 {
 971   GstVP8Enc *gst_vp8_enc;
 972
 973   g_return_if_fail (GST_IS_VP8_ENC (object));
 974   gst_vp8_enc = GST_VP8_ENC (object);
 975
 976   switch (prop_id) {
 977     case PROP_RC_END_USAGE:
 978       g_value_set_enum (value, gst_vp8_enc->rc_end_usage);
 979       break;
 980     case PROP_RC_TARGET_BITRATE:
 981       g_value_set_int (value, gst_vp8_enc->rc_target_bitrate);
 982       break;
 983     case PROP_RC_MIN_QUANTIZER:
 984       g_value_set_int (value, gst_vp8_enc->rc_min_quantizer);
 985       break;
 986     case PROP_RC_MAX_QUANTIZER:
 987       g_value_set_int (value, gst_vp8_enc->rc_max_quantizer);
 988       break;
 989     case PROP_RC_DROPFRAME_THRESH:
 990       g_value_set_int (value, gst_vp8_enc->rc_dropframe_thresh);
 991       break;
 992     case PROP_RC_RESIZE_ALLOWED:
 993       g_value_set_boolean (value, gst_vp8_enc->rc_resize_allowed);
 994       break;
 995     case PROP_RC_RESIZE_UP_THRESH:
 996       g_value_set_int (value, gst_vp8_enc->rc_resize_up_thresh);
 997       break;
 998     case PROP_RC_RESIZE_DOWN_THRESH:
 999       g_value_set_int (value, gst_vp8_enc->rc_resize_down_thresh);
1000       break;
1001     case PROP_RC_UNDERSHOOT_PCT:
1002       g_value_set_int (value, gst_vp8_enc->rc_undershoot_pct);
1003       break;
1004     case PROP_RC_OVERSHOOT_PCT:
1005       g_value_set_int (value, gst_vp8_enc->rc_overshoot_pct);
1006       break;
1007     case PROP_RC_BUF_SZ:
1008       g_value_set_int (value, gst_vp8_enc->rc_buf_sz);
1009       break;
1010     case PROP_RC_BUF_INITIAL_SZ:
1011       g_value_set_int (value, gst_vp8_enc->rc_buf_initial_sz);
1012       break;
1013     case PROP_RC_BUF_OPTIMAL_SZ:
1014       g_value_set_int (value, gst_vp8_enc->rc_buf_optimal_sz);
1015       break;
1016     case PROP_RC_2PASS_VBR_BIAS_PCT:
1017       g_value_set_int (value, gst_vp8_enc->rc_2pass_vbr_bias_pct);
1018       break;
1019     case PROP_RC_2PASS_VBR_MINSECTION_PCT:
1020       g_value_set_int (value, gst_vp8_enc->rc_2pass_vbr_minsection_pct);
1021       break;
1022     case PROP_RC_2PASS_VBR_MAXSECTION_PCT:
1023       g_value_set_int (value, gst_vp8_enc->rc_2pass_vbr_maxsection_pct);
1024       break;
1025     case PROP_KF_MODE:
1026       g_value_set_enum (value, gst_vp8_enc->kf_mode);
1027       break;
1028     case PROP_KF_MAX_DIST:
1029       g_value_set_int (value, gst_vp8_enc->kf_max_dist);
1030       break;
1031     case PROP_MULTIPASS_MODE:
1032       g_value_set_enum (value, gst_vp8_enc->multipass_mode);
1033       break;
1034     case PROP_MULTIPASS_CACHE_FILE:
1035       g_value_set_string (value, gst_vp8_enc->multipass_cache_file);
1036       break;
1037     case PROP_TS_NUMBER_LAYERS:
1038       g_value_set_int (value, gst_vp8_enc->ts_number_layers);
1039       break;
1040     case PROP_TS_TARGET_BITRATE:{
1041       GValueArray *va;
1042
1043       if (gst_vp8_enc->n_ts_target_bitrate == 0) {
1044         g_value_set_boxed (value, NULL);
1045       } else {
1046         gint i;
1047
1048         va = g_value_array_new (gst_vp8_enc->n_ts_target_bitrate);
1049         for (i = 0; i < gst_vp8_enc->n_ts_target_bitrate; i++) {
1050           GValue v = { 0, };
1051
1052           g_value_init (&v, G_TYPE_INT);
1053           g_value_set_int (&v, gst_vp8_enc->ts_target_bitrate[i]);
1054           g_value_array_append (va, &v);
1055           g_value_unset (&v);
1056         }
1057         g_value_set_boxed (value, va);
1058         g_value_array_free (va);
1059       }
1060       break;
1061     }
1062     case PROP_TS_RATE_DECIMATOR:{
1063       GValueArray *va;
1064
1065       if (gst_vp8_enc->n_ts_rate_decimator == 0) {
1066         g_value_set_boxed (value, NULL);
1067       } else {
1068         gint i;
1069
1070         va = g_value_array_new (gst_vp8_enc->n_ts_rate_decimator);
1071         for (i = 0; i < gst_vp8_enc->n_ts_rate_decimator; i++) {
1072           GValue v = { 0, };
1073
1074           g_value_init (&v, G_TYPE_INT);
1075           g_value_set_int (&v, gst_vp8_enc->ts_rate_decimator[i]);
1076           g_value_array_append (va, &v);
1077           g_value_unset (&v);
1078         }
1079         g_value_set_boxed (value, va);
1080         g_value_array_free (va);
1081       }
1082       break;
1083     }
1084     case PROP_TS_PERIODICITY:
1085       g_value_set_int (value, gst_vp8_enc->ts_periodicity);
1086       break;
1087     case PROP_TS_LAYER_ID:{
1088       GValueArray *va;
1089
1090       if (gst_vp8_enc->n_ts_layer_id == 0) {
1091         g_value_set_boxed (value, NULL);
1092       } else {
1093         gint i;
1094
1095         va = g_value_array_new (gst_vp8_enc->n_ts_layer_id);
1096         for (i = 0; i < gst_vp8_enc->n_ts_layer_id; i++) {
1097           GValue v = { 0, };
1098
1099           g_value_init (&v, G_TYPE_INT);
1100           g_value_set_int (&v, gst_vp8_enc->ts_layer_id[i]);
1101           g_value_array_append (va, &v);
1102           g_value_unset (&v);
1103         }
1104         g_value_set_boxed (value, va);
1105         g_value_array_free (va);
1106       }
1107       break;
1108     }
1109     case PROP_ERROR_RESILIENT:
1110       g_value_set_flags (value, gst_vp8_enc->error_resilient);
1111       break;
1112     case PROP_LAG_IN_FRAMES:
1113       g_value_set_int (value, gst_vp8_enc->lag_in_frames);
1114       break;
1115     case PROP_THREADS:
1116       g_value_set_int (value, gst_vp8_enc->threads);
1117       break;
1118     case PROP_DEADLINE:
1119       g_value_set_int64 (value, gst_vp8_enc->deadline);
1120       break;
1121     case PROP_H_SCALING_MODE:
1122       g_value_set_enum (value, gst_vp8_enc->h_scaling_mode);
1123       break;
1124     case PROP_V_SCALING_MODE:
1125       g_value_set_enum (value, gst_vp8_enc->v_scaling_mode);
1126       break;
1127     case PROP_CPU_USED:
1128       g_value_set_int (value, gst_vp8_enc->cpu_used);
1129       break;
1130     case PROP_ENABLE_AUTO_ALT_REF:
1131       g_value_set_boolean (value, gst_vp8_enc->enable_auto_alt_ref);
1132       break;
1133     case PROP_NOISE_SENSITIVITY:
1134       g_value_set_int (value, gst_vp8_enc->noise_sensitivity);
1135       break;
1136     case PROP_SHARPNESS:
1137       g_value_set_int (value, gst_vp8_enc->sharpness);
1138       break;
1139     case PROP_STATIC_THRESHOLD:
1140       g_value_set_int (value, gst_vp8_enc->static_threshold);
1141       break;
1142     case PROP_TOKEN_PARTITIONS:
1143       g_value_set_enum (value, gst_vp8_enc->token_partitions);
1144       break;
1145     case PROP_ARNR_MAXFRAMES:
1146       g_value_set_int (value, gst_vp8_enc->arnr_maxframes);
1147       break;
1148     case PROP_ARNR_STRENGTH:
1149       g_value_set_int (value, gst_vp8_enc->arnr_strength);
1150       break;
1151     case PROP_ARNR_TYPE:
1152       g_value_set_int (value, gst_vp8_enc->arnr_type);
1153       break;
1154     case PROP_TUNING:
1155       g_value_set_enum (value, gst_vp8_enc->tuning);
1156       break;
1157     case PROP_CQ_LEVEL:
1158       g_value_set_int (value, gst_vp8_enc->cq_level);
1159       break;
1160     case PROP_MAX_INTRA_BITRATE_PCT:
1161       g_value_set_int (value, gst_vp8_enc->max_intra_bitrate_pct);
1162       break;
1163     default:
1164       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1165       break;
1166   }
1167 }
1168
1169 static gboolean
1170 gst_vp8_enc_start (GstVideoEncoder * video_encoder)
1171 {
1172   GST_DEBUG_OBJECT (video_encoder, "start");
1173
1174   return TRUE;
1175 }
1176
1177 static gboolean
1178 gst_vp8_enc_stop (GstVideoEncoder * video_encoder)
1179 {
1180   GstVP8Enc *encoder;
1181
1182   GST_DEBUG_OBJECT (video_encoder, "stop");
1183
1184   encoder = GST_VP8_ENC (video_encoder);
1185
1186   if (encoder->inited) {
1187     vpx_codec_destroy (&encoder->encoder);
1188     encoder->inited = FALSE;
1189   }
1190
1191   if (encoder->first_pass_cache_content) {
1192     g_byte_array_free (encoder->first_pass_cache_content, TRUE);
1193     encoder->first_pass_cache_content = NULL;
1194   }
1195
1196   if (encoder->last_pass_cache_content.buf) {
1197     g_free (encoder->last_pass_cache_content.buf);
1198     encoder->last_pass_cache_content.buf = NULL;
1199     encoder->last_pass_cache_content.sz = 0;
1200   }
1201
1202   gst_tag_setter_reset_tags (GST_TAG_SETTER (encoder));
1203
1204   return TRUE;
1205 }
1206
1207 static gint
1208 gst_vp8_enc_get_downstream_profile (GstVP8Enc * encoder)
1209 {
1210   GstCaps *allowed;
1211   GstStructure *s;
1212   gint profile = DEFAULT_PROFILE;
1213
1214   allowed = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder));
1215   if (allowed) {
1216     allowed = gst_caps_truncate (allowed);
1217     s = gst_caps_get_structure (allowed, 0);
1218     if (gst_structure_has_field (s, "profile")) {
1219       const GValue *v = gst_structure_get_value (s, "profile");
1220       const gchar *profile_str = NULL;
1221
1222       if (GST_VALUE_HOLDS_LIST (v) && gst_value_list_get_size (v) > 0) {
1223         profile_str = g_value_get_string (gst_value_list_get_value (v, 0));
1224       } else if (G_VALUE_HOLDS_STRING (v)) {
1225         profile_str = g_value_get_string (v);
1226       }
1227
1228       if (profile_str) {
1229         gchar *endptr = NULL;
1230
1231         profile = g_ascii_strtoull (profile_str, &endptr, 10);
1232         if (*endptr != '\0' || profile < 0 || profile > 3) {
1233           GST_ERROR_OBJECT (encoder, "Invalid profile '%s'", profile_str);
1234           profile = DEFAULT_PROFILE;
1235         }
1236       }
1237     }
1238     gst_caps_unref (allowed);
1239   }
1240
1241   GST_DEBUG_OBJECT (encoder, "Using profile %d", profile);
1242
1243   return profile;
1244 }
1245
1246 static gboolean
1247 gst_vp8_enc_set_format (GstVideoEncoder * video_encoder,
1248     GstVideoCodecState * state)
1249 {
1250   GstVP8Enc *encoder;
1251   vpx_codec_enc_cfg_t cfg;
1252   vpx_codec_err_t status;
1253   vpx_image_t *image;
1254   guint8 *data = NULL;
1255   GstCaps *caps;
1256   gboolean ret = TRUE;
1257   GstVideoInfo *info = &state->info;
1258   GstVideoCodecState *output_state;
1259   gchar *profile_str;
1260
1261   encoder = GST_VP8_ENC (video_encoder);
1262   GST_DEBUG_OBJECT (video_encoder, "set_format");
1263
1264   if (encoder->inited) {
1265     GST_DEBUG_OBJECT (video_encoder, "refusing renegotiation");
1266     return FALSE;
1267   }
1268
1269   status = vpx_codec_enc_config_default (&vpx_codec_vp8_cx_algo, &cfg, 0);
1270   if (status != VPX_CODEC_OK) {
1271     GST_ELEMENT_ERROR (encoder, LIBRARY, INIT,
1272         ("Failed to get default encoder configuration"), ("%s",
1273             gst_vpx_error_name (status)));
1274     return FALSE;
1275   }
1276
1277   encoder->profile = gst_vp8_enc_get_downstream_profile (encoder);
1278
1279   /* Scale default bitrate to our size */
1280   cfg.rc_target_bitrate = gst_util_uint64_scale (cfg.rc_target_bitrate,
1281       GST_VIDEO_INFO_WIDTH (info) * GST_VIDEO_INFO_HEIGHT (info),
1282       cfg.g_w * cfg.g_h);
1283
1284   cfg.g_w = GST_VIDEO_INFO_WIDTH (info);
1285   cfg.g_h = GST_VIDEO_INFO_HEIGHT (info);
1286   cfg.g_timebase.num = GST_VIDEO_INFO_FPS_D (info);
1287   cfg.g_timebase.den = GST_VIDEO_INFO_FPS_N (info);
1288
1289   cfg.rc_end_usage = encoder->rc_end_usage;
1290   if (encoder->rc_target_bitrate_set)
1291     cfg.rc_target_bitrate = encoder->rc_target_bitrate / 1000;
1292   cfg.rc_min_quantizer = encoder->rc_min_quantizer;
1293   cfg.rc_max_quantizer = encoder->rc_max_quantizer;
1294   cfg.rc_dropframe_thresh = encoder->rc_dropframe_thresh;
1295   cfg.rc_resize_allowed = encoder->rc_resize_allowed;
1296   cfg.rc_resize_up_thresh = encoder->rc_resize_up_thresh;
1297   cfg.rc_resize_down_thresh = encoder->rc_resize_down_thresh;
1298   cfg.rc_undershoot_pct = encoder->rc_undershoot_pct;
1299   cfg.rc_overshoot_pct = encoder->rc_overshoot_pct;
1300   cfg.rc_buf_sz = encoder->rc_buf_sz;
1301   cfg.rc_buf_initial_sz = encoder->rc_buf_initial_sz;
1302   cfg.rc_buf_optimal_sz = encoder->rc_buf_optimal_sz;
1303   cfg.rc_2pass_vbr_bias_pct = encoder->rc_2pass_vbr_bias_pct;
1304   cfg.rc_2pass_vbr_minsection_pct = encoder->rc_2pass_vbr_minsection_pct;
1305   cfg.rc_2pass_vbr_maxsection_pct = encoder->rc_2pass_vbr_maxsection_pct;
1306   cfg.kf_mode = encoder->kf_mode;
1307   cfg.kf_max_dist = encoder->kf_max_dist;
1308   cfg.ts_number_layers = encoder->ts_number_layers;
1309   memcpy (cfg.ts_target_bitrate, encoder->ts_target_bitrate,
1310       sizeof (encoder->ts_target_bitrate));
1311   memcpy (cfg.ts_rate_decimator, encoder->ts_rate_decimator,
1312       sizeof (encoder->ts_rate_decimator));
1313   cfg.ts_periodicity = encoder->ts_periodicity;
1314   memcpy (cfg.ts_layer_id, encoder->ts_layer_id, sizeof (encoder->ts_layer_id));
1315   cfg.g_error_resilient = encoder->error_resilient;
1316   cfg.g_lag_in_frames = encoder->lag_in_frames;
1317   cfg.g_threads = encoder->threads;
1318
1319   cfg.g_pass = encoder->multipass_mode;
1320   if (encoder->multipass_mode == VPX_RC_FIRST_PASS) {
1321     encoder->first_pass_cache_content = g_byte_array_sized_new (4096);
1322   } else if (encoder->multipass_mode == VPX_RC_LAST_PASS) {
1323     GError *err = NULL;
1324
1325     if (!encoder->multipass_cache_file) {
1326       GST_ELEMENT_ERROR (encoder, RESOURCE, OPEN_READ,
1327           ("No multipass cache file provided"), (NULL));
1328       return FALSE;
1329     }
1330
1331     if (!g_file_get_contents (encoder->multipass_cache_file,
1332             (gchar **) & encoder->last_pass_cache_content.buf,
1333             &encoder->last_pass_cache_content.sz, &err)) {
1334       GST_ELEMENT_ERROR (encoder, RESOURCE, OPEN_READ,
1335           ("Failed to read multipass cache file provided"), ("%s",
1336               err->message));
1337       g_error_free (err);
1338       return FALSE;
1339     }
1340     cfg.rc_twopass_stats_in = encoder->last_pass_cache_content;
1341   }
1342
1343   status = vpx_codec_enc_init (&encoder->encoder, &vpx_codec_vp8_cx_algo,
1344       &cfg, 0);
1345   if (status != VPX_CODEC_OK) {
1346     GST_ELEMENT_ERROR (encoder, LIBRARY, INIT,
1347         ("Failed to initialize encoder"), ("%s", gst_vpx_error_name (status)));
1348     return FALSE;
1349   }
1350
1351   {
1352     vpx_scaling_mode_t sm;
1353
1354     sm.h_scaling_mode = encoder->h_scaling_mode;
1355     sm.v_scaling_mode = encoder->v_scaling_mode;
1356
1357     status = vpx_codec_control (&encoder->encoder, VP8E_SET_SCALEMODE, &sm);
1358     if (status != VPX_CODEC_OK) {
1359       GST_WARNING_OBJECT (encoder, "Failed to set VP8E_SET_SCALEMODE: %s",
1360           gst_vpx_error_name (status));
1361     }
1362   }
1363
1364   status =
1365       vpx_codec_control (&encoder->encoder, VP8E_SET_CPUUSED,
1366       encoder->cpu_used);
1367   if (status != VPX_CODEC_OK) {
1368     GST_WARNING_OBJECT (encoder, "Failed to set VP8E_SET_CPUUSED: %s",
1369         gst_vpx_error_name (status));
1370   }
1371
1372   status =
1373       vpx_codec_control (&encoder->encoder, VP8E_SET_ENABLEAUTOALTREF,
1374       (encoder->enable_auto_alt_ref ? 1 : 0));
1375   if (status != VPX_CODEC_OK) {
1376     GST_WARNING_OBJECT (encoder,
1377         "Failed to set VP8E_SET_ENABLEAUTOALTREF: %s",
1378         gst_vpx_error_name (status));
1379   }
1380   status = vpx_codec_control (&encoder->encoder, VP8E_SET_NOISE_SENSITIVITY,
1381       encoder->noise_sensitivity);
1382   if (status != VPX_CODEC_OK) {
1383     GST_WARNING_OBJECT (encoder,
1384         "Failed to set VP8E_SET_NOISE_SENSITIVITY: %s",
1385         gst_vpx_error_name (status));
1386   }
1387   status = vpx_codec_control (&encoder->encoder, VP8E_SET_SHARPNESS,
1388       encoder->sharpness);
1389   if (status != VPX_CODEC_OK) {
1390     GST_WARNING_OBJECT (encoder,
1391         "Failed to set VP8E_SET_SHARPNESS: %s", gst_vpx_error_name (status));
1392   }
1393   status = vpx_codec_control (&encoder->encoder, VP8E_SET_STATIC_THRESHOLD,
1394       encoder->static_threshold);
1395   if (status != VPX_CODEC_OK) {
1396     GST_WARNING_OBJECT (encoder,
1397         "Failed to set VP8E_SET_STATIC_THRESHOLD: %s",
1398         gst_vpx_error_name (status));
1399   }
1400   status = vpx_codec_control (&encoder->encoder, VP8E_SET_TOKEN_PARTITIONS,
1401       encoder->token_partitions);
1402   if (status != VPX_CODEC_OK) {
1403     GST_WARNING_OBJECT (encoder,
1404         "Failed to set VP8E_SET_TOKEN_PARTIONS: %s",
1405         gst_vpx_error_name (status));
1406   }
1407   status = vpx_codec_control (&encoder->encoder, VP8E_SET_ARNR_MAXFRAMES,
1408       encoder->arnr_maxframes);
1409   if (status != VPX_CODEC_OK) {
1410     GST_WARNING_OBJECT (encoder,
1411         "Failed to set VP8E_SET_ARNR_MAXFRAMES: %s",
1412         gst_vpx_error_name (status));
1413   }
1414   status = vpx_codec_control (&encoder->encoder, VP8E_SET_ARNR_STRENGTH,
1415       encoder->arnr_strength);
1416   if (status != VPX_CODEC_OK) {
1417     GST_WARNING_OBJECT (encoder,
1418         "Failed to set VP8E_SET_ARNR_STRENGTH: %s",
1419         gst_vpx_error_name (status));
1420   }
1421   status = vpx_codec_control (&encoder->encoder, VP8E_SET_ARNR_TYPE,
1422       encoder->arnr_type);
1423   if (status != VPX_CODEC_OK) {
1424     GST_WARNING_OBJECT (encoder,
1425         "Failed to set VP8E_SET_ARNR_TYPE: %s", gst_vpx_error_name (status));
1426   }
1427   status = vpx_codec_control (&encoder->encoder, VP8E_SET_TUNING,
1428       encoder->tuning);
1429   if (status != VPX_CODEC_OK) {
1430     GST_WARNING_OBJECT (encoder,
1431         "Failed to set VP8E_SET_TUNING: %s", gst_vpx_error_name (status));
1432   }
1433   status = vpx_codec_control (&encoder->encoder, VP8E_SET_CQ_LEVEL,
1434       encoder->cq_level);
1435   if (status != VPX_CODEC_OK) {
1436     GST_WARNING_OBJECT (encoder,
1437         "Failed to set VP8E_SET_CQ_LEVEL: %s", gst_vpx_error_name (status));
1438   }
1439   status = vpx_codec_control (&encoder->encoder, VP8E_SET_MAX_INTRA_BITRATE_PCT,
1440       encoder->max_intra_bitrate_pct);
1441   if (status != VPX_CODEC_OK) {
1442     GST_WARNING_OBJECT (encoder,
1443         "Failed to set VP8E_SET_MAX_INTRA_BITRATE_PCT: %s",
1444         gst_vpx_error_name (status));
1445   }
1446
1447   gst_video_encoder_set_latency (video_encoder, 0,
1448       gst_util_uint64_scale (encoder->lag_in_frames,
1449           GST_VIDEO_INFO_FPS_D (info) * GST_SECOND,
1450           GST_VIDEO_INFO_FPS_N (info)));
1451   encoder->inited = TRUE;
1452
1453   /* Store input state */
1454   if (encoder->input_state)
1455     gst_video_codec_state_unref (encoder->input_state);
1456   encoder->input_state = gst_video_codec_state_ref (state);
1457
1458   /* prepare cached image buffer setup */
1459   image = &encoder->image;
1460   memset (image, 0, sizeof (*image));
1461
1462   image->fmt = VPX_IMG_FMT_I420;
1463   image->bps = 12;
1464   image->x_chroma_shift = image->y_chroma_shift = 1;
1465   image->w = image->d_w = GST_VIDEO_INFO_WIDTH (info);
1466   image->h = image->d_h = GST_VIDEO_INFO_HEIGHT (info);
1467
1468   image->stride[VPX_PLANE_Y] = GST_VIDEO_INFO_COMP_STRIDE (info, 0);
1469   image->stride[VPX_PLANE_U] = GST_VIDEO_INFO_COMP_STRIDE (info, 1);
1470   image->stride[VPX_PLANE_V] = GST_VIDEO_INFO_COMP_STRIDE (info, 2);
1471
1472   profile_str = g_strdup_printf ("%d", encoder->profile);
1473   caps = gst_caps_new_simple ("video/x-vp8",
1474       "profile", G_TYPE_STRING, profile_str, NULL);
1475   g_free (profile_str);
1476
1477   {
1478     GstStructure *s;
1479     GstBuffer *stream_hdr, *vorbiscomment;
1480     const GstTagList *iface_tags;
1481     GValue array = { 0, };
1482     GValue value = { 0, };
1483     GstMapInfo map;
1484
1485     s = gst_caps_get_structure (caps, 0);
1486
1487     /* put buffers in a fixed list */
1488     g_value_init (&array, GST_TYPE_ARRAY);
1489     g_value_init (&value, GST_TYPE_BUFFER);
1490
1491     /* Create Ogg stream-info */
1492     stream_hdr = gst_buffer_new_and_alloc (26);
1493     gst_buffer_map (stream_hdr, &map, GST_MAP_WRITE);
1494     data = map.data;
1495
1496     GST_WRITE_UINT8 (data, 0x4F);
1497     GST_WRITE_UINT32_BE (data + 1, 0x56503830); /* "VP80" */
1498     GST_WRITE_UINT8 (data + 5, 0x01);   /* stream info header */
1499     GST_WRITE_UINT8 (data + 6, 1);      /* Major version 1 */
1500     GST_WRITE_UINT8 (data + 7, 0);      /* Minor version 0 */
1501     GST_WRITE_UINT16_BE (data + 8, GST_VIDEO_INFO_WIDTH (info));
1502     GST_WRITE_UINT16_BE (data + 10, GST_VIDEO_INFO_HEIGHT (info));
1503     GST_WRITE_UINT24_BE (data + 12, GST_VIDEO_INFO_PAR_N (info));
1504     GST_WRITE_UINT24_BE (data + 15, GST_VIDEO_INFO_PAR_D (info));
1505     GST_WRITE_UINT32_BE (data + 18, GST_VIDEO_INFO_FPS_N (info));
1506     GST_WRITE_UINT32_BE (data + 22, GST_VIDEO_INFO_FPS_D (info));
1507
1508     gst_buffer_unmap (stream_hdr, &map);
1509
1510     GST_BUFFER_FLAG_SET (stream_hdr, GST_BUFFER_FLAG_HEADER);
1511     gst_value_set_buffer (&value, stream_hdr);
1512     gst_value_array_append_value (&array, &value);
1513     g_value_unset (&value);
1514     gst_buffer_unref (stream_hdr);
1515
1516     iface_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (video_encoder));
1517     if (iface_tags) {
1518       vorbiscomment =
1519           gst_tag_list_to_vorbiscomment_buffer (iface_tags,
1520           (const guint8 *) "OVP80\2 ", 7,
1521           "Encoded with GStreamer vp8enc " PACKAGE_VERSION);
1522
1523       GST_BUFFER_FLAG_SET (vorbiscomment, GST_BUFFER_FLAG_HEADER);
1524
1525       g_value_init (&value, GST_TYPE_BUFFER);
1526       gst_value_set_buffer (&value, vorbiscomment);
1527       gst_value_array_append_value (&array, &value);
1528       g_value_unset (&value);
1529       gst_buffer_unref (vorbiscomment);
1530     }
1531
1532     gst_structure_set_value (s, "streamheader", &array);
1533     g_value_unset (&array);
1534   }
1535   output_state =
1536       gst_video_encoder_set_output_state (video_encoder, caps, state);
1537   gst_video_codec_state_unref (output_state);
1538
1539   gst_video_encoder_negotiate (GST_VIDEO_ENCODER (encoder));
1540
1541   return ret;
1542 }
1543
1544 static GstFlowReturn
1545 gst_vp8_enc_process (GstVP8Enc * encoder)
1546 {
1547   vpx_codec_iter_t iter = NULL;
1548   const vpx_codec_cx_pkt_t *pkt;
1549   GstVideoEncoder *video_encoder;
1550   GstVP8EncUserData *user_data;
1551   GstVideoCodecFrame *frame;
1552   GstFlowReturn ret = GST_FLOW_OK;
1553
1554   video_encoder = GST_VIDEO_ENCODER (encoder);
1555
1556   pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
1557   while (pkt != NULL) {
1558     GstBuffer *buffer;
1559     gboolean invisible;
1560
1561     GST_DEBUG_OBJECT (encoder, "packet %u type %d", (guint) pkt->data.frame.sz,
1562         pkt->kind);
1563
1564     if (pkt->kind == VPX_CODEC_STATS_PKT
1565         && encoder->multipass_mode == VPX_RC_FIRST_PASS) {
1566       GST_LOG_OBJECT (encoder, "handling STATS packet");
1567
1568       g_byte_array_append (encoder->first_pass_cache_content,
1569           pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
1570
1571       frame = gst_video_encoder_get_oldest_frame (video_encoder);
1572       if (frame != NULL) {
1573         buffer = gst_buffer_new ();
1574         GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_LIVE);
1575         frame->output_buffer = buffer;
1576         gst_video_encoder_finish_frame (video_encoder, frame);
1577       }
1578
1579       pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
1580       continue;
1581     } else if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) {
1582       GST_LOG_OBJECT (encoder, "non frame pkt: %d", pkt->kind);
1583       pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
1584       continue;
1585     }
1586
1587     invisible = (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE) != 0;
1588     frame = gst_video_encoder_get_oldest_frame (video_encoder);
1589     g_assert (frame != NULL);
1590     if ((pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0)
1591       GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
1592     else
1593       GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
1594
1595     user_data = gst_video_codec_frame_get_user_data (frame);
1596
1597     /* FIXME : It would be nice to avoid the memory copy ... */
1598     buffer =
1599         gst_buffer_new_wrapped (g_memdup (pkt->data.frame.buf,
1600             pkt->data.frame.sz), pkt->data.frame.sz);
1601
1602     if (user_data->image)
1603       g_slice_free (vpx_image_t, user_data->image);
1604     user_data->image = NULL;
1605
1606     if (invisible) {
1607       user_data->invisible = g_list_append (user_data->invisible, buffer);
1608     } else {
1609       frame->output_buffer = buffer;
1610       ret = gst_video_encoder_finish_frame (video_encoder, frame);
1611     }
1612
1613     pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
1614   }
1615
1616   return ret;
1617 }
1618
1619 static GstFlowReturn
1620 gst_vp8_enc_finish (GstVideoEncoder * video_encoder)
1621 {
1622   GstVP8Enc *encoder;
1623   int flags = 0;
1624   vpx_codec_err_t status;
1625
1626   GST_DEBUG_OBJECT (video_encoder, "finish");
1627
1628   encoder = GST_VP8_ENC (video_encoder);
1629
1630   status =
1631       vpx_codec_encode (&encoder->encoder, NULL, encoder->n_frames, 1, flags,
1632       encoder->deadline);
1633   if (status != 0) {
1634     GST_ERROR_OBJECT (encoder, "encode returned %d %s", status,
1635         gst_vpx_error_name (status));
1636     return GST_FLOW_ERROR;
1637   }
1638
1639   /* dispatch remaining frames */
1640   gst_vp8_enc_process (encoder);
1641
1642   if (encoder->multipass_mode == VPX_RC_FIRST_PASS
1643       && encoder->multipass_cache_file) {
1644     GError *err = NULL;
1645
1646     if (!g_file_set_contents (encoder->multipass_cache_file,
1647             (const gchar *) encoder->first_pass_cache_content->data,
1648             encoder->first_pass_cache_content->len, &err)) {
1649       GST_ELEMENT_ERROR (encoder, RESOURCE, WRITE, (NULL),
1650           ("Failed to write multipass cache file: %s", err->message));
1651       g_error_free (err);
1652     }
1653   }
1654
1655   return GST_FLOW_OK;
1656 }
1657
1658 static vpx_image_t *
1659 gst_vp8_enc_buffer_to_image (GstVP8Enc * enc, GstVideoFrame * frame)
1660 {
1661   vpx_image_t *image = g_slice_new (vpx_image_t);
1662
1663   memcpy (image, &enc->image, sizeof (*image));
1664
1665   image->planes[VPX_PLANE_Y] = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
1666   image->planes[VPX_PLANE_U] = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
1667   image->planes[VPX_PLANE_V] = GST_VIDEO_FRAME_COMP_DATA (frame, 2);
1668
1669   image->stride[VPX_PLANE_Y] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
1670   image->stride[VPX_PLANE_U] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1);
1671   image->stride[VPX_PLANE_V] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 2);
1672
1673   return image;
1674 }
1675
1676 static GstFlowReturn
1677 gst_vp8_enc_handle_frame (GstVideoEncoder * video_encoder,
1678     GstVideoCodecFrame * frame)
1679 {
1680   GstVP8Enc *encoder;
1681   vpx_codec_err_t status;
1682   int flags = 0;
1683   vpx_image_t *image;
1684   GstVP8EncUserData *user_data;
1685   GstVideoFrame vframe;
1686
1687   GST_DEBUG_OBJECT (video_encoder, "handle_frame");
1688
1689   encoder = GST_VP8_ENC (video_encoder);
1690
1691   encoder->n_frames++;
1692
1693   GST_DEBUG_OBJECT (video_encoder, "size %d %d",
1694       GST_VIDEO_INFO_WIDTH (&encoder->input_state->info),
1695       GST_VIDEO_INFO_HEIGHT (&encoder->input_state->info));
1696
1697   gst_video_frame_map (&vframe, &encoder->input_state->info,
1698       frame->input_buffer, GST_MAP_READ);
1699   image = gst_vp8_enc_buffer_to_image (encoder, &vframe);
1700
1701   user_data = g_slice_new0 (GstVP8EncUserData);
1702   user_data->image = image;
1703   gst_video_codec_frame_set_user_data (frame, user_data,
1704       (GDestroyNotify) gst_vp8_enc_user_data_free);
1705
1706   if (GST_VIDEO_CODEC_FRAME_IS_FORCE_KEYFRAME (frame)) {
1707     flags |= VPX_EFLAG_FORCE_KF;
1708   }
1709
1710   status = vpx_codec_encode (&encoder->encoder, image,
1711       encoder->n_frames, 1, flags, encoder->deadline);
1712   gst_video_frame_unmap (&vframe);
1713
1714   if (status != 0) {
1715     GST_ELEMENT_ERROR (encoder, LIBRARY, ENCODE,
1716         ("Failed to encode frame"), ("%s", gst_vpx_error_name (status)));
1717     gst_video_codec_frame_set_user_data (frame, NULL, NULL);
1718     return FALSE;
1719   }
1720   gst_video_codec_frame_unref (frame);
1721   return gst_vp8_enc_process (encoder);
1722 }
1723
1724 static guint64
1725 _to_granulepos (guint64 frame_end_number, guint inv_count, guint keyframe_dist)
1726 {
1727   guint64 granulepos;
1728   guint inv;
1729
1730   inv = (inv_count == 0) ? 0x3 : inv_count - 1;
1731
1732   granulepos = (frame_end_number << 32) | (inv << 30) | (keyframe_dist << 3);
1733   return granulepos;
1734 }
1735
1736 static GstFlowReturn
1737 gst_vp8_enc_pre_push (GstVideoEncoder * video_encoder,
1738     GstVideoCodecFrame * frame)
1739 {
1740   GstVP8Enc *encoder;
1741   GstBuffer *buf;
1742   GstFlowReturn ret = GST_FLOW_OK;
1743   GstVP8EncUserData *user_data = gst_video_codec_frame_get_user_data (frame);
1744   GList *l;
1745   gint inv_count;
1746   GstVideoInfo *info;
1747
1748   GST_DEBUG_OBJECT (video_encoder, "pre_push");
1749
1750   encoder = GST_VP8_ENC (video_encoder);
1751
1752   info = &encoder->input_state->info;
1753
1754   g_assert (user_data != NULL);
1755
1756   for (inv_count = 0, l = user_data->invisible; l; inv_count++, l = l->next) {
1757     buf = l->data;
1758     l->data = NULL;
1759
1760     /* FIXME : All of this should have already been handled by base classes, no ? */
1761     if (l == user_data->invisible
1762         && GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame)) {
1763       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
1764       encoder->keyframe_distance = 0;
1765     } else {
1766       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
1767       encoder->keyframe_distance++;
1768     }
1769
1770     GST_BUFFER_TIMESTAMP (buf) = GST_BUFFER_TIMESTAMP (frame->output_buffer);
1771     GST_BUFFER_DURATION (buf) = 0;
1772     GST_BUFFER_OFFSET_END (buf) =
1773         _to_granulepos (frame->presentation_frame_number + 1,
1774         inv_count, encoder->keyframe_distance);
1775     GST_BUFFER_OFFSET (buf) =
1776         gst_util_uint64_scale (frame->presentation_frame_number + 1,
1777         GST_SECOND * GST_VIDEO_INFO_FPS_D (info), GST_VIDEO_INFO_FPS_N (info));
1778
1779     ret = gst_pad_push (GST_VIDEO_ENCODER_SRC_PAD (video_encoder), buf);
1780
1781     if (ret != GST_FLOW_OK) {
1782       GST_WARNING_OBJECT (encoder, "flow error %d", ret);
1783       goto done;
1784     }
1785   }
1786
1787   buf = frame->output_buffer;
1788
1789   /* FIXME : All of this should have already been handled by base classes, no ? */
1790   if (!user_data->invisible && GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame)) {
1791     GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
1792     encoder->keyframe_distance = 0;
1793   } else {
1794     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
1795     encoder->keyframe_distance++;
1796   }
1797
1798   GST_BUFFER_OFFSET_END (buf) =
1799       _to_granulepos (frame->presentation_frame_number + 1, 0,
1800       encoder->keyframe_distance);
1801   GST_BUFFER_OFFSET (buf) =
1802       gst_util_uint64_scale (frame->presentation_frame_number + 1,
1803       GST_SECOND * GST_VIDEO_INFO_FPS_D (info), GST_VIDEO_INFO_FPS_N (info));
1804
1805   GST_LOG_OBJECT (video_encoder, "src ts: %" GST_TIME_FORMAT,
1806       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
1807
1808 done:
1809   return ret;
1810 }
1811
1812 static gboolean
1813 gst_vp8_enc_sink_event (GstVideoEncoder * benc, GstEvent * event)
1814 {
1815   GstVP8Enc *enc = GST_VP8_ENC (benc);
1816
1817   /* FIXME : Move this to base encoder class */
1818
1819   if (GST_EVENT_TYPE (event) == GST_EVENT_TAG) {
1820     GstTagList *list;
1821     GstTagSetter *setter = GST_TAG_SETTER (enc);
1822     const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter);
1823
1824     gst_event_parse_tag (event, &list);
1825     gst_tag_setter_merge_tags (setter, list, mode);
1826   }
1827
1828   /* just peeked, baseclass handles the rest */
1829   return GST_VIDEO_ENCODER_CLASS (parent_class)->sink_event (benc, event);
1830 }
1831
1832 static gboolean
1833 gst_vp8_enc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query)
1834 {
1835   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
1836
1837   return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder,
1838       query);
1839 }
1840
1841 #endif /* HAVE_VP8_ENCODER */