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                                  90000
 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, alignment = (string) tu")
 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 #ifdef FIXED_QP_OFFSET_COUNT
 432   av1enc->aom_cfg.fixed_qp_offsets[0] = -1;
 433   av1enc->aom_cfg.fixed_qp_offsets[1] = -1;
 434   av1enc->aom_cfg.fixed_qp_offsets[2] = -1;
 435   av1enc->aom_cfg.fixed_qp_offsets[3] = -1;
 436   av1enc->aom_cfg.fixed_qp_offsets[4] = -1;
 437 #endif
 438   av1enc->aom_cfg.rc_dropframe_thresh = DEFAULT_DROP_FRAME;
 439   av1enc->aom_cfg.rc_resize_mode = DEFAULT_RESIZE_MODE;
 440   av1enc->aom_cfg.rc_resize_denominator = DEFAULT_RESIZE_DENOMINATOR;
 441   av1enc->aom_cfg.rc_resize_kf_denominator = DEFAULT_RESIZE_KF_DENOMINATOR;
 442   av1enc->aom_cfg.rc_superres_mode = DEFAULT_SUPERRES_MODE;
 443   av1enc->aom_cfg.rc_superres_denominator = DEFAULT_SUPERRES_DENOMINATOR;
 444   av1enc->aom_cfg.rc_superres_kf_denominator = DEFAULT_SUPERRES_KF_DENOMINATOR;
 445   av1enc->aom_cfg.rc_superres_qthresh = DEFAULT_SUPERRES_QTHRESH;
 446   av1enc->aom_cfg.rc_superres_kf_qthresh = DEFAULT_SUPERRES_KF_QTHRESH;
 447   av1enc->aom_cfg.rc_end_usage = (enum aom_rc_mode) DEFAULT_END_USAGE;
 448   av1enc->aom_cfg.rc_target_bitrate = DEFAULT_TARGET_BITRATE;
 449   av1enc->aom_cfg.rc_min_quantizer = DEFAULT_MIN_QUANTIZER;
 450   av1enc->aom_cfg.rc_max_quantizer = DEFAULT_MAX_QUANTIZER;
 451   av1enc->aom_cfg.rc_undershoot_pct = DEFAULT_UNDERSHOOT_PCT;
 452   av1enc->aom_cfg.rc_overshoot_pct = DEFAULT_OVERSHOOT_PCT;
 453   av1enc->aom_cfg.rc_buf_sz = DEFAULT_BUF_SZ;
 454   av1enc->aom_cfg.rc_buf_initial_sz = DEFAULT_BUF_INITIAL_SZ;
 455   av1enc->aom_cfg.rc_buf_optimal_sz = DEFAULT_BUF_OPTIMAL_SZ;
 456   av1enc->aom_cfg.g_timebase.num = DEFAULT_TIMEBASE_N;
 457   av1enc->aom_cfg.g_timebase.den = DEFAULT_TIMEBASE_D;
 458   av1enc->aom_cfg.g_bit_depth = DEFAULT_BIT_DEPTH;
 459   av1enc->aom_cfg.g_input_bit_depth = (unsigned int) DEFAULT_BIT_DEPTH;
 460
 461   g_mutex_init (&av1enc->encoder_lock);
 462 }
 463
 464 static void
 465 gst_av1_enc_finalize (GObject * object)
 466 {
 467   GstAV1Enc *av1enc = GST_AV1_ENC (object);
 468
 469   if (av1enc->input_state) {
 470     gst_video_codec_state_unref (av1enc->input_state);
 471   }
 472   av1enc->input_state = NULL;
 473
 474   gst_av1_enc_destroy_encoder (av1enc);
 475   g_mutex_clear (&av1enc->encoder_lock);
 476
 477   G_OBJECT_CLASS (parent_class)->finalize (object);
 478 }
 479
 480 static void
 481 gst_av1_enc_set_latency (GstAV1Enc * av1enc)
 482 {
 483   GstClockTime latency;
 484   gint fps_n, fps_d;
 485
 486   if (av1enc->input_state->info.fps_n && av1enc->input_state->info.fps_d) {
 487     fps_n = av1enc->input_state->info.fps_n;
 488     fps_d = av1enc->input_state->info.fps_d;
 489   } else {
 490     fps_n = 25;
 491     fps_d = 1;
 492   }
 493
 494   latency =
 495       gst_util_uint64_scale (av1enc->aom_cfg.g_lag_in_frames * GST_SECOND,
 496       fps_d, fps_n);
 497   gst_video_encoder_set_latency (GST_VIDEO_ENCODER (av1enc), latency, latency);
 498
 499   GST_DEBUG_OBJECT (av1enc, "Latency set to %" GST_TIME_FORMAT
 500       " = %d frames at %d/%d fps ", GST_TIME_ARGS (latency),
 501       av1enc->aom_cfg.g_lag_in_frames, fps_n, fps_d);
 502 }
 503
 504 static const gchar *
 505 gst_av1_enc_get_aom_rc_mode_name (enum aom_rc_mode rc_mode)
 506 {
 507   switch (rc_mode) {
 508     case AOM_VBR:
 509       return "VBR (Variable Bit Rate)";
 510     case AOM_CBR:
 511       return "CBR (Constant Bit Rate)";
 512     case AOM_CQ:
 513       return "CQ (Constrained Quality)";
 514     case AOM_Q:
 515       return "Q (Constant Quality)";
 516     default:
 517       return "<UNKNOWN>";
 518   }
 519 }
 520
 521 static void
 522 gst_av1_enc_debug_encoder_cfg (struct aom_codec_enc_cfg *cfg)
 523 {
 524   GST_DEBUG ("g_usage : %u", cfg->g_usage);
 525   GST_DEBUG ("g_threads : %u", cfg->g_threads);
 526   GST_DEBUG ("g_profile : %u", cfg->g_profile);
 527   GST_DEBUG ("g_w x g_h : %u x %u", cfg->g_w, cfg->g_h);
 528   GST_DEBUG ("g_bit_depth : %d", cfg->g_bit_depth);
 529   GST_DEBUG ("g_input_bit_depth : %u", cfg->g_input_bit_depth);
 530   GST_DEBUG ("g_timebase : %d / %d", cfg->g_timebase.num, cfg->g_timebase.den);
 531   GST_DEBUG ("g_error_resilient : 0x%x", cfg->g_error_resilient);
 532   GST_DEBUG ("g_pass : %d", cfg->g_pass);
 533   GST_DEBUG ("g_lag_in_frames : %u", cfg->g_lag_in_frames);
 534   GST_DEBUG ("rc_dropframe_thresh : %u", cfg->rc_dropframe_thresh);
 535   GST_DEBUG ("rc_resize_mode : %u", cfg->rc_resize_mode);
 536   GST_DEBUG ("rc_resize_denominator : %u", cfg->rc_resize_denominator);
 537   GST_DEBUG ("rc_resize_kf_denominator : %u", cfg->rc_resize_kf_denominator);
 538   GST_DEBUG ("rc_superres_mode : %u", cfg->rc_superres_mode);
 539   GST_DEBUG ("rc_superres_denominator : %u", cfg->rc_superres_denominator);
 540   GST_DEBUG ("rc_superres_kf_denominator : %u",
 541       cfg->rc_superres_kf_denominator);
 542   GST_DEBUG ("rc_superres_qthresh : %u", cfg->rc_superres_qthresh);
 543   GST_DEBUG ("rc_superres_kf_qthresh : %u", cfg->rc_superres_kf_qthresh);
 544   GST_DEBUG ("rc_end_usage : %s",
 545       gst_av1_enc_get_aom_rc_mode_name (cfg->rc_end_usage));
 546   /* rc_twopass_stats_in */
 547   /* rc_firstpass_mb_stats_in */
 548   GST_DEBUG ("rc_target_bitrate : %u (kbps)", cfg->rc_target_bitrate);
 549   GST_DEBUG ("rc_min_quantizer : %u", cfg->rc_min_quantizer);
 550   GST_DEBUG ("rc_max_quantizer : %u", cfg->rc_max_quantizer);
 551   GST_DEBUG ("rc_undershoot_pct : %u", cfg->rc_undershoot_pct);
 552   GST_DEBUG ("rc_overshoot_pct : %u", cfg->rc_overshoot_pct);
 553   GST_DEBUG ("rc_buf_sz : %u (ms)", cfg->rc_buf_sz);
 554   GST_DEBUG ("rc_buf_initial_sz : %u (ms)", cfg->rc_buf_initial_sz);
 555   GST_DEBUG ("rc_buf_optimal_sz : %u (ms)", cfg->rc_buf_optimal_sz);
 556   GST_DEBUG ("rc_2pass_vbr_bias_pct : %u (%%)", cfg->rc_2pass_vbr_bias_pct);
 557   GST_DEBUG ("rc_2pass_vbr_minsection_pct : %u (%%)",
 558       cfg->rc_2pass_vbr_minsection_pct);
 559   GST_DEBUG ("rc_2pass_vbr_maxsection_pct : %u (%%)",
 560       cfg->rc_2pass_vbr_maxsection_pct);
 561   GST_DEBUG ("kf_mode : %u", cfg->kf_mode);
 562   GST_DEBUG ("kf_min_dist : %u", cfg->kf_min_dist);
 563   GST_DEBUG ("kf_max_dist : %u", cfg->kf_max_dist);
 564   GST_DEBUG ("large_scale_tile : %u", cfg->large_scale_tile);
 565   /* Tile-related values */
 566 }
 567
 568 static gint
 569 gst_av1_enc_get_downstream_profile (GstAV1Enc * av1enc)
 570 {
 571   GstCaps *allowed;
 572   GstStructure *s;
 573   gint profile = DEFAULT_PROFILE;
 574
 575   allowed = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (av1enc));
 576   if (allowed) {
 577     allowed = gst_caps_truncate (allowed);
 578     s = gst_caps_get_structure (allowed, 0);
 579     if (gst_structure_has_field (s, "profile")) {
 580       const GValue *v = gst_structure_get_value (s, "profile");
 581       const gchar *profile_str = NULL;
 582
 583       if (GST_VALUE_HOLDS_LIST (v) && gst_value_list_get_size (v) > 0) {
 584         profile_str = g_value_get_string (gst_value_list_get_value (v, 0));
 585       } else if (G_VALUE_HOLDS_STRING (v)) {
 586         profile_str = g_value_get_string (v);
 587       }
 588
 589       if (profile_str) {
 590         gchar *endptr = NULL;
 591
 592         if (g_strcmp0 (profile_str, "main") == 0) {
 593           GST_DEBUG_OBJECT (av1enc, "Downstream profile is \"main\"");
 594           profile = 0;
 595         } else if (g_strcmp0 (profile_str, "high") == 0) {
 596           profile = 1;
 597           GST_DEBUG_OBJECT (av1enc, "Downstream profile is \"high\"");
 598         } else if (g_strcmp0 (profile_str, "professional") == 0) {
 599           profile = 2;
 600           GST_DEBUG_OBJECT (av1enc, "Downstream profile is \"professional\"");
 601         } else {
 602           profile = g_ascii_strtoull (profile_str, &endptr, 10);
 603           if (*endptr != '\0' || profile < 0 || profile > 3) {
 604             GST_ERROR_OBJECT (av1enc, "Invalid profile '%s'", profile_str);
 605             profile = DEFAULT_PROFILE;
 606           } else {
 607             GST_DEBUG_OBJECT (av1enc,
 608                 "Downstream profile is \"%s\"", profile_str);
 609           }
 610         }
 611       }
 612     }
 613     gst_caps_unref (allowed);
 614   }
 615
 616   GST_DEBUG_OBJECT (av1enc, "Using profile %d", profile);
 617
 618   return profile;
 619 }
 620
 621 static void
 622 gst_av1_enc_adjust_profile (GstAV1Enc * av1enc, GstVideoFormat format)
 623 {
 624   guint depth = av1enc->aom_cfg.g_bit_depth;
 625   guint profile = av1enc->aom_cfg.g_profile;
 626   gboolean update = FALSE;
 627
 628   switch (profile) {
 629     case 0:
 630       if (depth < 12 && format == GST_VIDEO_FORMAT_Y444) {
 631         profile = 1;
 632         update = TRUE;
 633       } else if (depth == 12 || format == GST_VIDEO_FORMAT_Y42B) {
 634         profile = 2;
 635         update = TRUE;
 636       }
 637       break;
 638     case 1:
 639       if (depth == 12 || format == GST_VIDEO_FORMAT_Y42B) {
 640         profile = 2;
 641         update = TRUE;
 642       } else if (depth < 12 && format == GST_VIDEO_FORMAT_I420) {
 643         profile = 0;
 644         update = TRUE;
 645       }
 646       break;
 647     case 2:
 648       if (depth < 12) {
 649         if (format == GST_VIDEO_FORMAT_Y444) {
 650           profile = 1;
 651           update = TRUE;
 652         } else if (format == GST_VIDEO_FORMAT_I420) {
 653           profile = 0;
 654           update = TRUE;
 655         }
 656       }
 657       break;
 658     default:
 659       break;
 660   }
 661
 662   if (update) {
 663     GST_INFO_OBJECT (av1enc, "profile updated to %d from %d",
 664         profile, av1enc->aom_cfg.g_profile);
 665     av1enc->aom_cfg.g_profile = profile;
 666   }
 667 }
 668
 669 static gboolean
 670 gst_av1_enc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state)
 671 {
 672   GstVideoCodecState *output_state;
 673   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 674   GstAV1EncClass *av1enc_class = GST_AV1_ENC_GET_CLASS (av1enc);
 675   GstVideoInfo *info = &state->info;
 676
 677   output_state =
 678       gst_video_encoder_set_output_state (encoder,
 679       gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder)),
 680       state);
 681   gst_video_codec_state_unref (output_state);
 682
 683   if (av1enc->input_state) {
 684     gst_video_codec_state_unref (av1enc->input_state);
 685   }
 686   av1enc->input_state = gst_video_codec_state_ref (state);
 687
 688   g_mutex_lock (&av1enc->encoder_lock);
 689   gst_av1_enc_set_latency (av1enc);
 690
 691   av1enc->aom_cfg.g_profile = gst_av1_enc_get_downstream_profile (av1enc);
 692
 693   /* Scale default bitrate to our size */
 694   if (!av1enc->target_bitrate_set)
 695     av1enc->aom_cfg.rc_target_bitrate =
 696         gst_util_uint64_scale (DEFAULT_TARGET_BITRATE,
 697         GST_VIDEO_INFO_WIDTH (info) * GST_VIDEO_INFO_HEIGHT (info), 320 * 240);
 698
 699   av1enc->aom_cfg.g_w = GST_VIDEO_INFO_WIDTH (info);
 700   av1enc->aom_cfg.g_h = GST_VIDEO_INFO_HEIGHT (info);
 701   /* Recommended method is to set the timebase to that of the parent
 702    * container or multimedia framework (ex: 1/1000 for ms, as in FLV) */
 703   if (GST_VIDEO_INFO_FPS_D (info) != 0 && GST_VIDEO_INFO_FPS_N (info) != 0) {
 704     av1enc->aom_cfg.g_timebase.num = GST_VIDEO_INFO_FPS_D (info);
 705     av1enc->aom_cfg.g_timebase.den = GST_VIDEO_INFO_FPS_N (info);
 706   } else {
 707     av1enc->aom_cfg.g_timebase.num = DEFAULT_TIMEBASE_N;
 708     av1enc->aom_cfg.g_timebase.den = DEFAULT_TIMEBASE_D;
 709   }
 710   av1enc->aom_cfg.g_error_resilient = AOM_ERROR_RESILIENT_DEFAULT;
 711
 712   if (av1enc->threads == DEFAULT_THREADS)
 713     av1enc->aom_cfg.g_threads = g_get_num_processors ();
 714   else
 715     av1enc->aom_cfg.g_threads = av1enc->threads;
 716   /* TODO: do more configuration including bit_depth config */
 717
 718   av1enc->format =
 719       gst_video_format_to_av1_img_format (GST_VIDEO_INFO_FORMAT (info));
 720
 721   if (av1enc->aom_cfg.g_bit_depth != DEFAULT_BIT_DEPTH) {
 722     av1enc->aom_cfg.g_input_bit_depth = av1enc->aom_cfg.g_bit_depth;
 723     if (av1enc->aom_cfg.g_bit_depth > 8)
 724       av1enc->format |= AOM_IMG_FMT_HIGHBITDEPTH;
 725   }
 726
 727   /* Adjust profile according to format and bit-depth */
 728   gst_av1_enc_adjust_profile (av1enc, GST_VIDEO_INFO_FORMAT (info));
 729
 730   GST_DEBUG_OBJECT (av1enc, "Calling encoder init with config:");
 731   gst_av1_enc_debug_encoder_cfg (&av1enc->aom_cfg);
 732
 733   if (aom_codec_enc_init (&av1enc->encoder, av1enc_class->codec_algo,
 734           &av1enc->aom_cfg, 0)) {
 735     gst_av1_codec_error (&av1enc->encoder, "Failed to initialize encoder");
 736     g_mutex_unlock (&av1enc->encoder_lock);
 737     return FALSE;
 738   }
 739   av1enc->encoder_inited = TRUE;
 740
 741   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AOME_SET_CPUUSED, av1enc->cpu_used);
 742 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
 743   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_ROW_MT,
 744       (av1enc->row_mt ? 1 : 0));
 745 #endif
 746   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_COLUMNS,
 747       av1enc->tile_columns);
 748   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_ROWS,
 749       av1enc->tile_rows);
 750   g_mutex_unlock (&av1enc->encoder_lock);
 751
 752   return TRUE;
 753 }
 754
 755 static GstFlowReturn
 756 gst_av1_enc_process (GstAV1Enc * encoder)
 757 {
 758   aom_codec_iter_t iter = NULL;
 759   const aom_codec_cx_pkt_t *pkt;
 760   GstVideoCodecFrame *frame;
 761   GstVideoEncoder *video_encoder;
 762   GstFlowReturn ret = GST_FLOW_CUSTOM_SUCCESS;
 763
 764   video_encoder = GST_VIDEO_ENCODER (encoder);
 765
 766   while ((pkt = aom_codec_get_cx_data (&encoder->encoder, &iter)) != NULL) {
 767     if (pkt->kind == AOM_CODEC_STATS_PKT) {
 768       GST_WARNING_OBJECT (encoder, "Unhandled stats packet");
 769     } else if (pkt->kind == AOM_CODEC_FPMB_STATS_PKT) {
 770       GST_WARNING_OBJECT (encoder, "Unhandled FPMB pkt");
 771     } else if (pkt->kind == AOM_CODEC_PSNR_PKT) {
 772       GST_WARNING_OBJECT (encoder, "Unhandled PSNR packet");
 773     } else if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
 774       frame = gst_video_encoder_get_oldest_frame (video_encoder);
 775       g_assert (frame != NULL);
 776       if ((pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0) {
 777         GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
 778       } else {
 779         GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
 780       }
 781
 782       frame->output_buffer =
 783           gst_buffer_new_memdup (pkt->data.frame.buf, pkt->data.frame.sz);
 784
 785       if ((pkt->data.frame.flags & AOM_FRAME_IS_DROPPABLE) != 0)
 786         GST_BUFFER_FLAG_SET (frame->output_buffer, GST_BUFFER_FLAG_DROPPABLE);
 787
 788       ret = gst_video_encoder_finish_frame (video_encoder, frame);
 789       if (ret != GST_FLOW_OK)
 790         break;
 791     }
 792   }
 793
 794   return ret;
 795 }
 796
 797 static void
 798 gst_av1_enc_fill_image (GstAV1Enc * enc, GstVideoFrame * frame,
 799     aom_image_t * image)
 800 {
 801   image->planes[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
 802   image->planes[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
 803   image->planes[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_DATA (frame, 2);
 804
 805   image->stride[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
 806   image->stride[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1);
 807   image->stride[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 2);
 808 }
 809
 810 static GstFlowReturn
 811 gst_av1_enc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame)
 812 {
 813   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 814   aom_image_t raw;
 815   int flags = 0;
 816   GstFlowReturn ret = GST_FLOW_OK;
 817   GstVideoFrame vframe;
 818   aom_codec_pts_t scaled_pts;
 819
 820   if (!aom_img_alloc (&raw, av1enc->format, av1enc->aom_cfg.g_w,
 821           av1enc->aom_cfg.g_h, 1)) {
 822     GST_ERROR_OBJECT (encoder, "Failed to initialize encoder");
 823     return FALSE;
 824   }
 825
 826   gst_video_frame_map (&vframe, &av1enc->input_state->info,
 827       frame->input_buffer, GST_MAP_READ);
 828   gst_av1_enc_fill_image (av1enc, &vframe, &raw);
 829   gst_video_frame_unmap (&vframe);
 830
 831   if (av1enc->keyframe_dist >= 30) {
 832     av1enc->keyframe_dist = 0;
 833     flags |= AOM_EFLAG_FORCE_KF;
 834   }
 835   av1enc->keyframe_dist++;
 836
 837   // Convert the pts from nanoseconds to timebase units
 838   scaled_pts =
 839       gst_util_uint64_scale_int (frame->pts,
 840       av1enc->aom_cfg.g_timebase.den,
 841       av1enc->aom_cfg.g_timebase.num * (GstClockTime) GST_SECOND);
 842
 843   g_mutex_lock (&av1enc->encoder_lock);
 844   if (aom_codec_encode (&av1enc->encoder, &raw, scaled_pts, 1, flags)
 845       != AOM_CODEC_OK) {
 846     gst_av1_codec_error (&av1enc->encoder, "Failed to encode frame");
 847     ret = GST_FLOW_ERROR;
 848   }
 849   g_mutex_unlock (&av1enc->encoder_lock);
 850
 851   aom_img_free (&raw);
 852   gst_video_codec_frame_unref (frame);
 853
 854   if (ret == GST_FLOW_ERROR)
 855     return ret;
 856
 857   ret = gst_av1_enc_process (av1enc);
 858
 859   if (ret == GST_FLOW_CUSTOM_SUCCESS)
 860     ret = GST_FLOW_OK;
 861
 862   return ret;
 863 }
 864
 865 static GstFlowReturn
 866 gst_av1_enc_finish (GstVideoEncoder * encoder)
 867 {
 868   GstFlowReturn ret = GST_FLOW_OK;
 869   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 870
 871   while (ret == GST_FLOW_OK) {
 872     GST_DEBUG_OBJECT (encoder, "Calling finish");
 873     g_mutex_lock (&av1enc->encoder_lock);
 874     if (aom_codec_encode (&av1enc->encoder, NULL, 0, 1, 0)
 875         != AOM_CODEC_OK) {
 876       gst_av1_codec_error (&av1enc->encoder, "Failed to encode frame");
 877       ret = GST_FLOW_ERROR;
 878     }
 879     g_mutex_unlock (&av1enc->encoder_lock);
 880
 881     ret = gst_av1_enc_process (av1enc);
 882   }
 883
 884
 885   if (ret == GST_FLOW_CUSTOM_SUCCESS)
 886     ret = GST_FLOW_OK;
 887
 888   return ret;
 889 }
 890
 891 static void
 892 gst_av1_enc_destroy_encoder (GstAV1Enc * av1enc)
 893 {
 894   g_mutex_lock (&av1enc->encoder_lock);
 895   if (av1enc->encoder_inited) {
 896     aom_codec_destroy (&av1enc->encoder);
 897     av1enc->encoder_inited = FALSE;
 898   }
 899   g_mutex_unlock (&av1enc->encoder_lock);
 900 }
 901
 902 static gboolean
 903 gst_av1_enc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query)
 904 {
 905   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
 906
 907   return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder,
 908       query);
 909 }
 910
 911 static void
 912 gst_av1_enc_set_property (GObject * object, guint prop_id,
 913     const GValue * value, GParamSpec * pspec)
 914 {
 915   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (object);
 916   gboolean global = FALSE;
 917   aom_codec_err_t status;
 918
 919   GST_OBJECT_LOCK (av1enc);
 920
 921   g_mutex_lock (&av1enc->encoder_lock);
 922   switch (prop_id) {
 923     case PROP_CPU_USED:
 924       av1enc->cpu_used = g_value_get_int (value);
 925       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AOME_SET_CPUUSED,
 926           av1enc->cpu_used);
 927       break;
 928     case PROP_DROP_FRAME:
 929       av1enc->aom_cfg.rc_dropframe_thresh = g_value_get_uint (value);
 930       global = TRUE;
 931       break;
 932     case PROP_RESIZE_MODE:
 933       av1enc->aom_cfg.rc_resize_mode = g_value_get_enum (value);
 934       global = TRUE;
 935       break;
 936     case PROP_RESIZE_DENOMINATOR:
 937       av1enc->aom_cfg.rc_resize_denominator = g_value_get_uint (value);
 938       global = TRUE;
 939       break;
 940     case PROP_RESIZE_KF_DENOMINATOR:
 941       av1enc->aom_cfg.rc_resize_kf_denominator = g_value_get_uint (value);
 942       global = TRUE;
 943       break;
 944     case PROP_SUPERRES_MODE:
 945       av1enc->aom_cfg.rc_superres_mode = g_value_get_enum (value);
 946       global = TRUE;
 947       break;
 948     case PROP_SUPERRES_DENOMINATOR:
 949       av1enc->aom_cfg.rc_superres_denominator = g_value_get_uint (value);
 950       global = TRUE;
 951       break;
 952     case PROP_SUPERRES_KF_DENOMINATOR:
 953       av1enc->aom_cfg.rc_superres_kf_denominator = g_value_get_uint (value);
 954       global = TRUE;
 955       break;
 956     case PROP_SUPERRES_QTHRESH:
 957       av1enc->aom_cfg.rc_superres_qthresh = g_value_get_uint (value);
 958       global = TRUE;
 959       break;
 960     case PROP_SUPERRES_KF_QTHRESH:
 961       av1enc->aom_cfg.rc_superres_kf_qthresh = g_value_get_uint (value);
 962       global = TRUE;
 963       break;
 964     case PROP_END_USAGE:
 965       av1enc->aom_cfg.rc_end_usage = g_value_get_enum (value);
 966       global = TRUE;
 967       break;
 968     case PROP_TARGET_BITRATE:
 969       av1enc->aom_cfg.rc_target_bitrate = g_value_get_uint (value);
 970       av1enc->target_bitrate_set = TRUE;
 971       global = TRUE;
 972       break;
 973     case PROP_MIN_QUANTIZER:
 974       av1enc->aom_cfg.rc_min_quantizer = g_value_get_uint (value);
 975       global = TRUE;
 976       break;
 977     case PROP_MAX_QUANTIZER:
 978       av1enc->aom_cfg.rc_max_quantizer = g_value_get_uint (value);
 979       global = TRUE;
 980       break;
 981     case PROP_UNDERSHOOT_PCT:
 982       av1enc->aom_cfg.rc_undershoot_pct = g_value_get_uint (value);
 983       global = TRUE;
 984       break;
 985     case PROP_OVERSHOOT_PCT:
 986       av1enc->aom_cfg.rc_overshoot_pct = g_value_get_uint (value);
 987       global = TRUE;
 988       break;
 989     case PROP_BUF_SZ:
 990       av1enc->aom_cfg.rc_buf_sz = g_value_get_uint (value);
 991       global = TRUE;
 992       break;
 993     case PROP_BUF_INITIAL_SZ:
 994       av1enc->aom_cfg.rc_buf_initial_sz = g_value_get_uint (value);
 995       global = TRUE;
 996       break;
 997     case PROP_BUF_OPTIMAL_SZ:
 998       av1enc->aom_cfg.rc_buf_optimal_sz = g_value_get_uint (value);
 999       global = TRUE;
1000       break;
1001     case PROP_THREADS:
1002       av1enc->threads = g_value_get_uint (value);
1003       global = TRUE;
1004       break;
1005 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
1006     case PROP_ROW_MT:
1007       av1enc->row_mt = g_value_get_boolean (value);
1008       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_ROW_MT,
1009           (av1enc->row_mt ? 1 : 0));
1010       break;
1011 #endif
1012     case PROP_TILE_COLUMNS:
1013       av1enc->tile_columns = g_value_get_uint (value);
1014       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_COLUMNS,
1015           av1enc->tile_columns);
1016       break;
1017     case PROP_TILE_ROWS:
1018       av1enc->tile_rows = g_value_get_uint (value);
1019       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_ROWS,
1020           av1enc->tile_rows);
1021       break;
1022     default:
1023       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1024       break;
1025   }
1026
1027   if (global &&av1enc->encoder_inited) {
1028     status = aom_codec_enc_config_set (&av1enc->encoder, &av1enc->aom_cfg);
1029     GST_DEBUG_OBJECT (av1enc, "Set %s encoder configuration, ret = %s",
1030         pspec->name, gst_av1_get_error_name (status));
1031   }
1032
1033   g_mutex_unlock (&av1enc->encoder_lock);
1034   GST_OBJECT_UNLOCK (av1enc);
1035 }
1036
1037 static void
1038 gst_av1_enc_get_property (GObject * object, guint prop_id, GValue * value,
1039     GParamSpec * pspec)
1040 {
1041   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (object);
1042
1043   GST_OBJECT_LOCK (av1enc);
1044
1045   switch (prop_id) {
1046     case PROP_CPU_USED:
1047       g_value_set_int (value, av1enc->cpu_used);
1048       break;
1049     case PROP_DROP_FRAME:
1050       g_value_set_uint (value, av1enc->aom_cfg.rc_dropframe_thresh);
1051       break;
1052     case PROP_RESIZE_MODE:
1053       g_value_set_enum (value, av1enc->aom_cfg.rc_resize_mode);
1054       break;
1055     case PROP_RESIZE_DENOMINATOR:
1056       g_value_set_uint (value, av1enc->aom_cfg.rc_resize_denominator);
1057       break;
1058     case PROP_RESIZE_KF_DENOMINATOR:
1059       g_value_set_uint (value, av1enc->aom_cfg.rc_resize_kf_denominator);
1060       break;
1061     case PROP_SUPERRES_MODE:
1062       g_value_set_enum (value, av1enc->aom_cfg.rc_superres_mode);
1063       break;
1064     case PROP_SUPERRES_DENOMINATOR:
1065       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_denominator);
1066       break;
1067     case PROP_SUPERRES_KF_DENOMINATOR:
1068       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_kf_denominator);
1069       break;
1070     case PROP_SUPERRES_QTHRESH:
1071       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_qthresh);
1072       break;
1073     case PROP_SUPERRES_KF_QTHRESH:
1074       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_kf_qthresh);
1075       break;
1076     case PROP_END_USAGE:
1077       g_value_set_enum (value, av1enc->aom_cfg.rc_end_usage);
1078       break;
1079     case PROP_TARGET_BITRATE:
1080       g_value_set_uint (value, av1enc->aom_cfg.rc_target_bitrate);
1081       break;
1082     case PROP_MIN_QUANTIZER:
1083       g_value_set_uint (value, av1enc->aom_cfg.rc_min_quantizer);
1084       break;
1085     case PROP_MAX_QUANTIZER:
1086       g_value_set_uint (value, av1enc->aom_cfg.rc_max_quantizer);
1087       break;
1088     case PROP_UNDERSHOOT_PCT:
1089       g_value_set_uint (value, av1enc->aom_cfg.rc_undershoot_pct);
1090       break;
1091     case PROP_OVERSHOOT_PCT:
1092       g_value_set_uint (value, av1enc->aom_cfg.rc_overshoot_pct);
1093       break;
1094     case PROP_BUF_SZ:
1095       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_sz);
1096       break;
1097     case PROP_BUF_INITIAL_SZ:
1098       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_initial_sz);
1099       break;
1100     case PROP_BUF_OPTIMAL_SZ:
1101       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_optimal_sz);
1102       break;
1103     case PROP_THREADS:
1104       g_value_set_uint (value, av1enc->threads);
1105       break;
1106 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
1107     case PROP_ROW_MT:
1108       g_value_set_boolean (value, av1enc->row_mt);
1109       break;
1110 #endif
1111     case PROP_TILE_COLUMNS:
1112       g_value_set_uint (value, av1enc->tile_columns);
1113       break;
1114     case PROP_TILE_ROWS:
1115       g_value_set_uint (value, av1enc->tile_rows);
1116       break;
1117     default:
1118       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1119       break;
1120   }
1121
1122   GST_OBJECT_UNLOCK (av1enc);
1123 }
1124
1125 static gboolean
1126 gst_av1_enc_start (GstVideoEncoder * encoder)
1127 {
1128   return TRUE;
1129 }
1130
1131 static gboolean
1132 gst_av1_enc_stop (GstVideoEncoder * encoder)
1133 {
1134   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
1135
1136   if (av1enc->input_state) {
1137     gst_video_codec_state_unref (av1enc->input_state);
1138   }
1139   av1enc->input_state = NULL;
1140
1141   gst_av1_enc_destroy_encoder (av1enc);
1142
1143   return TRUE;
1144 }