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 #define GST_TYPE_KF_MODE (gst_kf_mode_get_type())
 120 static GType
 121 gst_kf_mode_get_type (void)
 122 {
 123   static GType kf_mode_type = 0;
 124   static const GEnumValue kf_mode[] = {
 125     {GST_AV1_ENC_KF_AUTO,
 126           "Encoder determines optimal keyframe placement automatically",
 127         "auto"},
 128     {GST_AV1_ENC_KF_DISABLED, "Encoder does not place keyframes", "disabled"},
 129     {0, NULL, NULL},
 130   };
 131
 132   if (!kf_mode_type) {
 133     kf_mode_type = g_enum_register_static ("GstAV1EncKFMode", kf_mode);
 134   }
 135   return kf_mode_type;
 136 }
 137
 138 #define GST_TYPE_ENC_PASS (gst_enc_pass_get_type())
 139 static GType
 140 gst_enc_pass_get_type (void)
 141 {
 142   static GType enc_pass_type = 0;
 143   static const GEnumValue enc_pass[] = {
 144     {GST_AV1_ENC_ONE_PASS, "Single pass mode", "one-pass"},
 145     {GST_AV1_ENC_FIRST_PASS, "First pass of multi-pass mode", "first-pass"},
 146     {GST_AV1_ENC_SECOND_PASS, "Second pass of multi-pass mode", "second-pass"},
 147     {GST_AV1_ENC_THIRD_PASS, "Third pass of multi-pass mode", "third-pass"},
 148     {0, NULL, NULL},
 149   };
 150
 151   if (!enc_pass_type) {
 152     enc_pass_type = g_enum_register_static ("GstAV1EncEncPass", enc_pass);
 153   }
 154   return enc_pass_type;
 155 }
 156
 157 #define GST_TYPE_USAGE_PROFILE (gst_usage_profile_get_type())
 158 static GType
 159 gst_usage_profile_get_type (void)
 160 {
 161   static GType usage_profile_type = 0;
 162   static const GEnumValue usage_profile[] = {
 163     {GST_AV1_ENC_USAGE_GOOD_QUALITY, "Good Quality profile", "good-quality"},
 164     {GST_AV1_ENC_USAGE_REALTIME, "Realtime profile", "realtime"},
 165     {GST_AV1_ENC_USAGE_ALL_INTRA, "All Intra profile", "all-intra"},
 166     {0, NULL, NULL},
 167   };
 168
 169   if (!usage_profile_type) {
 170     usage_profile_type =
 171         g_enum_register_static ("GstAV1EncUsageProfile", usage_profile);
 172   }
 173   return usage_profile_type;
 174 }
 175
 176 enum
 177 {
 178   LAST_SIGNAL
 179 };
 180
 181 enum
 182 {
 183   PROP_0,
 184   PROP_CPU_USED,
 185   PROP_DROP_FRAME,
 186   PROP_RESIZE_MODE,
 187   PROP_RESIZE_DENOMINATOR,
 188   PROP_RESIZE_KF_DENOMINATOR,
 189   PROP_SUPERRES_MODE,
 190   PROP_SUPERRES_DENOMINATOR,
 191   PROP_SUPERRES_KF_DENOMINATOR,
 192   PROP_SUPERRES_QTHRESH,
 193   PROP_SUPERRES_KF_QTHRESH,
 194   PROP_END_USAGE,
 195   PROP_TARGET_BITRATE,
 196   PROP_MIN_QUANTIZER,
 197   PROP_MAX_QUANTIZER,
 198   PROP_UNDERSHOOT_PCT,
 199   PROP_OVERSHOOT_PCT,
 200   PROP_BUF_SZ,
 201   PROP_BUF_INITIAL_SZ,
 202   PROP_BUF_OPTIMAL_SZ,
 203   PROP_THREADS,
 204   PROP_ROW_MT,
 205   PROP_TILE_COLUMNS,
 206   PROP_TILE_ROWS,
 207   PROP_KF_MODE,
 208   PROP_ENC_PASS,
 209   PROP_USAGE_PROFILE,
 210   PROP_LAG_IN_FRAMES,
 211   PROP_KEYFRAME_MAX_DIST
 212 };
 213
 214 /* From av1/av1_cx_iface.c */
 215 #define DEFAULT_PROFILE                                         0
 216 #define DEFAULT_CPU_USED                                        0
 217 #define DEFAULT_DROP_FRAME                                      0
 218 #define DEFAULT_RESIZE_MODE               GST_AV1_ENC_RESIZE_NONE
 219 #define DEFAULT_RESIZE_DENOMINATOR                              8
 220 #define DEFAULT_RESIZE_KF_DENOMINATOR                           8
 221 #define DEFAULT_SUPERRES_MODE           GST_AV1_ENC_SUPERRES_NONE
 222 #define DEFAULT_SUPERRES_DENOMINATOR                            8
 223 #define DEFAULT_SUPERRES_KF_DENOMINATOR                         8
 224 #define DEFAULT_SUPERRES_QTHRESH                               63
 225 #define DEFAULT_SUPERRES_KF_QTHRESH                            63
 226 #define DEFAULT_END_USAGE               GST_AV1_ENC_END_USAGE_VBR
 227 #define DEFAULT_TARGET_BITRATE                                256
 228 #define DEFAULT_MIN_QUANTIZER                                   0
 229 #define DEFAULT_MAX_QUANTIZER                                   0
 230 #define DEFAULT_UNDERSHOOT_PCT                                 25
 231 #define DEFAULT_OVERSHOOT_PCT                                  25
 232 #define DEFAULT_BUF_SZ                                       6000
 233 #define DEFAULT_BUF_INITIAL_SZ                               4000
 234 #define DEFAULT_BUF_OPTIMAL_SZ                               5000
 235 #define DEFAULT_TIMEBASE_N                                      1
 236 #define DEFAULT_TIMEBASE_D                                  90000
 237 #define DEFAULT_BIT_DEPTH                              AOM_BITS_8
 238 #define DEFAULT_THREADS                                         0
 239 #define DEFAULT_ROW_MT                                       TRUE
 240 #define DEFAULT_TILE_COLUMNS                                    0
 241 #define DEFAULT_TILE_ROWS                                       0
 242 #define DEFAULT_KF_MODE                       GST_AV1_ENC_KF_AUTO
 243 #define DEFAULT_ENC_PASS                     GST_AV1_ENC_ONE_PASS
 244 #define DEFAULT_USAGE_PROFILE      GST_AV1_ENC_USAGE_GOOD_QUALITY
 245 #define DEFAULT_LAG_IN_FRAMES                                   0
 246 #define DEFAULT_KEYFRAME_MAX_DIST                              30
 247
 248 static void gst_av1_enc_finalize (GObject * object);
 249 static void gst_av1_enc_set_property (GObject * object, guint prop_id,
 250     const GValue * value, GParamSpec * pspec);
 251 static void gst_av1_enc_get_property (GObject * object, guint prop_id,
 252     GValue * value, GParamSpec * pspec);
 253
 254 static gboolean gst_av1_enc_start (GstVideoEncoder * encoder);
 255 static gboolean gst_av1_enc_stop (GstVideoEncoder * encoder);
 256 static gboolean gst_av1_enc_set_format (GstVideoEncoder * encoder,
 257     GstVideoCodecState * state);
 258 static GstFlowReturn gst_av1_enc_handle_frame (GstVideoEncoder * encoder,
 259     GstVideoCodecFrame * frame);
 260 static GstFlowReturn gst_av1_enc_finish (GstVideoEncoder * encoder);
 261 static gboolean gst_av1_enc_propose_allocation (GstVideoEncoder * encoder,
 262     GstQuery * query);
 263
 264 static void gst_av1_enc_destroy_encoder (GstAV1Enc * av1enc);
 265
 266 #define gst_av1_enc_parent_class parent_class
 267 G_DEFINE_TYPE (GstAV1Enc, gst_av1_enc, GST_TYPE_VIDEO_ENCODER);
 268 GST_ELEMENT_REGISTER_DEFINE (av1enc, "av1enc", GST_RANK_PRIMARY,
 269     GST_TYPE_AV1_ENC);
 270
 271 /* *INDENT-OFF* */
 272 static GstStaticPadTemplate gst_av1_enc_sink_pad_template =
 273 GST_STATIC_PAD_TEMPLATE ("sink",
 274     GST_PAD_SINK,
 275     GST_PAD_ALWAYS,
 276         GST_STATIC_CAPS ("video/x-raw, "
 277         "format = (string) { I420, Y42B, Y444, YV12 }, "
 278         "framerate = (fraction) [0, MAX], "
 279         "width = (int) [ 4, MAX ], "
 280         "height = (int) [ 4, MAX ]")
 281     );
 282 /* *INDENT-ON* */
 283
 284 static GstStaticPadTemplate gst_av1_enc_src_pad_template =
 285 GST_STATIC_PAD_TEMPLATE ("src",
 286     GST_PAD_SRC,
 287     GST_PAD_ALWAYS,
 288     GST_STATIC_CAPS ("video/x-av1, "
 289         "stream-format = (string) obu-stream, " "alignment = (string) tu")
 290     );
 291
 292 static void
 293 gst_av1_enc_class_init (GstAV1EncClass * klass)
 294 {
 295   GObjectClass *gobject_class;
 296   GstElementClass *element_class;
 297   GstVideoEncoderClass *venc_class;
 298
 299   gobject_class = (GObjectClass *) klass;
 300   element_class = (GstElementClass *) klass;
 301   venc_class = (GstVideoEncoderClass *) klass;
 302
 303   parent_class = g_type_class_peek_parent (klass);
 304
 305   gobject_class->finalize = gst_av1_enc_finalize;
 306   gobject_class->set_property = gst_av1_enc_set_property;
 307   gobject_class->get_property = gst_av1_enc_get_property;
 308
 309   gst_element_class_add_static_pad_template (element_class,
 310       &gst_av1_enc_sink_pad_template);
 311   gst_element_class_add_static_pad_template (element_class,
 312       &gst_av1_enc_src_pad_template);
 313   gst_element_class_set_static_metadata (element_class, "AV1 Encoder",
 314       "Codec/Encoder/Video", "Encode AV1 video streams",
 315       "Sean DuBois <sean@siobud.com>");
 316
 317   venc_class->start = gst_av1_enc_start;
 318   venc_class->stop = gst_av1_enc_stop;
 319   venc_class->set_format = gst_av1_enc_set_format;
 320   venc_class->handle_frame = gst_av1_enc_handle_frame;
 321   venc_class->finish = gst_av1_enc_finish;
 322   venc_class->propose_allocation = gst_av1_enc_propose_allocation;
 323
 324   klass->codec_algo = &aom_codec_av1_cx_algo;
 325   GST_DEBUG_CATEGORY_INIT (av1_enc_debug, "av1enc", 0, "AV1 encoding element");
 326
 327   g_object_class_install_property (gobject_class, PROP_CPU_USED,
 328       g_param_spec_int ("cpu-used", "CPU Used",
 329           "CPU Used. A Value greater than 0 will increase encoder speed at the expense of quality.",
 330           0, 10, DEFAULT_CPU_USED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 331
 332   /* Rate control configurations */
 333   g_object_class_install_property (gobject_class, PROP_DROP_FRAME,
 334       g_param_spec_uint ("drop-frame", "Drop frame",
 335           "Temporal resampling configuration, drop frames as a strategy to meet "
 336           "its target data rate Set to zero (0) to disable this feature.",
 337           0, G_MAXUINT, DEFAULT_DROP_FRAME,
 338           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 339
 340   g_object_class_install_property (gobject_class, PROP_RESIZE_MODE,
 341       g_param_spec_enum ("resize-mode", "Resize mode",
 342           "Frame resize mode", GST_TYPE_RESIZE_MODE,
 343           DEFAULT_RESIZE_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 344
 345   g_object_class_install_property (gobject_class, PROP_RESIZE_DENOMINATOR,
 346       g_param_spec_uint ("resize-denominator", "Resize denominator",
 347           "Frame resize denominator, assuming 8 as the numerator",
 348           8, 16, DEFAULT_RESIZE_DENOMINATOR,
 349           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 350
 351   g_object_class_install_property (gobject_class, PROP_RESIZE_KF_DENOMINATOR,
 352       g_param_spec_uint ("resize-kf-denominator", "Resize keyframe denominator",
 353           "Frame resize keyframe denominator, assuming 8 as the numerator",
 354           8, 16, DEFAULT_RESIZE_KF_DENOMINATOR,
 355           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 356
 357   g_object_class_install_property (gobject_class, PROP_SUPERRES_MODE,
 358       g_param_spec_enum ("superres-mode", "Super-resolution scaling mode",
 359           "It integrates upscaling after the encode/decode process",
 360           GST_TYPE_SUPERRES_MODE,
 361           DEFAULT_SUPERRES_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 362
 363   g_object_class_install_property (gobject_class, PROP_SUPERRES_DENOMINATOR,
 364       g_param_spec_uint ("superres-denominator", "Super-resolution denominator",
 365           "Frame super-resolution denominator, used only by SUPERRES_FIXED mode",
 366           8, 16, DEFAULT_SUPERRES_DENOMINATOR,
 367           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 368
 369   g_object_class_install_property (gobject_class, PROP_SUPERRES_KF_DENOMINATOR,
 370       g_param_spec_uint ("superres-kf-denominator",
 371           "Keyframe super-resolution denominator",
 372           "Keyframe super-resolution denominator",
 373           8, 16, DEFAULT_SUPERRES_KF_DENOMINATOR,
 374           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 375
 376   g_object_class_install_property (gobject_class, PROP_SUPERRES_QTHRESH,
 377       g_param_spec_uint ("superres-qthresh",
 378           "Frame super-resolution qindex threshold",
 379           "Frame super-resolution qindex threshold, used only by SUPERRES_QTHRESH mode",
 380           1, 63, DEFAULT_SUPERRES_QTHRESH,
 381           (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 382
 383   g_object_class_install_property (gobject_class, PROP_SUPERRES_KF_QTHRESH,
 384       g_param_spec_uint ("superres-kf-qthresh",
 385           "Keyframe super-resolution qindex threshold",
 386           "Keyframe super-resolution qindex threshold, used only by SUPERRES_QTHRESH mode",
 387           1, 63, DEFAULT_SUPERRES_KF_QTHRESH,
 388           (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 389
 390   g_object_class_install_property (gobject_class, PROP_END_USAGE,
 391       g_param_spec_enum ("end-usage", "Rate control mode",
 392           "Rate control algorithm to use, indicates the end usage of this stream",
 393           GST_TYPE_END_USAGE_MODE, DEFAULT_END_USAGE,
 394           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 395
 396   g_object_class_install_property (gobject_class, PROP_TARGET_BITRATE,
 397       g_param_spec_uint ("target-bitrate", "Target bitrate",
 398           "Target bitrate, in kilobits per second",
 399           1, G_MAXUINT, DEFAULT_TARGET_BITRATE,
 400           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 401
 402   g_object_class_install_property (gobject_class, PROP_MIN_QUANTIZER,
 403       g_param_spec_uint ("min-quantizer", "Minimum (best quality) quantizer",
 404           "Minimum (best quality) quantizer",
 405           0, G_MAXUINT, DEFAULT_MIN_QUANTIZER,
 406           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 407
 408   g_object_class_install_property (gobject_class, PROP_MAX_QUANTIZER,
 409       g_param_spec_uint ("max-quantizer", "Maximum (worst quality) quantizer",
 410           "Maximum (worst quality) quantizer",
 411           0, G_MAXUINT, DEFAULT_MAX_QUANTIZER,
 412           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 413
 414   g_object_class_install_property (gobject_class, PROP_UNDERSHOOT_PCT,
 415       g_param_spec_uint ("undershoot-pct", "Datarate undershoot (min) target",
 416           "Rate control adaptation undershoot control",
 417           0, 1000, DEFAULT_UNDERSHOOT_PCT,
 418           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 419
 420   g_object_class_install_property (gobject_class, PROP_OVERSHOOT_PCT,
 421       g_param_spec_uint ("overshoot-pct", "Datarate overshoot (max) target",
 422           "Rate control adaptation overshoot control",
 423           0, 1000, DEFAULT_OVERSHOOT_PCT,
 424           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 425
 426   g_object_class_install_property (gobject_class, PROP_BUF_SZ,
 427       g_param_spec_uint ("buf-sz", "Decoder buffer size",
 428           "Decoder buffer size, expressed in units of time (milliseconds)",
 429           0, G_MAXUINT, DEFAULT_BUF_SZ,
 430           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 431
 432   g_object_class_install_property (gobject_class, PROP_BUF_INITIAL_SZ,
 433       g_param_spec_uint ("buf-initial-sz", "Decoder buffer initial size",
 434           "Decoder buffer initial size, expressed in units of time (milliseconds)",
 435           0, G_MAXUINT, DEFAULT_BUF_INITIAL_SZ,
 436           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 437
 438   g_object_class_install_property (gobject_class, PROP_BUF_OPTIMAL_SZ,
 439       g_param_spec_uint ("buf-optimal-sz", "Decoder buffer optimal size",
 440           "Decoder buffer optimal size, expressed in units of time (milliseconds)",
 441           0, G_MAXUINT, DEFAULT_BUF_OPTIMAL_SZ,
 442           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 443
 444   g_object_class_install_property (gobject_class, PROP_THREADS,
 445       g_param_spec_uint ("threads", "Max number of threads to use",
 446           "Max number of threads to use encoding, set to 0 determine the "
 447           "approximate number of threads that the system schedule",
 448           0, G_MAXUINT, DEFAULT_THREADS,
 449           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 450
 451 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
 452   g_object_class_install_property (gobject_class, PROP_ROW_MT,
 453       g_param_spec_boolean ("row-mt", "Row based multi-threading",
 454           "Enable row based multi-threading",
 455           DEFAULT_ROW_MT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 456 #endif
 457
 458   g_object_class_install_property (gobject_class, PROP_TILE_COLUMNS,
 459       g_param_spec_uint ("tile-columns", "Number of tile columns",
 460           "Partition into separate vertical tile columns from image frame which "
 461           "can enable parallel encoding",
 462           0, 6, DEFAULT_TILE_COLUMNS,
 463           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 464
 465   g_object_class_install_property (gobject_class, PROP_TILE_ROWS,
 466       g_param_spec_uint ("tile-rows", "Number of tile rows",
 467           "Partition into separate horizontal tile rows from image frame which "
 468           "can enable parallel encoding",
 469           0, 6, DEFAULT_TILE_ROWS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 470
 471   /**
 472    * av1enc:keyframe-mode:
 473    *
 474    * Since: 1.22
 475    */
 476   g_object_class_install_property (gobject_class, PROP_KF_MODE,
 477       g_param_spec_enum ("keyframe-mode", "Keyframe placement mode",
 478           "Determines whether keyframes are placed automatically by the encoder",
 479           GST_TYPE_KF_MODE, DEFAULT_KF_MODE,
 480           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 481
 482   /**
 483    * av1enc:enc-pass:
 484    *
 485    * Since: 1.22
 486    */
 487   g_object_class_install_property (gobject_class, PROP_ENC_PASS,
 488       g_param_spec_enum ("enc-pass", "Multi-pass Encoding Pass",
 489           "Current phase for multi-pass encoding or @GST_AV1_ENC_ONE_PASS for single pass",
 490           GST_TYPE_ENC_PASS, DEFAULT_ENC_PASS,
 491           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 492
 493   /**
 494    * av1enc:usage-profile:
 495    *
 496    * Since: 1.22
 497    */
 498   g_object_class_install_property (gobject_class, PROP_USAGE_PROFILE,
 499       g_param_spec_enum ("usage-profile", "Usage value",
 500           "Usage profile is used to guide the default config for the encoder",
 501           GST_TYPE_USAGE_PROFILE, DEFAULT_USAGE_PROFILE,
 502           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 503
 504   /**
 505    * av1enc:lag-in-frames:
 506    *
 507    * Since: 1.22
 508    */
 509   g_object_class_install_property (gobject_class, PROP_LAG_IN_FRAMES,
 510       g_param_spec_uint ("lag-in-frames", "Allow lagged encoding",
 511           "Maximum number of future frames the encoder is allowed to consume "
 512           "before producing the current output frame. "
 513           "Set value to 0 for disabling lagged encoding.",
 514           0, G_MAXUINT, DEFAULT_LAG_IN_FRAMES,
 515           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 516
 517   /**
 518    * av1enc:keyframe-max-dist:
 519    *
 520    * Since: 1.22
 521    */
 522   g_object_class_install_property (gobject_class, PROP_KEYFRAME_MAX_DIST,
 523       g_param_spec_int ("keyframe-max-dist", "Keyframe max distance",
 524           "Maximum distance between keyframes (number of frames)",
 525           0, G_MAXINT, DEFAULT_KEYFRAME_MAX_DIST,
 526           (GParamFlags) (G_PARAM_READWRITE |
 527               G_PARAM_STATIC_STRINGS | GST_PARAM_DOC_SHOW_DEFAULT)));
 528
 529   gst_type_mark_as_plugin_api (GST_TYPE_END_USAGE_MODE, 0);
 530   gst_type_mark_as_plugin_api (GST_TYPE_RESIZE_MODE, 0);
 531   gst_type_mark_as_plugin_api (GST_TYPE_SUPERRES_MODE, 0);
 532   gst_type_mark_as_plugin_api (GST_TYPE_KF_MODE, 0);
 533   gst_type_mark_as_plugin_api (GST_TYPE_ENC_PASS, 0);
 534   gst_type_mark_as_plugin_api (GST_TYPE_USAGE_PROFILE, 0);
 535 }
 536
 537 static void
 538 gst_av1_codec_error (aom_codec_ctx_t * ctx, const char *s)
 539 {
 540   const char *detail = aom_codec_error_detail (ctx);
 541
 542   GST_ERROR ("%s: %s %s", s, aom_codec_error (ctx), detail ? detail : "");
 543 }
 544
 545 static void
 546 gst_av1_enc_init (GstAV1Enc * av1enc)
 547 {
 548   GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_ENCODER_SINK_PAD (av1enc));
 549
 550   av1enc->encoder_inited = FALSE;
 551
 552   av1enc->cpu_used = DEFAULT_CPU_USED;
 553   av1enc->format = AOM_IMG_FMT_I420;
 554   av1enc->threads = DEFAULT_THREADS;
 555   av1enc->row_mt = DEFAULT_ROW_MT;
 556   av1enc->tile_columns = DEFAULT_TILE_COLUMNS;
 557   av1enc->tile_rows = DEFAULT_TILE_ROWS;
 558
 559 #ifdef FIXED_QP_OFFSET_COUNT
 560   av1enc->aom_cfg.fixed_qp_offsets[0] = -1;
 561   av1enc->aom_cfg.fixed_qp_offsets[1] = -1;
 562   av1enc->aom_cfg.fixed_qp_offsets[2] = -1;
 563   av1enc->aom_cfg.fixed_qp_offsets[3] = -1;
 564   av1enc->aom_cfg.fixed_qp_offsets[4] = -1;
 565 #endif
 566   av1enc->aom_cfg.kf_max_dist = DEFAULT_KEYFRAME_MAX_DIST;
 567   av1enc->aom_cfg.rc_dropframe_thresh = DEFAULT_DROP_FRAME;
 568   av1enc->aom_cfg.rc_resize_mode = DEFAULT_RESIZE_MODE;
 569   av1enc->aom_cfg.rc_resize_denominator = DEFAULT_RESIZE_DENOMINATOR;
 570   av1enc->aom_cfg.rc_resize_kf_denominator = DEFAULT_RESIZE_KF_DENOMINATOR;
 571   av1enc->aom_cfg.rc_superres_mode = DEFAULT_SUPERRES_MODE;
 572   av1enc->aom_cfg.rc_superres_denominator = DEFAULT_SUPERRES_DENOMINATOR;
 573   av1enc->aom_cfg.rc_superres_kf_denominator = DEFAULT_SUPERRES_KF_DENOMINATOR;
 574   av1enc->aom_cfg.rc_superres_qthresh = DEFAULT_SUPERRES_QTHRESH;
 575   av1enc->aom_cfg.rc_superres_kf_qthresh = DEFAULT_SUPERRES_KF_QTHRESH;
 576   av1enc->aom_cfg.rc_end_usage = (enum aom_rc_mode) DEFAULT_END_USAGE;
 577   av1enc->aom_cfg.rc_target_bitrate = DEFAULT_TARGET_BITRATE;
 578   av1enc->aom_cfg.rc_min_quantizer = DEFAULT_MIN_QUANTIZER;
 579   av1enc->aom_cfg.rc_max_quantizer = DEFAULT_MAX_QUANTIZER;
 580   av1enc->aom_cfg.rc_undershoot_pct = DEFAULT_UNDERSHOOT_PCT;
 581   av1enc->aom_cfg.rc_overshoot_pct = DEFAULT_OVERSHOOT_PCT;
 582   av1enc->aom_cfg.rc_buf_sz = DEFAULT_BUF_SZ;
 583   av1enc->aom_cfg.rc_buf_initial_sz = DEFAULT_BUF_INITIAL_SZ;
 584   av1enc->aom_cfg.rc_buf_optimal_sz = DEFAULT_BUF_OPTIMAL_SZ;
 585   av1enc->aom_cfg.g_timebase.num = DEFAULT_TIMEBASE_N;
 586   av1enc->aom_cfg.g_timebase.den = DEFAULT_TIMEBASE_D;
 587   av1enc->aom_cfg.g_bit_depth = DEFAULT_BIT_DEPTH;
 588   av1enc->aom_cfg.g_input_bit_depth = (unsigned int) DEFAULT_BIT_DEPTH;
 589   av1enc->aom_cfg.kf_mode = (enum aom_kf_mode) DEFAULT_KF_MODE;
 590   av1enc->aom_cfg.g_pass = (enum aom_enc_pass) DEFAULT_ENC_PASS;
 591   av1enc->aom_cfg.g_usage = (unsigned int) DEFAULT_USAGE_PROFILE;
 592   av1enc->aom_cfg.g_lag_in_frames = DEFAULT_LAG_IN_FRAMES;
 593
 594   g_mutex_init (&av1enc->encoder_lock);
 595 }
 596
 597 static void
 598 gst_av1_enc_finalize (GObject * object)
 599 {
 600   GstAV1Enc *av1enc = GST_AV1_ENC (object);
 601
 602   if (av1enc->input_state) {
 603     gst_video_codec_state_unref (av1enc->input_state);
 604   }
 605   av1enc->input_state = NULL;
 606
 607   gst_av1_enc_destroy_encoder (av1enc);
 608   g_mutex_clear (&av1enc->encoder_lock);
 609
 610   G_OBJECT_CLASS (parent_class)->finalize (object);
 611 }
 612
 613 static void
 614 gst_av1_enc_set_latency (GstAV1Enc * av1enc)
 615 {
 616   GstClockTime latency;
 617   gint fps_n, fps_d;
 618
 619   if (av1enc->input_state->info.fps_n && av1enc->input_state->info.fps_d) {
 620     fps_n = av1enc->input_state->info.fps_n;
 621     fps_d = av1enc->input_state->info.fps_d;
 622   } else {
 623     fps_n = 25;
 624     fps_d = 1;
 625   }
 626
 627   latency =
 628       gst_util_uint64_scale (av1enc->aom_cfg.g_lag_in_frames * GST_SECOND,
 629       fps_d, fps_n);
 630   gst_video_encoder_set_latency (GST_VIDEO_ENCODER (av1enc), latency, latency);
 631
 632   GST_DEBUG_OBJECT (av1enc, "Latency set to %" GST_TIME_FORMAT
 633       " = %d frames at %d/%d fps ", GST_TIME_ARGS (latency),
 634       av1enc->aom_cfg.g_lag_in_frames, fps_n, fps_d);
 635 }
 636
 637 static const gchar *
 638 gst_av1_enc_get_aom_rc_mode_name (enum aom_rc_mode rc_mode)
 639 {
 640   switch (rc_mode) {
 641     case AOM_VBR:
 642       return "VBR (Variable Bit Rate)";
 643     case AOM_CBR:
 644       return "CBR (Constant Bit Rate)";
 645     case AOM_CQ:
 646       return "CQ (Constrained Quality)";
 647     case AOM_Q:
 648       return "Q (Constant Quality)";
 649     default:
 650       return "<UNKNOWN>";
 651   }
 652 }
 653
 654 static void
 655 gst_av1_enc_debug_encoder_cfg (struct aom_codec_enc_cfg *cfg)
 656 {
 657   GST_DEBUG ("g_usage : %u", cfg->g_usage);
 658   GST_DEBUG ("g_threads : %u", cfg->g_threads);
 659   GST_DEBUG ("g_profile : %u", cfg->g_profile);
 660   GST_DEBUG ("g_w x g_h : %u x %u", cfg->g_w, cfg->g_h);
 661   GST_DEBUG ("g_bit_depth : %d", cfg->g_bit_depth);
 662   GST_DEBUG ("g_input_bit_depth : %u", cfg->g_input_bit_depth);
 663   GST_DEBUG ("g_timebase : %d / %d", cfg->g_timebase.num, cfg->g_timebase.den);
 664   GST_DEBUG ("g_error_resilient : 0x%x", cfg->g_error_resilient);
 665   GST_DEBUG ("g_pass : %d", cfg->g_pass);
 666   GST_DEBUG ("g_lag_in_frames : %u", cfg->g_lag_in_frames);
 667   GST_DEBUG ("rc_dropframe_thresh : %u", cfg->rc_dropframe_thresh);
 668   GST_DEBUG ("rc_resize_mode : %u", cfg->rc_resize_mode);
 669   GST_DEBUG ("rc_resize_denominator : %u", cfg->rc_resize_denominator);
 670   GST_DEBUG ("rc_resize_kf_denominator : %u", cfg->rc_resize_kf_denominator);
 671   GST_DEBUG ("rc_superres_mode : %u", cfg->rc_superres_mode);
 672   GST_DEBUG ("rc_superres_denominator : %u", cfg->rc_superres_denominator);
 673   GST_DEBUG ("rc_superres_kf_denominator : %u",
 674       cfg->rc_superres_kf_denominator);
 675   GST_DEBUG ("rc_superres_qthresh : %u", cfg->rc_superres_qthresh);
 676   GST_DEBUG ("rc_superres_kf_qthresh : %u", cfg->rc_superres_kf_qthresh);
 677   GST_DEBUG ("rc_end_usage : %s",
 678       gst_av1_enc_get_aom_rc_mode_name (cfg->rc_end_usage));
 679   /* rc_twopass_stats_in */
 680   /* rc_firstpass_mb_stats_in */
 681   GST_DEBUG ("rc_target_bitrate : %u (kbps)", cfg->rc_target_bitrate);
 682   GST_DEBUG ("rc_min_quantizer : %u", cfg->rc_min_quantizer);
 683   GST_DEBUG ("rc_max_quantizer : %u", cfg->rc_max_quantizer);
 684   GST_DEBUG ("rc_undershoot_pct : %u", cfg->rc_undershoot_pct);
 685   GST_DEBUG ("rc_overshoot_pct : %u", cfg->rc_overshoot_pct);
 686   GST_DEBUG ("rc_buf_sz : %u (ms)", cfg->rc_buf_sz);
 687   GST_DEBUG ("rc_buf_initial_sz : %u (ms)", cfg->rc_buf_initial_sz);
 688   GST_DEBUG ("rc_buf_optimal_sz : %u (ms)", cfg->rc_buf_optimal_sz);
 689   GST_DEBUG ("rc_2pass_vbr_bias_pct : %u (%%)", cfg->rc_2pass_vbr_bias_pct);
 690   GST_DEBUG ("rc_2pass_vbr_minsection_pct : %u (%%)",
 691       cfg->rc_2pass_vbr_minsection_pct);
 692   GST_DEBUG ("rc_2pass_vbr_maxsection_pct : %u (%%)",
 693       cfg->rc_2pass_vbr_maxsection_pct);
 694   GST_DEBUG ("kf_mode : %u", cfg->kf_mode);
 695   GST_DEBUG ("kf_min_dist : %u", cfg->kf_min_dist);
 696   GST_DEBUG ("kf_max_dist : %u", cfg->kf_max_dist);
 697   GST_DEBUG ("large_scale_tile : %u", cfg->large_scale_tile);
 698   /* Tile-related values */
 699 }
 700
 701 static gint
 702 gst_av1_enc_get_downstream_profile (GstAV1Enc * av1enc)
 703 {
 704   GstCaps *allowed;
 705   GstStructure *s;
 706   gint profile = DEFAULT_PROFILE;
 707
 708   allowed = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (av1enc));
 709   if (allowed) {
 710     allowed = gst_caps_truncate (allowed);
 711     s = gst_caps_get_structure (allowed, 0);
 712     if (gst_structure_has_field (s, "profile")) {
 713       const GValue *v = gst_structure_get_value (s, "profile");
 714       const gchar *profile_str = NULL;
 715
 716       if (GST_VALUE_HOLDS_LIST (v) && gst_value_list_get_size (v) > 0) {
 717         profile_str = g_value_get_string (gst_value_list_get_value (v, 0));
 718       } else if (G_VALUE_HOLDS_STRING (v)) {
 719         profile_str = g_value_get_string (v);
 720       }
 721
 722       if (profile_str) {
 723         gchar *endptr = NULL;
 724
 725         if (g_strcmp0 (profile_str, "main") == 0) {
 726           GST_DEBUG_OBJECT (av1enc, "Downstream profile is \"main\"");
 727           profile = 0;
 728         } else if (g_strcmp0 (profile_str, "high") == 0) {
 729           profile = 1;
 730           GST_DEBUG_OBJECT (av1enc, "Downstream profile is \"high\"");
 731         } else if (g_strcmp0 (profile_str, "professional") == 0) {
 732           profile = 2;
 733           GST_DEBUG_OBJECT (av1enc, "Downstream profile is \"professional\"");
 734         } else {
 735           profile = g_ascii_strtoull (profile_str, &endptr, 10);
 736           if (*endptr != '\0' || profile < 0 || profile > 3) {
 737             GST_ERROR_OBJECT (av1enc, "Invalid profile '%s'", profile_str);
 738             profile = DEFAULT_PROFILE;
 739           } else {
 740             GST_DEBUG_OBJECT (av1enc,
 741                 "Downstream profile is \"%s\"", profile_str);
 742           }
 743         }
 744       }
 745     }
 746     gst_caps_unref (allowed);
 747   }
 748
 749   GST_DEBUG_OBJECT (av1enc, "Using profile %d", profile);
 750
 751   return profile;
 752 }
 753
 754 static void
 755 gst_av1_enc_adjust_profile (GstAV1Enc * av1enc, GstVideoFormat format)
 756 {
 757   guint depth = av1enc->aom_cfg.g_bit_depth;
 758   guint profile = av1enc->aom_cfg.g_profile;
 759   gboolean update = FALSE;
 760
 761   switch (profile) {
 762     case 0:
 763       if (depth < 12 && format == GST_VIDEO_FORMAT_Y444) {
 764         profile = 1;
 765         update = TRUE;
 766       } else if (depth == 12 || format == GST_VIDEO_FORMAT_Y42B) {
 767         profile = 2;
 768         update = TRUE;
 769       }
 770       break;
 771     case 1:
 772       if (depth == 12 || format == GST_VIDEO_FORMAT_Y42B) {
 773         profile = 2;
 774         update = TRUE;
 775       } else if (depth < 12 && format == GST_VIDEO_FORMAT_I420) {
 776         profile = 0;
 777         update = TRUE;
 778       }
 779       break;
 780     case 2:
 781       if (depth < 12) {
 782         if (format == GST_VIDEO_FORMAT_Y444) {
 783           profile = 1;
 784           update = TRUE;
 785         } else if (format == GST_VIDEO_FORMAT_I420) {
 786           profile = 0;
 787           update = TRUE;
 788         }
 789       }
 790       break;
 791     default:
 792       break;
 793   }
 794
 795   if (update) {
 796     GST_INFO_OBJECT (av1enc, "profile updated to %d from %d",
 797         profile, av1enc->aom_cfg.g_profile);
 798     av1enc->aom_cfg.g_profile = profile;
 799   }
 800 }
 801
 802 static gboolean
 803 gst_av1_enc_set_format (GstVideoEncoder * encoder, GstVideoCodecState * state)
 804 {
 805   GstVideoCodecState *output_state;
 806   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 807   GstAV1EncClass *av1enc_class = GST_AV1_ENC_GET_CLASS (av1enc);
 808   GstVideoInfo *info = &state->info;
 809
 810   output_state =
 811       gst_video_encoder_set_output_state (encoder,
 812       gst_pad_get_pad_template_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder)),
 813       state);
 814   gst_video_codec_state_unref (output_state);
 815
 816   if (av1enc->input_state) {
 817     gst_video_codec_state_unref (av1enc->input_state);
 818   }
 819   av1enc->input_state = gst_video_codec_state_ref (state);
 820
 821   g_mutex_lock (&av1enc->encoder_lock);
 822   gst_av1_enc_set_latency (av1enc);
 823
 824   av1enc->aom_cfg.g_profile = gst_av1_enc_get_downstream_profile (av1enc);
 825
 826   /* Scale default bitrate to our size */
 827   if (!av1enc->target_bitrate_set)
 828     av1enc->aom_cfg.rc_target_bitrate =
 829         gst_util_uint64_scale (DEFAULT_TARGET_BITRATE,
 830         GST_VIDEO_INFO_WIDTH (info) * GST_VIDEO_INFO_HEIGHT (info), 320 * 240);
 831
 832   av1enc->aom_cfg.g_w = GST_VIDEO_INFO_WIDTH (info);
 833   av1enc->aom_cfg.g_h = GST_VIDEO_INFO_HEIGHT (info);
 834   /* Recommended method is to set the timebase to that of the parent
 835    * container or multimedia framework (ex: 1/1000 for ms, as in FLV) */
 836   if (GST_VIDEO_INFO_FPS_D (info) != 0 && GST_VIDEO_INFO_FPS_N (info) != 0) {
 837     av1enc->aom_cfg.g_timebase.num = GST_VIDEO_INFO_FPS_D (info);
 838     av1enc->aom_cfg.g_timebase.den = GST_VIDEO_INFO_FPS_N (info);
 839   } else {
 840     av1enc->aom_cfg.g_timebase.num = DEFAULT_TIMEBASE_N;
 841     av1enc->aom_cfg.g_timebase.den = DEFAULT_TIMEBASE_D;
 842   }
 843   av1enc->aom_cfg.g_error_resilient = AOM_ERROR_RESILIENT_DEFAULT;
 844
 845   if (av1enc->threads == DEFAULT_THREADS)
 846     av1enc->aom_cfg.g_threads = g_get_num_processors ();
 847   else
 848     av1enc->aom_cfg.g_threads = av1enc->threads;
 849   /* TODO: do more configuration including bit_depth config */
 850
 851   av1enc->format =
 852       gst_video_format_to_av1_img_format (GST_VIDEO_INFO_FORMAT (info));
 853
 854   if (av1enc->aom_cfg.g_bit_depth != DEFAULT_BIT_DEPTH) {
 855     av1enc->aom_cfg.g_input_bit_depth = av1enc->aom_cfg.g_bit_depth;
 856     if (av1enc->aom_cfg.g_bit_depth > 8)
 857       av1enc->format |= AOM_IMG_FMT_HIGHBITDEPTH;
 858   }
 859
 860   /* Adjust profile according to format and bit-depth */
 861   gst_av1_enc_adjust_profile (av1enc, GST_VIDEO_INFO_FORMAT (info));
 862
 863   GST_DEBUG_OBJECT (av1enc, "Calling encoder init with config:");
 864   gst_av1_enc_debug_encoder_cfg (&av1enc->aom_cfg);
 865
 866   if (aom_codec_enc_init (&av1enc->encoder, av1enc_class->codec_algo,
 867           &av1enc->aom_cfg, 0)) {
 868     gst_av1_codec_error (&av1enc->encoder, "Failed to initialize encoder");
 869     g_mutex_unlock (&av1enc->encoder_lock);
 870     return FALSE;
 871   }
 872   av1enc->encoder_inited = TRUE;
 873
 874   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AOME_SET_CPUUSED, av1enc->cpu_used);
 875 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
 876   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_ROW_MT,
 877       (av1enc->row_mt ? 1 : 0));
 878 #endif
 879   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_COLUMNS,
 880       av1enc->tile_columns);
 881   GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_ROWS,
 882       av1enc->tile_rows);
 883   g_mutex_unlock (&av1enc->encoder_lock);
 884
 885   return TRUE;
 886 }
 887
 888 static GstFlowReturn
 889 gst_av1_enc_process (GstAV1Enc * encoder)
 890 {
 891   aom_codec_iter_t iter = NULL;
 892   const aom_codec_cx_pkt_t *pkt;
 893   GstVideoCodecFrame *frame;
 894   GstVideoEncoder *video_encoder;
 895   GstFlowReturn ret = GST_FLOW_CUSTOM_SUCCESS;
 896
 897   video_encoder = GST_VIDEO_ENCODER (encoder);
 898
 899   while ((pkt = aom_codec_get_cx_data (&encoder->encoder, &iter)) != NULL) {
 900     if (pkt->kind == AOM_CODEC_STATS_PKT) {
 901       GST_WARNING_OBJECT (encoder, "Unhandled stats packet");
 902     } else if (pkt->kind == AOM_CODEC_FPMB_STATS_PKT) {
 903       GST_WARNING_OBJECT (encoder, "Unhandled FPMB pkt");
 904     } else if (pkt->kind == AOM_CODEC_PSNR_PKT) {
 905       GST_WARNING_OBJECT (encoder, "Unhandled PSNR packet");
 906     } else if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
 907       frame = gst_video_encoder_get_oldest_frame (video_encoder);
 908       g_assert (frame != NULL);
 909       if ((pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0) {
 910         GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
 911       } else {
 912         GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
 913       }
 914
 915       frame->output_buffer =
 916           gst_buffer_new_memdup (pkt->data.frame.buf, pkt->data.frame.sz);
 917
 918       if ((pkt->data.frame.flags & AOM_FRAME_IS_DROPPABLE) != 0)
 919         GST_BUFFER_FLAG_SET (frame->output_buffer, GST_BUFFER_FLAG_DROPPABLE);
 920
 921       ret = gst_video_encoder_finish_frame (video_encoder, frame);
 922       if (ret != GST_FLOW_OK)
 923         break;
 924     }
 925   }
 926
 927   return ret;
 928 }
 929
 930 static void
 931 gst_av1_enc_fill_image (GstAV1Enc * enc, GstVideoFrame * frame,
 932     aom_image_t * image)
 933 {
 934   image->planes[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
 935   image->planes[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
 936   image->planes[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_DATA (frame, 2);
 937
 938   image->stride[AOM_PLANE_Y] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
 939   image->stride[AOM_PLANE_U] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 1);
 940   image->stride[AOM_PLANE_V] = GST_VIDEO_FRAME_COMP_STRIDE (frame, 2);
 941 }
 942
 943 static GstFlowReturn
 944 gst_av1_enc_handle_frame (GstVideoEncoder * encoder, GstVideoCodecFrame * frame)
 945 {
 946   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
 947   aom_image_t raw;
 948   int flags = 0;
 949   GstFlowReturn ret = GST_FLOW_OK;
 950   GstVideoFrame vframe;
 951   aom_codec_pts_t scaled_pts;
 952   GstClockTime pts_rt;
 953   unsigned long duration;
 954
 955   if (!aom_img_alloc (&raw, av1enc->format, av1enc->aom_cfg.g_w,
 956           av1enc->aom_cfg.g_h, 1)) {
 957     GST_ERROR_OBJECT (encoder, "Failed to initialize encoder");
 958     return FALSE;
 959   }
 960
 961   gst_video_frame_map (&vframe, &av1enc->input_state->info,
 962       frame->input_buffer, GST_MAP_READ);
 963   gst_av1_enc_fill_image (av1enc, &vframe, &raw);
 964   gst_video_frame_unmap (&vframe);
 965
 966   // aom_codec_encode requires pts to be strictly increasing
 967   pts_rt =
 968       gst_segment_to_running_time (&encoder->input_segment,
 969       GST_FORMAT_TIME, frame->pts);
 970
 971   if (GST_CLOCK_TIME_IS_VALID (av1enc->next_pts)
 972       && pts_rt <= av1enc->next_pts) {
 973     GST_WARNING_OBJECT (av1enc,
 974         "decreasing pts %" GST_TIME_FORMAT " previous buffer was %"
 975         GST_TIME_FORMAT " enforce increasing pts", GST_TIME_ARGS (pts_rt),
 976         GST_TIME_ARGS (av1enc->next_pts));
 977     pts_rt = av1enc->next_pts + 1;
 978   }
 979
 980   av1enc->next_pts = pts_rt;
 981
 982   // Convert the pts from nanoseconds to timebase units
 983   scaled_pts =
 984       gst_util_uint64_scale_int (pts_rt,
 985       av1enc->aom_cfg.g_timebase.den,
 986       av1enc->aom_cfg.g_timebase.num * (GstClockTime) GST_SECOND);
 987
 988   if (frame->duration != GST_CLOCK_TIME_NONE) {
 989     duration =
 990         gst_util_uint64_scale (frame->duration, av1enc->aom_cfg.g_timebase.den,
 991         av1enc->aom_cfg.g_timebase.num * (GstClockTime) GST_SECOND);
 992
 993     if (duration > 0) {
 994       av1enc->next_pts += frame->duration;
 995     } else {
 996       /* We force the path ignoring the duration if we end up with a zero
 997        * value for duration after scaling (e.g. duration value too small) */
 998       GST_WARNING_OBJECT (av1enc,
 999           "Ignoring too small frame duration %" GST_TIME_FORMAT,
1000           GST_TIME_ARGS (frame->duration));
1001       duration = 1;
1002       av1enc->next_pts += 1;
1003     }
1004   } else {
1005     duration = 1;
1006     av1enc->next_pts += 1;
1007   }
1008
1009   if (aom_codec_encode (&av1enc->encoder, &raw, scaled_pts, duration, flags)
1010       != AOM_CODEC_OK) {
1011     gst_av1_codec_error (&av1enc->encoder, "Failed to encode frame");
1012     ret = GST_FLOW_ERROR;
1013   }
1014
1015   aom_img_free (&raw);
1016   gst_video_codec_frame_unref (frame);
1017
1018   if (ret == GST_FLOW_ERROR)
1019     return ret;
1020
1021   ret = gst_av1_enc_process (av1enc);
1022
1023   if (ret == GST_FLOW_CUSTOM_SUCCESS)
1024     ret = GST_FLOW_OK;
1025
1026   return ret;
1027 }
1028
1029 static GstFlowReturn
1030 gst_av1_enc_finish (GstVideoEncoder * encoder)
1031 {
1032   GstFlowReturn ret = GST_FLOW_OK;
1033   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
1034   aom_codec_pts_t scaled_pts;
1035   GstClockTime pts = 0;
1036
1037   while (ret == GST_FLOW_OK) {
1038     GST_DEBUG_OBJECT (encoder, "Calling finish");
1039     g_mutex_lock (&av1enc->encoder_lock);
1040
1041     if (GST_CLOCK_TIME_IS_VALID (av1enc->next_pts))
1042       pts = av1enc->next_pts;
1043     scaled_pts =
1044         gst_util_uint64_scale (pts,
1045         av1enc->aom_cfg.g_timebase.den,
1046         av1enc->aom_cfg.g_timebase.num * (GstClockTime) GST_SECOND);
1047
1048     if (aom_codec_encode (&av1enc->encoder, NULL, scaled_pts, 1, 0)
1049         != AOM_CODEC_OK) {
1050       gst_av1_codec_error (&av1enc->encoder, "Failed to encode frame");
1051       ret = GST_FLOW_ERROR;
1052     }
1053     g_mutex_unlock (&av1enc->encoder_lock);
1054
1055     ret = gst_av1_enc_process (av1enc);
1056   }
1057
1058
1059   if (ret == GST_FLOW_CUSTOM_SUCCESS)
1060     ret = GST_FLOW_OK;
1061
1062   return ret;
1063 }
1064
1065 static void
1066 gst_av1_enc_destroy_encoder (GstAV1Enc * av1enc)
1067 {
1068   g_mutex_lock (&av1enc->encoder_lock);
1069   if (av1enc->encoder_inited) {
1070     aom_codec_destroy (&av1enc->encoder);
1071     av1enc->encoder_inited = FALSE;
1072   }
1073
1074   av1enc->next_pts = GST_CLOCK_TIME_NONE;
1075
1076   g_mutex_unlock (&av1enc->encoder_lock);
1077 }
1078
1079 static gboolean
1080 gst_av1_enc_propose_allocation (GstVideoEncoder * encoder, GstQuery * query)
1081 {
1082   gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
1083
1084   return GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder,
1085       query);
1086 }
1087
1088 static void
1089 gst_av1_enc_set_property (GObject * object, guint prop_id,
1090     const GValue * value, GParamSpec * pspec)
1091 {
1092   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (object);
1093   gboolean global = FALSE;
1094   aom_codec_err_t status;
1095
1096   GST_OBJECT_LOCK (av1enc);
1097
1098   g_mutex_lock (&av1enc->encoder_lock);
1099   switch (prop_id) {
1100     case PROP_CPU_USED:
1101       av1enc->cpu_used = g_value_get_int (value);
1102       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AOME_SET_CPUUSED,
1103           av1enc->cpu_used);
1104       break;
1105     case PROP_DROP_FRAME:
1106       av1enc->aom_cfg.rc_dropframe_thresh = g_value_get_uint (value);
1107       global = TRUE;
1108       break;
1109     case PROP_RESIZE_MODE:
1110       av1enc->aom_cfg.rc_resize_mode = g_value_get_enum (value);
1111       global = TRUE;
1112       break;
1113     case PROP_RESIZE_DENOMINATOR:
1114       av1enc->aom_cfg.rc_resize_denominator = g_value_get_uint (value);
1115       global = TRUE;
1116       break;
1117     case PROP_RESIZE_KF_DENOMINATOR:
1118       av1enc->aom_cfg.rc_resize_kf_denominator = g_value_get_uint (value);
1119       global = TRUE;
1120       break;
1121     case PROP_SUPERRES_MODE:
1122       av1enc->aom_cfg.rc_superres_mode = g_value_get_enum (value);
1123       global = TRUE;
1124       break;
1125     case PROP_SUPERRES_DENOMINATOR:
1126       av1enc->aom_cfg.rc_superres_denominator = g_value_get_uint (value);
1127       global = TRUE;
1128       break;
1129     case PROP_SUPERRES_KF_DENOMINATOR:
1130       av1enc->aom_cfg.rc_superres_kf_denominator = g_value_get_uint (value);
1131       global = TRUE;
1132       break;
1133     case PROP_SUPERRES_QTHRESH:
1134       av1enc->aom_cfg.rc_superres_qthresh = g_value_get_uint (value);
1135       global = TRUE;
1136       break;
1137     case PROP_SUPERRES_KF_QTHRESH:
1138       av1enc->aom_cfg.rc_superres_kf_qthresh = g_value_get_uint (value);
1139       global = TRUE;
1140       break;
1141     case PROP_END_USAGE:
1142       av1enc->aom_cfg.rc_end_usage = g_value_get_enum (value);
1143       global = TRUE;
1144       break;
1145     case PROP_TARGET_BITRATE:
1146       av1enc->aom_cfg.rc_target_bitrate = g_value_get_uint (value);
1147       av1enc->target_bitrate_set = TRUE;
1148       global = TRUE;
1149       break;
1150     case PROP_MIN_QUANTIZER:
1151       av1enc->aom_cfg.rc_min_quantizer = g_value_get_uint (value);
1152       global = TRUE;
1153       break;
1154     case PROP_MAX_QUANTIZER:
1155       av1enc->aom_cfg.rc_max_quantizer = g_value_get_uint (value);
1156       global = TRUE;
1157       break;
1158     case PROP_UNDERSHOOT_PCT:
1159       av1enc->aom_cfg.rc_undershoot_pct = g_value_get_uint (value);
1160       global = TRUE;
1161       break;
1162     case PROP_OVERSHOOT_PCT:
1163       av1enc->aom_cfg.rc_overshoot_pct = g_value_get_uint (value);
1164       global = TRUE;
1165       break;
1166     case PROP_BUF_SZ:
1167       av1enc->aom_cfg.rc_buf_sz = g_value_get_uint (value);
1168       global = TRUE;
1169       break;
1170     case PROP_BUF_INITIAL_SZ:
1171       av1enc->aom_cfg.rc_buf_initial_sz = g_value_get_uint (value);
1172       global = TRUE;
1173       break;
1174     case PROP_BUF_OPTIMAL_SZ:
1175       av1enc->aom_cfg.rc_buf_optimal_sz = g_value_get_uint (value);
1176       global = TRUE;
1177       break;
1178     case PROP_THREADS:
1179       av1enc->threads = g_value_get_uint (value);
1180       global = TRUE;
1181       break;
1182 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
1183     case PROP_ROW_MT:
1184       av1enc->row_mt = g_value_get_boolean (value);
1185       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_ROW_MT,
1186           (av1enc->row_mt ? 1 : 0));
1187       break;
1188 #endif
1189     case PROP_TILE_COLUMNS:
1190       av1enc->tile_columns = g_value_get_uint (value);
1191       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_COLUMNS,
1192           av1enc->tile_columns);
1193       break;
1194     case PROP_TILE_ROWS:
1195       av1enc->tile_rows = g_value_get_uint (value);
1196       GST_AV1_ENC_APPLY_CODEC_CONTROL (av1enc, AV1E_SET_TILE_ROWS,
1197           av1enc->tile_rows);
1198       break;
1199     case PROP_KF_MODE:
1200       av1enc->aom_cfg.kf_mode = g_value_get_enum (value);
1201       global = TRUE;
1202       break;
1203     case PROP_ENC_PASS:
1204       av1enc->aom_cfg.g_pass = g_value_get_enum (value);
1205       global = TRUE;
1206       break;
1207     case PROP_USAGE_PROFILE:
1208       av1enc->aom_cfg.g_usage = g_value_get_enum (value);
1209       global = TRUE;
1210       break;
1211     case PROP_LAG_IN_FRAMES:
1212       av1enc->aom_cfg.g_lag_in_frames = g_value_get_uint (value);
1213       global = TRUE;
1214       break;
1215     case PROP_KEYFRAME_MAX_DIST:
1216       av1enc->aom_cfg.kf_max_dist = g_value_get_int (value);
1217       global = TRUE;
1218       break;
1219     default:
1220       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1221       break;
1222   }
1223
1224   if (global &&av1enc->encoder_inited) {
1225     status = aom_codec_enc_config_set (&av1enc->encoder, &av1enc->aom_cfg);
1226     GST_DEBUG_OBJECT (av1enc, "Set %s encoder configuration, ret = %s",
1227         pspec->name, gst_av1_get_error_name (status));
1228   }
1229
1230   g_mutex_unlock (&av1enc->encoder_lock);
1231   GST_OBJECT_UNLOCK (av1enc);
1232 }
1233
1234 static void
1235 gst_av1_enc_get_property (GObject * object, guint prop_id, GValue * value,
1236     GParamSpec * pspec)
1237 {
1238   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (object);
1239
1240   GST_OBJECT_LOCK (av1enc);
1241
1242   switch (prop_id) {
1243     case PROP_CPU_USED:
1244       g_value_set_int (value, av1enc->cpu_used);
1245       break;
1246     case PROP_DROP_FRAME:
1247       g_value_set_uint (value, av1enc->aom_cfg.rc_dropframe_thresh);
1248       break;
1249     case PROP_RESIZE_MODE:
1250       g_value_set_enum (value, av1enc->aom_cfg.rc_resize_mode);
1251       break;
1252     case PROP_RESIZE_DENOMINATOR:
1253       g_value_set_uint (value, av1enc->aom_cfg.rc_resize_denominator);
1254       break;
1255     case PROP_RESIZE_KF_DENOMINATOR:
1256       g_value_set_uint (value, av1enc->aom_cfg.rc_resize_kf_denominator);
1257       break;
1258     case PROP_SUPERRES_MODE:
1259       g_value_set_enum (value, av1enc->aom_cfg.rc_superres_mode);
1260       break;
1261     case PROP_SUPERRES_DENOMINATOR:
1262       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_denominator);
1263       break;
1264     case PROP_SUPERRES_KF_DENOMINATOR:
1265       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_kf_denominator);
1266       break;
1267     case PROP_SUPERRES_QTHRESH:
1268       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_qthresh);
1269       break;
1270     case PROP_SUPERRES_KF_QTHRESH:
1271       g_value_set_uint (value, av1enc->aom_cfg.rc_superres_kf_qthresh);
1272       break;
1273     case PROP_END_USAGE:
1274       g_value_set_enum (value, av1enc->aom_cfg.rc_end_usage);
1275       break;
1276     case PROP_TARGET_BITRATE:
1277       g_value_set_uint (value, av1enc->aom_cfg.rc_target_bitrate);
1278       break;
1279     case PROP_MIN_QUANTIZER:
1280       g_value_set_uint (value, av1enc->aom_cfg.rc_min_quantizer);
1281       break;
1282     case PROP_MAX_QUANTIZER:
1283       g_value_set_uint (value, av1enc->aom_cfg.rc_max_quantizer);
1284       break;
1285     case PROP_UNDERSHOOT_PCT:
1286       g_value_set_uint (value, av1enc->aom_cfg.rc_undershoot_pct);
1287       break;
1288     case PROP_OVERSHOOT_PCT:
1289       g_value_set_uint (value, av1enc->aom_cfg.rc_overshoot_pct);
1290       break;
1291     case PROP_BUF_SZ:
1292       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_sz);
1293       break;
1294     case PROP_BUF_INITIAL_SZ:
1295       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_initial_sz);
1296       break;
1297     case PROP_BUF_OPTIMAL_SZ:
1298       g_value_set_uint (value, av1enc->aom_cfg.rc_buf_optimal_sz);
1299       break;
1300     case PROP_THREADS:
1301       g_value_set_uint (value, av1enc->threads);
1302       break;
1303 #ifdef AOM_CTRL_AV1E_SET_ROW_MT
1304     case PROP_ROW_MT:
1305       g_value_set_boolean (value, av1enc->row_mt);
1306       break;
1307 #endif
1308     case PROP_TILE_COLUMNS:
1309       g_value_set_uint (value, av1enc->tile_columns);
1310       break;
1311     case PROP_TILE_ROWS:
1312       g_value_set_uint (value, av1enc->tile_rows);
1313       break;
1314     case PROP_KF_MODE:
1315       g_value_set_enum (value, av1enc->aom_cfg.kf_mode);
1316       break;
1317     case PROP_ENC_PASS:
1318       g_value_set_enum (value, av1enc->aom_cfg.g_pass);
1319       break;
1320     case PROP_USAGE_PROFILE:
1321       g_value_set_enum (value, av1enc->aom_cfg.g_usage);
1322       break;
1323     case PROP_LAG_IN_FRAMES:
1324       g_value_set_uint (value, av1enc->aom_cfg.g_lag_in_frames);
1325       break;
1326     case PROP_KEYFRAME_MAX_DIST:
1327       g_value_set_int (value, av1enc->aom_cfg.kf_max_dist);
1328       break;
1329     default:
1330       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1331       break;
1332   }
1333
1334   GST_OBJECT_UNLOCK (av1enc);
1335 }
1336
1337 static gboolean
1338 gst_av1_enc_start (GstVideoEncoder * encoder)
1339 {
1340   return TRUE;
1341 }
1342
1343 static gboolean
1344 gst_av1_enc_stop (GstVideoEncoder * encoder)
1345 {
1346   GstAV1Enc *av1enc = GST_AV1_ENC_CAST (encoder);
1347
1348   if (av1enc->input_state) {
1349     gst_video_codec_state_unref (av1enc->input_state);
1350   }
1351   av1enc->input_state = NULL;
1352
1353   gst_av1_enc_destroy_encoder (av1enc);
1354
1355   return TRUE;
1356 }