subprojects/gst-plugins-bad/ext/aom/gstav1enc.c

   1 /* GStreamer
   2  * Copyright (C) <2017> Sean DuBois <sean@siobud.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19 /**
  20  * SECTION:element-av1enc
  21  *
  22  * AV1 Encoder.
  23  *
  24  * ## Example launch line
  25  *
  26  * |[
  27  * gst-launch-1.0 videotestsrc num-buffers=50 ! av1enc ! webmmux ! filesink location=av1.webm
  28  * ]|
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include "config.h"
  33 #endif
  34
  35 #include "gstav1enc.h"
  36 #include "gstav1utils.h"
  37 #include <gst/video/video.h>
  38 #include <gst/video/gstvideometa.h>
  39 #include <gst/base/base.h>
  40
  41 #define GST_AV1_ENC_APPLY_CODEC_CONTROL(av1enc, flag, value)             \
  42   if (av1enc->encoder_inited) {                                        \
  43     if (aom_codec_control (&av1enc->encoder, flag,                     \
  44             value) != AOM_CODEC_OK) {                                  \
  45       gst_av1_codec_error (&av1enc->encoder, "Failed to set " #flag);  \
  46     }                                                                  \
  47   }
  48
  49 GST_DEBUG_CATEGORY_STATIC (av1_enc_debug);
  50 #define GST_CAT_DEFAULT av1_enc_debug
  51
  52 #define GST_TYPE_RESIZE_MODE (gst_resize_mode_get_type())
  53 static GType
  54 gst_resize_mode_get_type (void)
  55 {
  56   static GType resize_mode_type = 0;
  57   static const GEnumValue resize_mode[] = {
  58     {GST_AV1_ENC_RESIZE_NONE, "No frame resizing allowed", "none"},
  59     {GST_AV1_ENC_RESIZE_FIXED, "All frames are coded at the specified scale",
  60         "fixed"},
  61     {GST_AV1_ENC_RESIZE_RANDOM, "All frames are coded at a random scale",
  62         "random"},
  63     {0, NULL, NULL},
  64   };
  65
  66   if (!resize_mode_type) {
  67     resize_mode_type =
  68         g_enum_register_static ("GstAV1EncResizeMode", resize_mode);
  69   }
  70   return resize_mode_type;
  71 }
  72
  73 #define GST_TYPE_SUPERRES_MODE (gst_superres_mode_get_type())
  74 static GType
  75 gst_superres_mode_get_type (void)
  76 {
  77   static GType superres_mode_type = 0;
  78   static const GEnumValue superres_mode[] = {
  79     {GST_AV1_ENC_SUPERRES_NONE, "No frame superres allowed", "none"},
  80     {GST_AV1_ENC_SUPERRES_FIXED,
  81           "All frames are coded at the specified scale and super-resolved",
  82         "fixed"},
  83     {GST_AV1_ENC_SUPERRES_RANDOM,
  84           "All frames are coded at a random scale and super-resolved",
  85         "random"},
  86     {GST_AV1_ENC_SUPERRES_QTHRESH,
  87           "Superres scale for a frame is determined based on q_index",
  88         "qthresh"},
  89     {0, NULL, NULL},
  90   };
  91
  92   if (!superres_mode_type) {
  93     superres_mode_type =
  94         g_enum_register_static ("GstAV1EncSuperresMode", superres_mode);
  95   }
  96   return superres_mode_type;
  97 }
  98
  99 #define GST_TYPE_END_USAGE_MODE (gst_end_usage_mode_get_type())
 100 static GType
 101 gst_end_usage_mode_get_type (void)
 102 {
 103   static GType end_usage_mode_type = 0;
 104   static const GEnumValue end_usage_mode[] = {
 105     {GST_AV1_ENC_END_USAGE_VBR, "Variable Bit Rate Mode", "vbr"},
 106     {GST_AV1_ENC_END_USAGE_CBR, "Constant Bit Rate Mode", "cbr"},
 107     {GST_AV1_ENC_END_USAGE_CQ, "Constrained Quality Mode", "cq"},
 108     {GST_AV1_ENC_END_USAGE_Q, "Constant Quality Mode", "q"},
 109     {0, NULL, NULL},
 110   };
 111
 112   if (!end_usage_mode_type) {
 113     end_usage_mode_type =
 114         g_enum_register_static ("GstAV1EncEndUsageMode", end_usage_mode);
 115   }
 116   return end_usage_mode_type;
 117 }
 118
 119 enum
 120 {
 121   LAST_SIGNAL
 122 };
 123
 124 enum
 125 {
 126   PROP_0,
 127   PROP_CPU_USED,
 128   PROP_DROP_FRAME,
 129   PROP_RESIZE_MODE,
 130   PROP_RESIZE_DENOMINATOR,
 131   PROP_RESIZE_KF_DENOMINATOR,
 132   PROP_SUPERRES_MODE,
 133   PROP_SUPERRES_DENOMINATOR,
 134   PROP_SUPERRES_KF_DENOMINATOR,
 135   PROP_SUPERRES_QTHRESH,
 136   PROP_SUPERRES_KF_QTHRESH,
 137   PROP_END_USAGE,
 138   PROP_TARGET_BITRATE,
 139   PROP_MIN_QUANTIZER,
 140   PROP_MAX_QUANTIZER,
 141   PROP_UNDERSHOOT_PCT,
 142   PROP_OVERSHOOT_PCT,
 143   PROP_BUF_SZ,
 144   PROP_BUF_INITIAL_SZ,
 145   PROP_BUF_OPTIMAL_SZ,
 146   PROP_THREADS,
 147   PROP_ROW_MT,
 148   PROP_TILE_COLUMNS,
 149   PROP_TILE_ROWS
 150 };
 151
 152 /* From av1/av1_cx_iface.c */
 153 #define DEFAULT_PROFILE                                         0
 154 #define DEFAULT_CPU_USED                                        0
 155 #define DEFAULT_DROP_FRAME                                      0
 156 #define DEFAULT_RESIZE_MODE               GST_AV1_ENC_RESIZE_NONE
 157 #define DEFAULT_RESIZE_DENOMINATOR                              8
 158 #define DEFAULT_RESIZE_KF_DENOMINATOR                           8
 159 #define DEFAULT_SUPERRES_MODE           GST_AV1_ENC_SUPERRES_NONE
 160 #define DEFAULT_SUPERRES_DENOMINATOR                            8
 161 #define DEFAULT_SUPERRES_KF_DENOMINATOR                         8
 162 #define DEFAULT_SUPERRES_QTHRESH                               63
 163 #define DEFAULT_SUPERRES_KF_QTHRESH                            63
 164 #define DEFAULT_END_USAGE               GST_AV1_ENC_END_USAGE_VBR
 165 #define DEFAULT_TARGET_BITRATE                                256
 166 #define DEFAULT_MIN_QUANTIZER                                   0
 167 #define DEFAULT_MAX_QUANTIZER                                   0
 168 #define DEFAULT_UNDERSHOOT_PCT                                 25
 169 #define DEFAULT_OVERSHOOT_PCT                                  25
 170 #define DEFAULT_BUF_SZ                                       6000
 171 #define DEFAULT_BUF_INITIAL_SZ                               4000
 172 #define DEFAULT_BUF_OPTIMAL_SZ                               5000
 173 #define DEFAULT_TIMEBASE_N                                      1
 174 #define DEFAULT_TIMEBASE_D                                     30
 175 #define DEFAULT_BIT_DEPTH                              AOM_BITS_8
 176 #define DEFAULT_THREADS                                         0
 177 #define DEFAULT_ROW_MT                                       TRUE
 178 #define DEFAULT_TILE_COLUMNS                                    0
 179 #define DEFAULT_TILE_ROWS                                       0
 180
 181 static void gst_av1_enc_finalize (GObject * object);
 182 static void gst_av1_enc_set_property (GObject * object, guint prop_id,
 183     const GValue * value, GParamSpec * pspec);
 184 static void gst_av1_enc_get_property (GObject * object, guint prop_id,
 185     GValue * value, GParamSpec * pspec);
 186
 187 static gboolean gst_av1_enc_start (GstVideoEncoder * encoder);
 188 static gboolean gst_av1_enc_stop (GstVideoEncoder * encoder);
 189 static gboolean gst_av1_enc_set_format (GstVideoEncoder * encoder,
 190     GstVideoCodecState * state);
 191 static GstFlowReturn gst_av1_enc_handle_frame (GstVideoEncoder * encoder,
 192     GstVideoCodecFrame * frame);
 193 static GstFlowReturn gst_av1_enc_finish (GstVideoEncoder * encoder);
 194 static gboolean gst_av1_enc_propose_allocation (GstVideoEncoder * encoder,
 195     GstQuery * query);
 196
 197 static void gst_av1_enc_destroy_encoder (GstAV1Enc * av1enc);
 198
 199 #define gst_av1_enc_parent_class parent_class
 200 G_DEFINE_TYPE (GstAV1Enc, gst_av1_enc, GST_TYPE_VIDEO_ENCODER);
 201 GST_ELEMENT_REGISTER_DEFINE (av1enc, "av1enc", GST_RANK_PRIMARY,
 202     GST_TYPE_AV1_ENC);
 203
 204 /* *INDENT-OFF* */
 205 static GstStaticPadTemplate gst_av1_enc_sink_pad_template =
 206 GST_STATIC_PAD_TEMPLATE ("sink",
 207     GST_PAD_SINK,
 208     GST_PAD_ALWAYS,
 209         GST_STATIC_CAPS ("video/x-raw, "
 210         "format = (string) { I420, Y42B, Y444, YV12 }, "
 211         "framerate = (fraction) [0, MAX], "
 212         "width = (int) [ 4, MAX ], "
 213         "height = (int) [ 4, MAX ]")
 214     );
 215 /* *INDENT-ON* */
 216
 217 static GstStaticPadTemplate gst_av1_enc_src_pad_template =
 218 GST_STATIC_PAD_TEMPLATE ("src",
 219     GST_PAD_SRC,
 220     GST_PAD_ALWAYS,
 221     GST_STATIC_CAPS ("video/x-av1")
 222     );
 223
 224 static void
 225 gst_av1_enc_class_init (GstAV1EncClass * klass)
 226 {
 227   GObjectClass *gobject_class;
 228   GstElementClass *element_class;
 229   GstVideoEncoderClass *venc_class;
 230
 231   gobject_class = (GObjectClass *) klass;
 232   element_class = (GstElementClass *) klass;
 233   venc_class = (GstVideoEncoderClass *) klass;
 234
 235   parent_class = g_type_class_peek_parent (klass);
 236
 237   gobject_class->finalize = gst_av1_enc_finalize;
 238   gobject_class->set_property = gst_av1_enc_set_property;
 239   gobject_class->get_property = gst_av1_enc_get_property;
 240
 241   gst_element_class_add_static_pad_template (element_class,
 242       &gst_av1_enc_sink_pad_template);
 243   gst_element_class_add_static_pad_template (element_class,
 244       &gst_av1_enc_src_pad_template);
 245   gst_element_class_set_static_metadata (element_class, "AV1 Encoder",
 246       "Codec/Encoder/Video", "Encode AV1 video streams",
 247       "Sean DuBois <sean@siobud.com>");
 248
 249   venc_class->start = gst_av1_enc_start;
 250   venc_class->stop = gst_av1_enc_stop;
 251   venc_class->set_format = gst_av1_enc_set_format;
 252   venc_class->handle_frame = gst_av1_enc_handle_frame;
 253   venc_class->finish = gst_av1_enc_finish;
 254   venc_class->propose_allocation = gst_av1_enc_propose_allocation;
 255
 256   klass->codec_algo = &aom_codec_av1_cx_algo;
 257   GST_DEBUG_CATEGORY_INIT (av1_enc_debug, "av1enc", 0, "AV1 encoding element");
 258
 259   g_object_class_install_property (gobject_class, PROP_CPU_USED,
 260       g_param_spec_int ("cpu-used", "CPU Used",
 261           "CPU Used. A Value greater than 0 will increase encoder speed at the expense of quality.",
 262           0, 5, DEFAULT_CPU_USED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 263
 264   /* Rate control configurations */
 265   g_object_class_install_property (gobject_class, PROP_DROP_FRAME,
 266       g_param_spec_uint ("drop-frame", "Drop frame",
 267           "Temporal resampling configuration, drop frames as a strategy to meet "
 268           "its target data rate Set to zero (0) to disable this feature.",
 269           0, G_MAXUINT, DEFAULT_DROP_FRAME,
 270           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 271
 272   g_object_class_install_property (gobject_class, PROP_RESIZE_MODE,
 273       g_param_spec_enum ("resize-mode", "Resize mode",
 274           "Frame resize mode", GST_TYPE_RESIZE_MODE,
 275           DEFAULT_RESIZE_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 276
 277   g_object_class_install_property (gobject_class, PROP_RESIZE_DENOMINATOR,
 278       g_param_spec_uint ("resize-denominator", "Resize denominator",
 279           "Frame resize denominator, assuming 8 as the numerator",
 280           8, 16, DEFAULT_RESIZE_DENOMINATOR,
 281           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 282
 283   g_object_class_install_property (gobject_class, PROP_RESIZE_KF_DENOMINATOR,
 284       g_param_spec_uint ("resize-kf-denominator", "Resize keyframe denominator",
 285           "Frame resize keyframe denominator, assuming 8 as the numerator",
 286           8, 16, DEFAULT_RESIZE_KF_DENOMINATOR,
 287           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 288
 289   g_object_class_install_property (gobject_class, PROP_SUPERRES_MODE,
 290       g_param_spec_enum ("superres-mode", "Super-resolution scaling mode",
 291           "It integrates upscaling after the encode/decode process",
 292           GST_TYPE_SUPERRES_MODE,
 293           DEFAULT_SUPERRES_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 294
 295   g_object_class_install_property (gobject_class, PROP_SUPERRES_DENOMINATOR,
 296       g_param_spec_uint ("superres-denominator", "Super-resolution denominator",
 297           "Frame super-resolution denominator, used only by SUPERRES_FIXED mode",
 298           8, 16, DEFAULT_SUPERRES_DENOMINATOR,
 299           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 300
 301   g_object_class_install_property (gobject_class, PROP_SUPERRES_KF_DENOMINATOR,
 302       g_param_spec_uint ("superres-kf-denominator",
 303           "Keyframe super-resolution denominator",
 304           "Keyframe super-resolution denominator",
 305           8, 16, DEFAULT_SUPERRES_KF_DENOMINATOR,
 306           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 307
 308   g_object_class_install_property (gobject_class, PROP_SUPERRES_QTHRESH,
 309       g_param_spec_uint ("superres-qthresh",
 310           "Frame super-resolution qindex threshold",
 311           "Frame super-resolution qindex threshold, used only by SUPERRES_QTHRESH mode",
 312           1, 63, DEFAULT_SUPERRES_QTHRESH,
 313           (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 314
 315   g_object_class_install_property (gobject_class, PROP_SUPERRES_KF_QTHRESH,
 316       g_param_spec_uint ("superres-kf-qthresh",
 317           "Keyframe super-resolution qindex threshold",
 318           "Keyframe super-resolution qindex threshold, used only by SUPERRES_QTHRESH mode",
 319           1, 63, DEFAULT_SUPERRES_KF_QTHRESH,
 320           (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 321
 322   g_object_class_install_property (gobject_class, PROP_END_USAGE,
 323       g_param_spec_enum ("end-usage", "Rate control mode",
 324           "Rate control algorithm to use, indicates the end usage of this stream",
 325           GST_TYPE_END_USAGE_MODE, DEFAULT_END_USAGE,
 326           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 327
 328   g_object_class_install_property (gobject_class, PROP_TARGET_BITRATE,
 329       g_param_spec_uint ("target-bitrate", "Target bitrate",
 330           "Target bitrate, in kilobits per second",
 331           1, G_MAXUINT, DEFAULT_TARGET_BITRATE,
 332           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 333
 334   g_object_class_install_property (gobject_class, PROP_MIN_QUANTIZER,
 335       g_param_spec_uint ("min-quantizer", "Minimum (best quality) quantizer",
 336           "Minimum (best quality) quantizer",
 337           0, G_MAXUINT, DEFAULT_MIN_QUANTIZER,
 338           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 339
 340   g_object_class_install_property (gobject_class, PROP_MAX_QUANTIZER,
 341       g_param_spec_uint ("max-quantizer", "Maximum (worst quality) quantizer",
 342           "Maximum (worst quality) quantizer",
 343           0, G_MAXUINT, DEFAULT_MAX_QUANTIZER,
 344           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 345
 346   g_object_class_install_property (gobject_class, PROP_UNDERSHOOT_PCT,
 347       g_param_spec_uint ("undershoot-pct", "Datarate undershoot (min) target",
 348           "Rate control adaptation undershoot control",
 349           0, 1000, DEFAULT_UNDERSHOOT_PCT,
 350           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 351
 352   g_object_class_install_property (gobject_class, PROP_OVERSHOOT_PCT,
 353       g_param_spec_uint ("overshoot-pct", "Datarate overshoot (max) target",
 354           "Rate control adaptation overshoot control",
 355           0, 1000, DEFAULT_OVERSHOOT_PCT,
 356           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 357
 358   g_object_class_install_property (gobject_class, PROP_BUF_SZ,
 359       g_param_spec_uint ("buf-sz", "Decoder buffer size",
 360           "Decoder buffer size, expressed in units of time (milliseconds)",
 361           0, G_MAXUINT, DEFAULT_BUF_SZ,
 362           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 363
 364   g_object_class_install_property (gobject_class, PROP_BUF_INITIAL_SZ,
 365       g_param_spec_uint ("buf-initial-sz", "Decoder buffer initial size",
 366           "Decoder buffer initial size, expressed in units of time (milliseconds)",
 367           0, G_MAXUINT, DEFAULT_BUF_INITIAL_SZ,
 368           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 369
 370   g_object_class_install_property (gobject_class, PROP_BUF_OPTIMAL_SZ,
 371       g_param_spec_uint ("buf-optimal-sz", "Decoder buffer optimal size",
 372           "Decoder buffer optimal size, expressed in units of time (milliseconds)",
 373           0, G_MAXUINT, DEFAULT_BUF_OPTIMAL_SZ,
 374           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 375
 376   g_object_class_install_property (gobject_class, PROP_THREADS,
 377       g_param_spec_uint ("threads", "Max number of threads to use",
 378           "Max number of threads to use encoding, set to 0 determine the "
 379           "approximate number of threads that the system schedule",
 380           0, G_MAXUINT, DEFAULT_THREADS,
 381           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 382
 383 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
 384   g_object_class_install_property (gobject_class, PROP_ROW_MT,
 385       g_param_spec_boolean ("row-mt", "Row based multi-threading",
 386           "Enable row based multi-threading",
 387           DEFAULT_ROW_MT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 388 #endif
 389
 390   g_object_class_install_property (gobject_class, PROP_TILE_COLUMNS,
 391       g_param_spec_uint ("tile-columns", "Number of tile columns",
 392           "Partition into separate vertical tile columns from image frame which "
 393           "can enable parallel encoding",
 394           0, 6, DEFAULT_TILE_COLUMNS,
 395           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 396
 397   g_object_class_install_property (gobject_class, PROP_TILE_ROWS,
 398       g_param_spec_uint ("tile-rows", "Number of tile rows",
 399           "Partition into separate horizontal tile rows from image frame which "
 400           "can enable parallel encoding",
 401           0, 6, DEFAULT_TILE_ROWS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 402
 403   gst_type_mark_as_plugin_api (GST_TYPE_END_USAGE_MODE, 0);
 404   gst_type_mark_as_plugin_api (GST_TYPE_RESIZE_MODE, 0);
 405   gst_type_mark_as_plugin_api (GST_TYPE_SUPERRES_MODE, 0);
 406 }
 407
 408 static void
 409 gst_av1_codec_error (aom_codec_ctx_t * ctx, const char *s)
 410 {
 411   const char *detail = aom_codec_error_detail (ctx);
 412
 413   GST_ERROR ("%s: %s %s", s, aom_codec_error (ctx), detail ? detail : "");
 414 }
 415
 416 static void
 417 gst_av1_enc_init (GstAV1Enc * av1enc)
 418 {
 419   GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_ENCODER_SINK_PAD (av1enc));
 420
 421   av1enc->encoder_inited = FALSE;
 422
 423   av1enc->keyframe_dist = 30;
 424   av1enc->cpu_used = DEFAULT_CPU_USED;
 425   av1enc->format = AOM_IMG_FMT_I420;
 426   av1enc->threads = DEFAULT_THREADS;
 427   av1enc->row_mt = DEFAULT_ROW_MT;
 428   av1enc->tile_columns = DEFAULT_TILE_COLUMNS;
 429   av1enc->tile_rows = DEFAULT_TILE_ROWS;
 430
 431   av1enc->aom_cfg.rc_dropframe_thresh = DEFAULT_DROP_FRAME;
 432   av1enc->aom_cfg.rc_resize_mode = DEFAULT_RESIZE_MODE;
 433   av1enc->aom_cfg.rc_resize_denominator = DEFAULT_RESIZE_DENOMINATOR;
 434   av1enc->aom_cfg.rc_resize_kf_denominator = DEFAULT_RESIZE_KF_DENOMINATOR;
 435   av1enc->aom_cfg.rc_superres_mode = DEFAULT_SUPERRES_MODE;
 436   av1enc->aom_cfg.rc_superres_denominator = DEFAULT_SUPERRES_DENOMINATOR;
 437   av1enc->aom_cfg.rc_superres_kf_denominator = DEFAULT_SUPERRES_KF_DENOMINATOR;
 438   av1enc->aom_cfg.rc_superres_qthresh = DEFAULT_SUPERRES_QTHRESH;
 439   av1enc->aom_cfg.rc_superres_kf_qthresh = DEFAULT_SUPERRES_KF_QTHRESH;
 440   av1enc->aom_cfg.rc_end_usage = (enum aom_rc_mode) DEFAULT_END_USAGE;
 441   av1enc->aom_cfg.rc_target_bitrate = DEFAULT_TARGET_BITRATE;
 442   av1enc->aom_cfg.rc_min_quantizer = DEFAULT_MIN_QUANTIZER;
 443   av1enc->aom_cfg.rc_max_quantizer = DEFAULT_MAX_QUANTIZER;
 444   av1enc->aom_cfg.rc_undershoot_pct = DEFAULT_UNDERSHOOT_PCT;
 445   av1enc->aom_cfg.rc_overshoot_pct = DEFAULT_OVERSHOOT_PCT;
 446   av1enc->aom_cfg.rc_buf_sz = DEFAULT_BUF_SZ;
 447   av1enc->aom_cfg.rc_buf_initial_sz = DEFAULT_BUF_INITIAL_SZ;
 448   av1enc->aom_cfg.rc_buf_optimal_sz = DEFAULT_BUF_OPTIMAL_SZ;
 449   av1enc->aom_cfg.g_timebase.num = DEFAULT_TIMEBASE_N;
 450   av1enc->aom_cfg.g_timebase.den = DEFAULT_TIMEBASE_D;
 451   av1enc->aom_cfg.g_bit_depth = DEFAULT_BIT_DEPTH;
 452   av1enc->aom_cfg.g_input_bit_depth = (unsigned int) DEFAULT_BIT_DEPTH;
 453
 454   g_mutex_init (&av1enc->encoder_lock);
 455 }
 456
 457 static void
 458 gst_av1_enc_finalize (GObject * object)
 459 {
 460   GstAV1Enc *av1enc = GST_AV1_ENC (object);
 461
 462   if (av1enc->input_state) {
 463     gst_video_codec_state_unref (av1enc->input_state);
 464   }
 465   av1enc->input_state = NULL;
 466
 467   gst_av1_enc_destroy_encoder (av1enc);
 468   g_mutex_clear (&av1enc->encoder_lock);
 469
 470   G_OBJECT_CLASS (parent_class)->finalize (object);
 471 }
 472
 473 static void
 474 gst_av1_enc_set_latency (GstAV1Enc * av1enc)
 475 {
 476   GstClockTime latency;
 477   gint fps_n, fps_d;
 478
 479   if (av1enc->input_state->info.fps_n && av1enc->input_state->info.fps_d) {
 480     fps_n = av1enc->input_state->info.fps_n;
 481     fps_d = av1enc->input_state->info.fps_d;
 482   } else {
 483     fps_n = 25;
 484     fps_d = 1;
 485   }
 486
 487   latency =
 488       gst_util_uint64_scale (av1enc->aom_cfg.g_lag_in_frames * GST_SECOND,
 489       fps_d, fps_n);
 490   gst_video_encoder_set_latency (GST_VIDEO_ENCODER (av1enc), latency, latency);
 491
 492   GST_DEBUG_OBJECT (av1enc, "Latency set to %" GST_TIME_FORMAT
 493       " = %d frames at %d/%d fps ", GST_TIME_ARGS (latency),
 494       av1enc->aom_cfg.g_lag_in_frames, fps_n, fps_d);
 495 }
 496
 497 static const gchar *
 498 gst_av1_enc_get_aom_rc_mode_name (enum aom_rc_mode rc_mode)
 499 {
 500   switch (rc_mode) {
 501     case AOM_VBR:
 502       return "VBR (Variable Bit Rate)";
 503     case AOM_CBR:
 504       return "CBR (Constant Bit Rate)";
 505     case AOM_CQ:
 506       return "CQ (Constrained Quality)";
 507     case AOM_Q:
 508       return "Q (Constant Quality)";
 509     default:
 510       return "<UNKNOWN>";
 511   }
 512 }
 513
 514 static void
 515 gst_av1_enc_debug_encoder_cfg (struct aom_codec_enc_cfg *cfg)
 516 {
 517   GST_DEBUG ("g_usage : %u", cfg->g_usage);
 518   GST_DEBUG ("g_threads : %u", cfg->g_threads);
 519   GST_DEBUG ("g_profile : %u", cfg->g_profile);
 520   GST_DEBUG ("g_w x g_h : %u x %u", cfg->g_w, cfg->g_h);
 521   GST_DEBUG ("g_bit_depth : %d", cfg->g_bit_depth);
 522   GST_DEBUG ("g_input_bit_depth : %u", cfg->g_input_bit_depth);
 523   GST_DEBUG ("g_timebase : %d / %d", cfg->g_timebase.num, cfg->g_timebase.den);
 524   GST_DEBUG ("g_error_resilient : 0x%x", cfg->g_error_resilient);
 525   GST_DEBUG ("g_pass : %d", cfg->g_pass);
 526   GST_DEBUG ("g_lag_in_frames : %u", cfg->g_lag_in_frames);
 527   GST_DEBUG ("rc_dropframe_thresh : %u", cfg->rc_dropframe_thresh);
 528   GST_DEBUG ("rc_resize_mode : %u", cfg->rc_resize_mode);
 529   GST_DEBUG ("rc_resize_denominator : %u", cfg->rc_resize_denominator);
 530   GST_DEBUG ("rc_resize_kf_denominator : %u", cfg->rc_resize_kf_denominator);
 531   GST_DEBUG ("rc_superres_mode : %u", cfg->rc_superres_mode);
 532   GST_DEBUG ("rc_superres_denominator : %u", cfg->rc_superres_denominator);
 533   GST_DEBUG ("rc_superres_kf_denominator : %u",
 534       cfg->rc_superres_kf_denominator);
 535   GST_DEBUG ("rc_superres_qthresh : %u", cfg->rc_superres_qthresh);
 536   GST_DEBUG ("rc_superres_kf_qthresh : %u", cfg->rc_superres_kf_qthresh);
 537   GST_DEBUG ("rc_end_usage : %s",
 538       gst_av1_enc_get_aom_rc_mode_name (cfg->rc_end_usage));
 539   /* rc_twopass_stats_in */
 540   /* rc_firstpass_mb_stats_in */
 541   GST_DEBUG ("rc_target_bitrate : %u (kbps)", cfg->rc_target_bitrate);
 542   GST_DEBUG ("rc_min_quantizer : %u", cfg->rc_min_quantizer);
 543   GST_DEBUG ("rc_max_quantizer : %u", cfg->rc_max_quantizer);
 544   GST_DEBUG ("rc_undershoot_pct : %u", cfg->rc_undershoot_pct);
 545   GST_DEBUG ("rc_overshoot_pct : %u", cfg->rc_overshoot_pct);
 546   GST_DEBUG ("rc_buf_sz : %u (ms)", cfg->rc_buf_sz);
 547   GST_DEBUG ("rc_buf_initial_sz : %u (ms)", cfg->rc_buf_initial_sz);
 548   GST_DEBUG ("rc_buf_optimal_sz : %u (ms)", cfg->rc_buf_optimal_sz);
 549   GST_DEBUG ("rc_2pass_vbr_bias_pct : %u (%%)", cfg->rc_2pass_vbr_bias_pct);
 550   GST_DEBUG ("rc_2pass_vbr_minsection_pct : %u (%%)",
 551       cfg->rc_2pass_vbr_minsection_pct);
 552   GST_DEBUG ("rc_2pass_vbr_maxsection_pct : %u (%%)",
 553       cfg->rc_2pass_vbr_maxsection_pct);
 554   GST_DEBUG ("kf_mode : %u", cfg->kf_mode);
 555   GST_DEBUG ("kf_min_dist : %u", cfg->kf_min_dist);
 556   GST_DEBUG ("kf_max_dist : %u", cfg->kf_max_dist);
 557   GST_DEBUG ("large_scale_tile : %u", cfg->large_scale_tile);
 558   /* Tile-related values */
 559 }
 560
 561 static gint
 562 gst_av1_enc_get_downstream_profile (GstAV1Enc * av1enc)
 563 {
 564   GstCaps *allowed;
 565   GstStructure *s;
 566   gint profile = DEFAULT_PROFILE;
 567
 568   allowed = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (av1enc));
 569   if (allowed) {
 570     allowed = gst_caps_truncate (allowed);
 571     s = gst_caps_get_structure (allowed, 0);
 572     if (gst_structure_has_field (s, "profile")) {
 573       const GValue *v = gst_structure_get_value (s, "profile");
 574       const gchar *profile_str = NULL;
 575
 576       if (GST_VALUE_HOLDS_LIST (v) && gst_value_list_get_size (v) > 0) {
 577         profile_str = g_value_get_string (gst_value_list_get_value (v, 0));
 578       } else if (G_VALUE_HOLDS_STRING (v)) {
 579         profile_str = g_value_get_string (v);
 580       }
 581
 582       if (profile_str) {
 583         gchar *endptr = NULL;
 584
 585         profile = g_ascii_strtoull (profile_str, &endptr, 10);
 586         if (*endptr != '\0' || profile < 0 || profile > 3) {
 587           GST_ERROR_OBJECT (av1enc, "Invalid profile '%s'", profile_str);
 588           profile = DEFAULT_PROFILE;
 589         }
 590       }
 591     }
 592     gst_caps_unref (allowed);
 593   }
 594
 595   GST_DEBUG_OBJECT (av1enc, "Using profile %d", profile);
 596
 597   return profile;
 598 }
 599
 600 static void
 601 gst_av1_enc_adjust_profile (GstAV1Enc * av1enc, GstVideoFormat format)
 602 {
 603   guint depth = av1enc->aom_cfg.g_bit_depth;
 604   guint profile = av1enc->aom_cfg.g_profile;
 605   gboolean update = FALSE;
 606
 607   switch (profile) {
 608     case 0:
 609       if (depth < 12 && format == GST_VIDEO_FORMAT_Y444) {
 610         profile = 1;
 611         update = TRUE;
 612       } else if (depth == 12 || format == GST_VIDEO_FORMAT_Y42B) {
 613         profile = 2;
 614         update = TRUE;
 615       }
 616       break;
 617     case 1:
 618       if (depth == 12 || format == GST_VIDEO_FORMAT_Y42B) {
 619         profile = 2;
 620         update = TRUE;
 621       } else if (depth < 12 && format == GST_VIDEO_FORMAT_I420) {
 622         profile = 0;
 623         update = TRUE;
 624       }
 625       break;
 626     case 2:
 627       if (depth < 12) {
 628         if (format == GST_VIDEO_FORMAT_Y444) {
 629           profile = 1;
 630           update = TRUE;
 631         } else if (format == GST_VIDEO_FORMAT_I420) {
 632           profile = 0;
 633           update = TRUE;
 634         }
 635       }
 636       break;
 637     default:
 638       break;
 639   }
 640
 641   if (update) {
 642     GST_INFO_OBJECT (av1enc, "profile updated to %d from %d",
 643         profile, av1enc->aom_cfg.g_profile);
 644     av1enc->aom_cfg.g_profile = profile;
 645   }
 646 }
 647
 648 static gboolean
 649 gst_av1_enc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state)
 650 {
 651   GstVideoCodecState *output_state;
 652   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 653   GstAV1EncClass *av1enc_class = GST_AV1_ENC_GET_CLASS (av1enc);
 654   GstVideoInfo *info = &state->info;
 655
 656   output_state =
 657       gst_video_encoder_set_output_state (encoder,
 658       gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder)),
 659       state);
 660   gst_video_codec_state_unref (output_state);
 661
 662   if (av1enc->input_state) {
 663     gst_video_codec_state_unref (av1enc->input_state);
 664   }
 665   av1enc->input_state = gst_video_codec_state_ref (state);
 666
 667   g_mutex_lock (&av1enc->encoder_lock);
 668   gst_av1_enc_set_latency (av1enc);
 669
 670   av1enc->aom_cfg.g_profile = gst_av1_enc_get_downstream_profile (av1enc);
 671
 672   /* Scale default bitrate to our size */
 673   if (!av1enc->target_bitrate_set)
 674     av1enc->aom_cfg.rc_target_bitrate =
 675         gst_util_uint64_scale (DEFAULT_TARGET_BITRATE,
 676         GST_VIDEO_INFO_WIDTH (info) * GST_VIDEO_INFO_HEIGHT (info), 320 * 240);
 677
 678   av1enc->aom_cfg.g_w = GST_VIDEO_INFO_WIDTH (info);
 679   av1enc->aom_cfg.g_h = GST_VIDEO_INFO_HEIGHT (info);
 680   /* Recommended method is to set the timebase to that of the parent
 681    * container or multimedia framework (ex: 1/1000 for ms, as in FLV) */
 682   av1enc->aom_cfg.g_timebase.num = GST_VIDEO_INFO_FPS_D (info);
 683   av1enc->aom_cfg.g_timebase.den = GST_VIDEO_INFO_FPS_N (info);
 684   av1enc->aom_cfg.g_error_resilient = AOM_ERROR_RESILIENT_DEFAULT;
 685
 686   if (av1enc->threads == DEFAULT_THREADS)
 687     av1enc->aom_cfg.g_threads = g_get_num_processors ();
 688   else
 689     av1enc->aom_cfg.g_threads = av1enc->threads;
 690   /* TODO: do more configuration including bit_depth config */
 691
 692   av1enc->format =
 693       gst_video_format_to_av1_img_format (GST_VIDEO_INFO_FORMAT (info));
 694
 695   if (av1enc->aom_cfg.g_bit_depth != DEFAULT_BIT_DEPTH) {
 696     av1enc->aom_cfg.g_input_bit_depth = av1enc->aom_cfg.g_bit_depth;
 697     if (av1enc->aom_cfg.g_bit_depth > 8)
 698       av1enc->format |= AOM_IMG_FMT_HIGHBITDEPTH;
 699   }
 700
 701   /* Adjust profile according to format and bit-depth */
 702   gst_av1_enc_adjust_profile (av1enc, GST_VIDEO_INFO_FORMAT (info));
 703
 704   GST_DEBUG_OBJECT (av1enc, "Calling encoder init with config:");
 705   gst_av1_enc_debug_encoder_cfg (&av1enc->aom_cfg);
 706
 707   if (aom_codec_enc_init (&av1enc->encoder, av1enc_class->codec_algo,
 708           &av1enc->aom_cfg, 0)) {
 709     gst_av1_codec_error (&av1enc->encoder, "Failed to initialize encoder");
 710     g_mutex_unlock (&av1enc->encoder_lock);
 711     return FALSE;
 712   }
 713   av1enc->encoder_inited = TRUE;
 714
 715   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AOME_SET_CPUUSED, av1enc->cpu_used);
 716 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
 717   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_ROW_MT,
 718       (av1enc->row_mt ? 1 : 0));
 719 #endif
 720   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_COLUMNS,
 721       av1enc->tile_columns);
 722   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_ROWS,
 723       av1enc->tile_rows);
 724   g_mutex_unlock (&av1enc->encoder_lock);
 725
 726   return TRUE;
 727 }
 728
 729 static GstFlowReturn
 730 gst_av1_enc_process (GstAV1Enc * encoder)
 731 {
 732   aom_codec_iter_t iter = NULL;
 733   const aom_codec_cx_pkt_t *pkt;
 734   GstVideoCodecFrame *frame;
 735   GstVideoEncoder *video_encoder;
 736   GstFlowReturn ret = GST_FLOW_CUSTOM_SUCCESS;
 737
 738   video_encoder = GST_VIDEO_ENCODER (encoder);
 739
 740   while ((pkt = aom_codec_get_cx_data (&encoder->encoder, &iter)) != NULL) {
 741     if (pkt->kind == AOM_CODEC_STATS_PKT) {
 742       GST_WARNING_OBJECT (encoder, "Unhandled stats packet");
 743     } else if (pkt->kind == AOM_CODEC_FPMB_STATS_PKT) {
 744       GST_WARNING_OBJECT (encoder, "Unhandled FPMB pkt");
 745     } else if (pkt->kind == AOM_CODEC_PSNR_PKT) {
 746       GST_WARNING_OBJECT (encoder, "Unhandled PSNR packet");
 747     } else if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
 748       frame = gst_video_encoder_get_oldest_frame (video_encoder);
 749       g_assert (frame != NULL);
 750       if ((pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0) {
 751         GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
 752       } else {
 753         GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
 754       }
 755
 756       frame->output_buffer =
 757           gst_buffer_new_memdup (pkt->data.frame.buf, pkt->data.frame.sz);
 758
 759       if ((pkt->data.frame.flags & AOM_FRAME_IS_DROPPABLE) != 0)
 760         GST_BUFFER_FLAG_SET (frame->output_buffer, GST_BUFFER_FLAG_DROPPABLE);
 761
 762       ret = gst_video_encoder_finish_frame (video_encoder, frame);
 763       if (ret != GST_FLOW_OK)
 764         break;
 765     }
 766   }
 767
 768   return ret;
 769 }
 770
 771 static void
 772 gst_av1_enc_fill_image (GstAV1Enc * enc, GstVideoFrame * frame,
 773     aom_image_t * image)
 774 {
 775   image->planes[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
 776   image->planes[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
 777   image->planes[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_DATA (frame, 2);
 778
 779   image->stride[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
 780   image->stride[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1);
 781   image->stride[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 2);
 782 }
 783
 784 static GstFlowReturn
 785 gst_av1_enc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame)
 786 {
 787   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 788   aom_image_t raw;
 789   int flags = 0;
 790   GstFlowReturn ret = GST_FLOW_OK;
 791   GstVideoFrame vframe;
 792
 793   if (!aom_img_alloc (&raw, av1enc->format, av1enc->aom_cfg.g_w,
 794           av1enc->aom_cfg.g_h, 1)) {
 795     GST_ERROR_OBJECT (encoder, "Failed to initialize encoder");
 796     return FALSE;
 797   }
 798
 799   gst_video_frame_map (&vframe, &av1enc->input_state->info,
 800       frame->input_buffer, GST_MAP_READ);
 801   gst_av1_enc_fill_image (av1enc, &vframe, &raw);
 802   gst_video_frame_unmap (&vframe);
 803
 804   if (av1enc->keyframe_dist >= 30) {
 805     av1enc->keyframe_dist = 0;
 806     flags |= AOM_EFLAG_FORCE_KF;
 807   }
 808   av1enc->keyframe_dist++;
 809
 810   g_mutex_lock (&av1enc->encoder_lock);
 811   if (aom_codec_encode (&av1enc->encoder, &raw, frame->pts, 1, flags)
 812       != AOM_CODEC_OK) {
 813     gst_av1_codec_error (&av1enc->encoder, "Failed to encode frame");
 814     ret = GST_FLOW_ERROR;
 815   }
 816   g_mutex_unlock (&av1enc->encoder_lock);
 817
 818   aom_img_free (&raw);
 819   gst_video_codec_frame_unref (frame);
 820
 821   if (ret == GST_FLOW_ERROR)
 822     return ret;
 823
 824   ret = gst_av1_enc_process (av1enc);
 825
 826   if (ret == GST_FLOW_CUSTOM_SUCCESS)
 827     ret = GST_FLOW_OK;
 828
 829   return ret;
 830 }
 831
 832 static GstFlowReturn
 833 gst_av1_enc_finish (GstVideoEncoder * encoder)
 834 {
 835   GstFlowReturn ret = GST_FLOW_OK;
 836   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 837
 838   while (ret == GST_FLOW_OK) {
 839     GST_DEBUG_OBJECT (encoder, "Calling finish");
 840     g_mutex_lock (&av1enc->encoder_lock);
 841     if (aom_codec_encode (&av1enc->encoder, NULL, 0, 1, 0)
 842         != AOM_CODEC_OK) {
 843       gst_av1_codec_error (&av1enc->encoder, "Failed to encode frame");
 844       ret = GST_FLOW_ERROR;
 845     }
 846     g_mutex_unlock (&av1enc->encoder_lock);
 847
 848     ret = gst_av1_enc_process (av1enc);
 849   }
 850
 851
 852   if (ret == GST_FLOW_CUSTOM_SUCCESS)
 853     ret = GST_FLOW_OK;
 854
 855   return ret;
 856 }
 857
 858 static void
 859 gst_av1_enc_destroy_encoder (GstAV1Enc * av1enc)
 860 {
 861   g_mutex_lock (&av1enc->encoder_lock);
 862   if (av1enc->encoder_inited) {
 863     aom_codec_destroy (&av1enc->encoder);
 864     av1enc->encoder_inited = FALSE;
 865   }
 866   g_mutex_unlock (&av1enc->encoder_lock);
 867 }
 868
 869 static gboolean
 870 gst_av1_enc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query)
 871 {
 872   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
 873
 874   return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder,
 875       query);
 876 }
 877
 878 static void
 879 gst_av1_enc_set_property (GObject * object, guint prop_id,
 880     const GValue * value, GParamSpec * pspec)
 881 {
 882   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (object);
 883   gboolean global = FALSE;
 884   aom_codec_err_t status;
 885
 886   GST_OBJECT_LOCK (av1enc);
 887
 888   g_mutex_lock (&av1enc->encoder_lock);
 889   switch (prop_id) {
 890     case PROP_CPU_USED:
 891       av1enc->cpu_used = g_value_get_int (value);
 892       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AOME_SET_CPUUSED,
 893           av1enc->cpu_used);
 894       break;
 895     case PROP_DROP_FRAME:
 896       av1enc->aom_cfg.rc_dropframe_thresh = g_value_get_uint (value);
 897       global = TRUE;
 898       break;
 899     case PROP_RESIZE_MODE:
 900       av1enc->aom_cfg.rc_resize_mode = g_value_get_enum (value);
 901       global = TRUE;
 902       break;
 903     case PROP_RESIZE_DENOMINATOR:
 904       av1enc->aom_cfg.rc_resize_denominator = g_value_get_uint (value);
 905       global = TRUE;
 906       break;
 907     case PROP_RESIZE_KF_DENOMINATOR:
 908       av1enc->aom_cfg.rc_resize_kf_denominator = g_value_get_uint (value);
 909       global = TRUE;
 910       break;
 911     case PROP_SUPERRES_MODE:
 912       av1enc->aom_cfg.rc_superres_mode = g_value_get_enum (value);
 913       global = TRUE;
 914       break;
 915     case PROP_SUPERRES_DENOMINATOR:
 916       av1enc->aom_cfg.rc_superres_denominator = g_value_get_uint (value);
 917       global = TRUE;
 918       break;
 919     case PROP_SUPERRES_KF_DENOMINATOR:
 920       av1enc->aom_cfg.rc_superres_kf_denominator = g_value_get_uint (value);
 921       global = TRUE;
 922       break;
 923     case PROP_SUPERRES_QTHRESH:
 924       av1enc->aom_cfg.rc_superres_qthresh = g_value_get_uint (value);
 925       global = TRUE;
 926       break;
 927     case PROP_SUPERRES_KF_QTHRESH:
 928       av1enc->aom_cfg.rc_superres_kf_qthresh = g_value_get_uint (value);
 929       global = TRUE;
 930       break;
 931     case PROP_END_USAGE:
 932       av1enc->aom_cfg.rc_end_usage = g_value_get_enum (value);
 933       global = TRUE;
 934       break;
 935     case PROP_TARGET_BITRATE:
 936       av1enc->aom_cfg.rc_target_bitrate = g_value_get_uint (value);
 937       av1enc->target_bitrate_set = TRUE;
 938       global = TRUE;
 939       break;
 940     case PROP_MIN_QUANTIZER:
 941       av1enc->aom_cfg.rc_min_quantizer = g_value_get_uint (value);
 942       global = TRUE;
 943       break;
 944     case PROP_MAX_QUANTIZER:
 945       av1enc->aom_cfg.rc_max_quantizer = g_value_get_uint (value);
 946       global = TRUE;
 947       break;
 948     case PROP_UNDERSHOOT_PCT:
 949       av1enc->aom_cfg.rc_undershoot_pct = g_value_get_uint (value);
 950       global = TRUE;
 951       break;
 952     case PROP_OVERSHOOT_PCT:
 953       av1enc->aom_cfg.rc_overshoot_pct = g_value_get_uint (value);
 954       global = TRUE;
 955       break;
 956     case PROP_BUF_SZ:
 957       av1enc->aom_cfg.rc_buf_sz = g_value_get_uint (value);
 958       global = TRUE;
 959       break;
 960     case PROP_BUF_INITIAL_SZ:
 961       av1enc->aom_cfg.rc_buf_initial_sz = g_value_get_uint (value);
 962       global = TRUE;
 963       break;
 964     case PROP_BUF_OPTIMAL_SZ:
 965       av1enc->aom_cfg.rc_buf_optimal_sz = g_value_get_uint (value);
 966       global = TRUE;
 967       break;
 968     case PROP_THREADS:
 969       av1enc->threads = g_value_get_uint (value);
 970       global = TRUE;
 971       break;
 972 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
 973     case PROP_ROW_MT:
 974       av1enc->row_mt = g_value_get_boolean (value);
 975       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_ROW_MT,
 976           (av1enc->row_mt ? 1 : 0));
 977       break;
 978 #endif
 979     case PROP_TILE_COLUMNS:
 980       av1enc->tile_columns = g_value_get_uint (value);
 981       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_COLUMNS,
 982           av1enc->tile_columns);
 983       break;
 984     case PROP_TILE_ROWS:
 985       av1enc->tile_rows = g_value_get_uint (value);
 986       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_ROWS,
 987           av1enc->tile_rows);
 988       break;
 989     default:
 990       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 991       break;
 992   }
 993
 994   if (global &&av1enc->encoder_inited) {
 995     status = aom_codec_enc_config_set (&av1enc->encoder, &av1enc->aom_cfg);
 996     GST_DEBUG_OBJECT (av1enc, "Set %s encoder configuration, ret = %s",
 997         pspec->name, gst_av1_get_error_name (status));
 998   }
 999
1000   g_mutex_unlock (&av1enc->encoder_lock);
1001   GST_OBJECT_UNLOCK (av1enc);
1002 }
1003
1004 static void
1005 gst_av1_enc_get_property (GObject * object, guint prop_id, GValue * value,
1006     GParamSpec * pspec)
1007 {
1008   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (object);
1009
1010   GST_OBJECT_LOCK (av1enc);
1011
1012   switch (prop_id) {
1013     case PROP_CPU_USED:
1014       g_value_set_int (value, av1enc->cpu_used);
1015       break;
1016     case PROP_DROP_FRAME:
1017       g_value_set_uint (value, av1enc->aom_cfg.rc_dropframe_thresh);
1018       break;
1019     case PROP_RESIZE_MODE:
1020       g_value_set_enum (value, av1enc->aom_cfg.rc_resize_mode);
1021       break;
1022     case PROP_RESIZE_DENOMINATOR:
1023       g_value_set_uint (value, av1enc->aom_cfg.rc_resize_denominator);
1024       break;
1025     case PROP_RESIZE_KF_DENOMINATOR:
1026       g_value_set_uint (value, av1enc->aom_cfg.rc_resize_kf_denominator);
1027       break;
1028     case PROP_SUPERRES_MODE:
1029       g_value_set_enum (value, av1enc->aom_cfg.rc_superres_mode);
1030       break;
1031     case PROP_SUPERRES_DENOMINATOR:
1032       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_denominator);
1033       break;
1034     case PROP_SUPERRES_KF_DENOMINATOR:
1035       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_kf_denominator);
1036       break;
1037     case PROP_SUPERRES_QTHRESH:
1038       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_qthresh);
1039       break;
1040     case PROP_SUPERRES_KF_QTHRESH:
1041       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_kf_qthresh);
1042       break;
1043     case PROP_END_USAGE:
1044       g_value_set_enum (value, av1enc->aom_cfg.rc_end_usage);
1045       break;
1046     case PROP_TARGET_BITRATE:
1047       g_value_set_uint (value, av1enc->aom_cfg.rc_target_bitrate);
1048       break;
1049     case PROP_MIN_QUANTIZER:
1050       g_value_set_uint (value, av1enc->aom_cfg.rc_min_quantizer);
1051       break;
1052     case PROP_MAX_QUANTIZER:
1053       g_value_set_uint (value, av1enc->aom_cfg.rc_max_quantizer);
1054       break;
1055     case PROP_UNDERSHOOT_PCT:
1056       g_value_set_uint (value, av1enc->aom_cfg.rc_undershoot_pct);
1057       break;
1058     case PROP_OVERSHOOT_PCT:
1059       g_value_set_uint (value, av1enc->aom_cfg.rc_overshoot_pct);
1060       break;
1061     case PROP_BUF_SZ:
1062       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_sz);
1063       break;
1064     case PROP_BUF_INITIAL_SZ:
1065       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_initial_sz);
1066       break;
1067     case PROP_BUF_OPTIMAL_SZ:
1068       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_optimal_sz);
1069       break;
1070     case PROP_THREADS:
1071       g_value_set_uint (value, av1enc->threads);
1072       break;
1073 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
1074     case PROP_ROW_MT:
1075       g_value_set_boolean (value, av1enc->row_mt);
1076       break;
1077 #endif
1078     case PROP_TILE_COLUMNS:
1079       g_value_set_uint (value, av1enc->tile_columns);
1080       break;
1081     case PROP_TILE_ROWS:
1082       g_value_set_uint (value, av1enc->tile_rows);
1083       break;
1084     default:
1085       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1086       break;
1087   }
1088
1089   GST_OBJECT_UNLOCK (av1enc);
1090 }
1091
1092 static gboolean
1093 gst_av1_enc_start (GstVideoEncoder * encoder)
1094 {
1095   return TRUE;
1096 }
1097
1098 static gboolean
1099 gst_av1_enc_stop (GstVideoEncoder * encoder)
1100 {
1101   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
1102
1103   if (av1enc->input_state) {
1104     gst_video_codec_state_unref (av1enc->input_state);
1105   }
1106   av1enc->input_state = NULL;
1107
1108   gst_av1_enc_destroy_encoder (av1enc);
1109
1110   return TRUE;
1111 }