subprojects/gst-plugins-bad/ext/fdkaac/gstfdkaacenc.c

   1 /*
   2  * Copyright (C) 2016 Sebastian Dröge <sebastian@centricular.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 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "gstfdkaac.h"
  25 #include "gstfdkaacenc.h"
  26
  27 #include <gst/pbutils/pbutils.h>
  28
  29 #include <string.h>
  30
  31 /* TODO:
  32  * - Add support for other AOT / profiles
  33  * - Expose more properties, e.g. afterburner and vbr
  34  * - Signal encoder delay
  35  * - LOAS / LATM support
  36  */
  37
  38 enum
  39 {
  40   PROP_0,
  41   PROP_BITRATE
  42 };
  43
  44 #define DEFAULT_BITRATE (0)
  45
  46 #define SAMPLE_RATES " 8000, " \
  47                     "11025, " \
  48                     "12000, " \
  49                     "16000, " \
  50                     "22050, " \
  51                     "24000, " \
  52                     "32000, " \
  53                     "44100, " \
  54                     "48000, " \
  55                     "64000, " \
  56                     "88200, " \
  57                     "96000"
  58
  59 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  60     GST_PAD_SINK,
  61     GST_PAD_ALWAYS,
  62     GST_STATIC_CAPS ("audio/x-raw, "
  63         "format = (string) " GST_AUDIO_NE (S16) ", "
  64         "layout = (string) interleaved, "
  65         "rate = (int) { " SAMPLE_RATES " }, "
  66         "channels = (int) {1, 2, 3, 4, 5, 6, 8}")
  67     );
  68
  69 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  70     GST_PAD_SRC,
  71     GST_PAD_ALWAYS,
  72     GST_STATIC_CAPS ("audio/mpeg, "
  73         "mpegversion = (int) 4, "
  74         "rate = (int) { " SAMPLE_RATES " }, "
  75         "channels = (int) {1, 2, 3, 4, 5, 6, 8}, "
  76         "stream-format = (string) { adts, adif, raw }, "
  77         "base-profile = (string) lc, " "framed = (boolean) true")
  78     );
  79
  80 GST_DEBUG_CATEGORY_STATIC (gst_fdkaacenc_debug);
  81 #define GST_CAT_DEFAULT gst_fdkaacenc_debug
  82
  83 static void gst_fdkaacenc_set_property (GObject * object, guint prop_id,
  84     const GValue * value, GParamSpec * pspec);
  85 static void gst_fdkaacenc_get_property (GObject * object, guint prop_id,
  86     GValue * value, GParamSpec * pspec);
  87 static gboolean gst_fdkaacenc_start (GstAudioEncoder * enc);
  88 static gboolean gst_fdkaacenc_stop (GstAudioEncoder * enc);
  89 static gboolean gst_fdkaacenc_set_format (GstAudioEncoder * enc,
  90     GstAudioInfo * info);
  91 static GstFlowReturn gst_fdkaacenc_handle_frame (GstAudioEncoder * enc,
  92     GstBuffer * in_buf);
  93 static GstCaps *gst_fdkaacenc_get_caps (GstAudioEncoder * enc,
  94     GstCaps * filter);
  95 static void gst_fdkaacenc_flush (GstAudioEncoder * enc);
  96
  97 G_DEFINE_TYPE (GstFdkAacEnc, gst_fdkaacenc, GST_TYPE_AUDIO_ENCODER);
  98 GST_ELEMENT_REGISTER_DEFINE (fdkaacenc, "fdkaacenc", GST_RANK_PRIMARY,
  99     GST_TYPE_FDKAACENC);
 100
 101 static void
 102 gst_fdkaacenc_set_property (GObject * object, guint prop_id,
 103     const GValue * value, GParamSpec * pspec)
 104 {
 105   GstFdkAacEnc *self = GST_FDKAACENC (object);
 106
 107   switch (prop_id) {
 108     case PROP_BITRATE:
 109       self->bitrate = g_value_get_int (value);
 110       break;
 111     default:
 112       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 113       break;
 114   }
 115   return;
 116 }
 117
 118 static void
 119 gst_fdkaacenc_get_property (GObject * object, guint prop_id,
 120     GValue * value, GParamSpec * pspec)
 121 {
 122   GstFdkAacEnc *self = GST_FDKAACENC (object);
 123
 124   switch (prop_id) {
 125     case PROP_BITRATE:
 126       g_value_set_int (value, self->bitrate);
 127       break;
 128     default:
 129       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 130       break;
 131   }
 132   return;
 133 }
 134
 135 static gboolean
 136 gst_fdkaacenc_start (GstAudioEncoder * enc)
 137 {
 138   GstFdkAacEnc *self = GST_FDKAACENC (enc);
 139
 140   GST_DEBUG_OBJECT (self, "start");
 141
 142   return TRUE;
 143 }
 144
 145 static gboolean
 146 gst_fdkaacenc_stop (GstAudioEncoder * enc)
 147 {
 148   GstFdkAacEnc *self = GST_FDKAACENC (enc);
 149
 150   GST_DEBUG_OBJECT (self, "stop");
 151
 152   if (self->enc) {
 153     aacEncClose (&self->enc);
 154     self->enc = NULL;
 155   }
 156
 157   self->is_drained = TRUE;
 158   return TRUE;
 159 }
 160
 161 static GstCaps *
 162 gst_fdkaacenc_get_caps (GstAudioEncoder * enc, GstCaps * filter)
 163 {
 164   const GstFdkAacChannelLayout *layout;
 165   GstCaps *res, *caps;
 166
 167   caps = gst_caps_new_empty ();
 168
 169   for (layout = channel_layouts; layout->channels; layout++) {
 170     gint channels = layout->channels;
 171     GstCaps *tmp =
 172         gst_caps_make_writable (gst_pad_get_pad_template_caps
 173         (GST_AUDIO_ENCODER_SINK_PAD (enc)));
 174
 175     if (channels == 1) {
 176       gst_caps_set_simple (tmp, "channels", G_TYPE_INT, channels, NULL);
 177     } else {
 178       guint64 channel_mask;
 179       gst_audio_channel_positions_to_mask (layout->positions, channels, FALSE,
 180           &channel_mask);
 181       gst_caps_set_simple (tmp, "channels", G_TYPE_INT, channels,
 182           "channel-mask", GST_TYPE_BITMASK, channel_mask, NULL);
 183     }
 184
 185     gst_caps_append (caps, tmp);
 186   }
 187
 188   res = gst_audio_encoder_proxy_getcaps (enc, caps, filter);
 189   gst_caps_unref (caps);
 190
 191   return res;
 192 }
 193
 194 static gboolean
 195 gst_fdkaacenc_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
 196 {
 197   GstFdkAacEnc *self = GST_FDKAACENC (enc);
 198   gboolean ret = FALSE;
 199   GstCaps *allowed_caps;
 200   GstCaps *src_caps;
 201   AACENC_ERROR err;
 202   gint transmux = 0, aot = AOT_AAC_LC;
 203   gint mpegversion = 4;
 204   CHANNEL_MODE channel_mode;
 205   AACENC_InfoStruct enc_info = { 0 };
 206   gint bitrate;
 207
 208   if (self->enc && !self->is_drained) {
 209     /* drain */
 210     gst_fdkaacenc_handle_frame (enc, NULL);
 211     aacEncClose (&self->enc);
 212     self->is_drained = TRUE;
 213   }
 214
 215   allowed_caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (self));
 216
 217   GST_DEBUG_OBJECT (self, "allowed caps: %" GST_PTR_FORMAT, allowed_caps);
 218
 219   if (allowed_caps && gst_caps_get_size (allowed_caps) > 0) {
 220     GstStructure *s = gst_caps_get_structure (allowed_caps, 0);
 221     const gchar *str = NULL;
 222
 223     if ((str = gst_structure_get_string (s, "stream-format"))) {
 224       if (strcmp (str, "adts") == 0) {
 225         GST_DEBUG_OBJECT (self, "use ADTS format for output");
 226         transmux = 2;
 227       } else if (strcmp (str, "adif") == 0) {
 228         GST_DEBUG_OBJECT (self, "use ADIF format for output");
 229         transmux = 1;
 230       } else if (strcmp (str, "raw") == 0) {
 231         GST_DEBUG_OBJECT (self, "use RAW format for output");
 232         transmux = 0;
 233       }
 234     }
 235
 236     gst_structure_get_int (s, "mpegversion", &mpegversion);
 237   }
 238   if (allowed_caps)
 239     gst_caps_unref (allowed_caps);
 240
 241   err = aacEncOpen (&self->enc, 0, GST_AUDIO_INFO_CHANNELS (info));
 242   if (err != AACENC_OK) {
 243     GST_ERROR_OBJECT (self, "Unable to open encoder: %d", err);
 244     return FALSE;
 245   }
 246
 247   aot = AOT_AAC_LC;
 248
 249   if ((err = aacEncoder_SetParam (self->enc, AACENC_AOT, aot)) != AACENC_OK) {
 250     GST_ERROR_OBJECT (self, "Unable to set AOT %d: %d", aot, err);
 251     return FALSE;
 252   }
 253
 254   if ((err = aacEncoder_SetParam (self->enc, AACENC_SAMPLERATE,
 255               GST_AUDIO_INFO_RATE (info))) != AACENC_OK) {
 256     GST_ERROR_OBJECT (self, "Unable to set sample rate %d: %d",
 257         GST_AUDIO_INFO_RATE (info), err);
 258     return FALSE;
 259   }
 260
 261   if (GST_AUDIO_INFO_CHANNELS (info) == 1) {
 262     channel_mode = MODE_1;
 263     self->need_reorder = FALSE;
 264     self->aac_positions = NULL;
 265   } else {
 266     gint in_channels = GST_AUDIO_INFO_CHANNELS (info);
 267     const GstAudioChannelPosition *in_positions =
 268         &GST_AUDIO_INFO_POSITION (info, 0);
 269     guint64 in_channel_mask;
 270     const GstFdkAacChannelLayout *layout;
 271
 272     gst_audio_channel_positions_to_mask (in_positions, in_channels, FALSE,
 273         &in_channel_mask);
 274
 275     for (layout = channel_layouts; layout->channels; layout++) {
 276       gint channels = layout->channels;
 277       const GstAudioChannelPosition *positions = layout->positions;
 278       guint64 channel_mask;
 279
 280       if (channels != in_channels)
 281         continue;
 282
 283       gst_audio_channel_positions_to_mask (positions, channels, FALSE,
 284           &channel_mask);
 285       if (channel_mask != in_channel_mask)
 286         continue;
 287
 288       channel_mode = layout->mode;
 289       self->need_reorder = memcmp (positions, in_positions,
 290           channels * sizeof *positions) != 0;
 291       self->aac_positions = positions;
 292       break;
 293     }
 294
 295     if (!layout->channels) {
 296       GST_ERROR_OBJECT (self, "Couldn't find a valid channel layout");
 297       return FALSE;
 298     }
 299   }
 300
 301   if ((err = aacEncoder_SetParam (self->enc, AACENC_CHANNELMODE,
 302               channel_mode)) != AACENC_OK) {
 303     GST_ERROR_OBJECT (self, "Unable to set channel mode %d: %d", channel_mode,
 304         err);
 305     return FALSE;
 306   }
 307
 308   /* MPEG channel order */
 309   if ((err = aacEncoder_SetParam (self->enc, AACENC_CHANNELORDER,
 310               0)) != AACENC_OK) {
 311     GST_ERROR_OBJECT (self, "Unable to set channel order %d: %d", channel_mode,
 312         err);
 313     return FALSE;
 314   }
 315
 316   bitrate = self->bitrate;
 317   /* See
 318    * http://wiki.hydrogenaud.io/index.php?title=Fraunhofer_FDK_AAC#Recommended_Sampling_Rate_and_Bitrate_Combinations
 319    */
 320   if (bitrate == 0) {
 321     if (GST_AUDIO_INFO_CHANNELS (info) == 1) {
 322       if (GST_AUDIO_INFO_RATE (info) < 16000) {
 323         bitrate = 8000;
 324       } else if (GST_AUDIO_INFO_RATE (info) == 16000) {
 325         bitrate = 16000;
 326       } else if (GST_AUDIO_INFO_RATE (info) < 32000) {
 327         bitrate = 24000;
 328       } else if (GST_AUDIO_INFO_RATE (info) == 32000) {
 329         bitrate = 32000;
 330       } else if (GST_AUDIO_INFO_RATE (info) <= 44100) {
 331         bitrate = 56000;
 332       } else {
 333         bitrate = 160000;
 334       }
 335     } else if (GST_AUDIO_INFO_CHANNELS (info) == 2) {
 336       if (GST_AUDIO_INFO_RATE (info) < 16000) {
 337         bitrate = 16000;
 338       } else if (GST_AUDIO_INFO_RATE (info) == 16000) {
 339         bitrate = 24000;
 340       } else if (GST_AUDIO_INFO_RATE (info) < 22050) {
 341         bitrate = 32000;
 342       } else if (GST_AUDIO_INFO_RATE (info) < 32000) {
 343         bitrate = 40000;
 344       } else if (GST_AUDIO_INFO_RATE (info) == 32000) {
 345         bitrate = 96000;
 346       } else if (GST_AUDIO_INFO_RATE (info) <= 44100) {
 347         bitrate = 112000;
 348       } else {
 349         bitrate = 320000;
 350       }
 351     } else {
 352       /* 5, 5.1 */
 353       if (GST_AUDIO_INFO_RATE (info) < 32000) {
 354         bitrate = 160000;
 355       } else if (GST_AUDIO_INFO_RATE (info) <= 44100) {
 356         bitrate = 240000;
 357       } else {
 358         bitrate = 320000;
 359       }
 360     }
 361   }
 362
 363   if ((err = aacEncoder_SetParam (self->enc, AACENC_TRANSMUX,
 364               transmux)) != AACENC_OK) {
 365     GST_ERROR_OBJECT (self, "Unable to set transmux %d: %d", transmux, err);
 366     return FALSE;
 367   }
 368
 369   if ((err = aacEncoder_SetParam (self->enc, AACENC_BITRATE,
 370               bitrate)) != AACENC_OK) {
 371     GST_ERROR_OBJECT (self, "Unable to set bitrate %d: %d", bitrate, err);
 372     return FALSE;
 373   }
 374
 375   if ((err = aacEncEncode (self->enc, NULL, NULL, NULL, NULL)) != AACENC_OK) {
 376     GST_ERROR_OBJECT (self, "Unable to initialize encoder: %d", err);
 377     return FALSE;
 378   }
 379
 380   if ((err = aacEncInfo (self->enc, &enc_info)) != AACENC_OK) {
 381     GST_ERROR_OBJECT (self, "Unable to get encoder info: %d", err);
 382     return FALSE;
 383   }
 384
 385   gst_audio_encoder_set_frame_max (enc, 1);
 386   gst_audio_encoder_set_frame_samples_min (enc, enc_info.frameLength);
 387   gst_audio_encoder_set_frame_samples_max (enc, enc_info.frameLength);
 388   gst_audio_encoder_set_hard_min (enc, FALSE);
 389   self->outbuf_size = enc_info.maxOutBufBytes;
 390   self->samples_per_frame = enc_info.frameLength;
 391
 392   src_caps = gst_caps_new_simple ("audio/mpeg",
 393       "mpegversion", G_TYPE_INT, mpegversion,
 394       "channels", G_TYPE_INT, GST_AUDIO_INFO_CHANNELS (info),
 395       "framed", G_TYPE_BOOLEAN, TRUE,
 396       "rate", G_TYPE_INT, GST_AUDIO_INFO_RATE (info), NULL);
 397
 398   /* raw */
 399   if (transmux == 0) {
 400     GstBuffer *codec_data =
 401         gst_buffer_new_memdup (enc_info.confBuf, enc_info.confSize);
 402     gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER, codec_data,
 403         "stream-format", G_TYPE_STRING, "raw", NULL);
 404     gst_buffer_unref (codec_data);
 405   } else if (transmux == 1) {
 406     gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adif",
 407         NULL);
 408   } else if (transmux == 2) {
 409     gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adts",
 410         NULL);
 411   } else {
 412     g_assert_not_reached ();
 413   }
 414
 415   gst_codec_utils_aac_caps_set_level_and_profile (src_caps, enc_info.confBuf,
 416       enc_info.confSize);
 417
 418   ret = gst_audio_encoder_set_output_format (enc, src_caps);
 419   gst_caps_unref (src_caps);
 420
 421   return ret;
 422 }
 423
 424 static GstFlowReturn
 425 gst_fdkaacenc_handle_frame (GstAudioEncoder * enc, GstBuffer * inbuf)
 426 {
 427   GstFdkAacEnc *self = GST_FDKAACENC (enc);
 428   GstFlowReturn ret = GST_FLOW_OK;
 429   GstAudioInfo *info;
 430   GstMapInfo imap, omap;
 431   GstBuffer *outbuf;
 432   AACENC_BufDesc in_desc = { 0 };
 433   AACENC_BufDesc out_desc = { 0 };
 434   AACENC_InArgs in_args = { 0 };
 435   AACENC_OutArgs out_args = { 0 };
 436   gint in_id = IN_AUDIO_DATA, out_id = OUT_BITSTREAM_DATA;
 437   gint in_sizes, out_sizes;
 438   gint in_el_sizes, out_el_sizes;
 439   AACENC_ERROR err;
 440
 441   info = gst_audio_encoder_get_audio_info (enc);
 442
 443   if (inbuf) {
 444     if (self->need_reorder) {
 445       inbuf = gst_buffer_copy (inbuf);
 446       gst_buffer_map (inbuf, &imap, GST_MAP_READWRITE);
 447       gst_audio_reorder_channels (imap.data, imap.size,
 448           GST_AUDIO_INFO_FORMAT (info), GST_AUDIO_INFO_CHANNELS (info),
 449           &GST_AUDIO_INFO_POSITION (info, 0), self->aac_positions);
 450     } else {
 451       gst_buffer_map (inbuf, &imap, GST_MAP_READ);
 452     }
 453
 454     in_args.numInSamples = imap.size / GST_AUDIO_INFO_BPS (info);
 455
 456     in_sizes = imap.size;
 457     in_el_sizes = GST_AUDIO_INFO_BPS (info);
 458     in_desc.numBufs = 1;
 459   } else {
 460     in_args.numInSamples = -1;
 461
 462     in_sizes = 0;
 463     in_el_sizes = 0;
 464     in_desc.numBufs = 0;
 465   }
 466   /* We unset is_drained even if there's no inbuf. Basically this is a
 467    * workaround for aacEncEncode always producing 1024 bytes even without any
 468    * input, thus messing up with the base class counting */
 469   self->is_drained = FALSE;
 470
 471   in_desc.bufferIdentifiers = &in_id;
 472   in_desc.bufs = (void *) &imap.data;
 473   in_desc.bufSizes = &in_sizes;
 474   in_desc.bufElSizes = &in_el_sizes;
 475
 476   outbuf = gst_audio_encoder_allocate_output_buffer (enc, self->outbuf_size);
 477   if (!outbuf) {
 478     ret = GST_FLOW_ERROR;
 479     goto out;
 480   }
 481
 482   gst_buffer_map (outbuf, &omap, GST_MAP_WRITE);
 483   out_sizes = omap.size;
 484   out_el_sizes = 1;
 485   out_desc.bufferIdentifiers = &out_id;
 486   out_desc.numBufs = 1;
 487   out_desc.bufs = (void *) &omap.data;
 488   out_desc.bufSizes = &out_sizes;
 489   out_desc.bufElSizes = &out_el_sizes;
 490
 491   err = aacEncEncode (self->enc, &in_desc, &out_desc, &in_args, &out_args);
 492   if (err == AACENC_ENCODE_EOF && !inbuf)
 493     goto out;
 494   else if (err != AACENC_OK) {
 495     GST_ERROR_OBJECT (self, "Failed to encode data: %d", err);
 496     ret = GST_FLOW_ERROR;
 497     goto out;
 498   }
 499
 500   if (inbuf) {
 501     gst_buffer_unmap (inbuf, &imap);
 502     if (self->need_reorder)
 503       gst_buffer_unref (inbuf);
 504     inbuf = NULL;
 505   }
 506
 507   if (!out_args.numOutBytes)
 508     goto out;
 509
 510   gst_buffer_unmap (outbuf, &omap);
 511   gst_buffer_set_size (outbuf, out_args.numOutBytes);
 512
 513   ret = gst_audio_encoder_finish_frame (enc, outbuf, self->samples_per_frame);
 514   outbuf = NULL;
 515
 516 out:
 517   if (outbuf) {
 518     gst_buffer_unmap (outbuf, &omap);
 519     gst_buffer_unref (outbuf);
 520   }
 521   if (inbuf) {
 522     gst_buffer_unmap (inbuf, &imap);
 523     if (self->need_reorder)
 524       gst_buffer_unref (inbuf);
 525   }
 526
 527   return ret;
 528 }
 529
 530 static void
 531 gst_fdkaacenc_flush (GstAudioEncoder * enc)
 532 {
 533   GstFdkAacEnc *self = GST_FDKAACENC (enc);
 534   GstAudioInfo *info = gst_audio_encoder_get_audio_info (enc);
 535
 536   aacEncClose (&self->enc);
 537   self->enc = NULL;
 538   self->is_drained = TRUE;
 539
 540   if (GST_AUDIO_INFO_IS_VALID (info))
 541     gst_fdkaacenc_set_format (enc, info);
 542 }
 543
 544 static void
 545 gst_fdkaacenc_init (GstFdkAacEnc * self)
 546 {
 547   self->bitrate = DEFAULT_BITRATE;
 548   self->enc = NULL;
 549   self->is_drained = TRUE;
 550
 551   gst_audio_encoder_set_drainable (GST_AUDIO_ENCODER (self), TRUE);
 552 }
 553
 554 static void
 555 gst_fdkaacenc_class_init (GstFdkAacEncClass * klass)
 556 {
 557   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 558   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 559   GstAudioEncoderClass *base_class = GST_AUDIO_ENCODER_CLASS (klass);
 560
 561   object_class->set_property = GST_DEBUG_FUNCPTR (gst_fdkaacenc_set_property);
 562   object_class->get_property = GST_DEBUG_FUNCPTR (gst_fdkaacenc_get_property);
 563
 564   base_class->start = GST_DEBUG_FUNCPTR (gst_fdkaacenc_start);
 565   base_class->stop = GST_DEBUG_FUNCPTR (gst_fdkaacenc_stop);
 566   base_class->set_format = GST_DEBUG_FUNCPTR (gst_fdkaacenc_set_format);
 567   base_class->getcaps = GST_DEBUG_FUNCPTR (gst_fdkaacenc_get_caps);
 568   base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_fdkaacenc_handle_frame);
 569   base_class->flush = GST_DEBUG_FUNCPTR (gst_fdkaacenc_flush);
 570
 571   g_object_class_install_property (object_class, PROP_BITRATE,
 572       g_param_spec_int ("bitrate",
 573           "Bitrate",
 574           "Target Audio Bitrate (0 = fixed value based on "
 575           " sample rate and channel count)",
 576           0, G_MAXINT, DEFAULT_BITRATE,
 577           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 578
 579   gst_element_class_add_static_pad_template (element_class, &sink_template);
 580   gst_element_class_add_static_pad_template (element_class, &src_template);
 581
 582   gst_element_class_set_static_metadata (element_class, "FDK AAC audio encoder",
 583       "Codec/Encoder/Audio/Converter", "FDK AAC audio encoder",
 584       "Sebastian Dröge <sebastian@centricular.com>");
 585
 586   GST_DEBUG_CATEGORY_INIT (gst_fdkaacenc_debug, "fdkaacenc", 0,
 587       "fdkaac encoder");
 588 }