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