omx/gstomxaacenc.c

   1 /*
   2  * Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
   3  *   Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation
   8  * version 2.1 of the License.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <gst/gst.h>
  26
  27 #include "gstomxaacenc.h"
  28
  29 GST_DEBUG_CATEGORY_STATIC (gst_omx_aac_enc_debug_category);
  30 #define GST_CAT_DEFAULT gst_omx_aac_enc_debug_category
  31
  32 /* prototypes */
  33 static void gst_omx_aac_enc_set_property (GObject * object, guint prop_id,
  34     const GValue * value, GParamSpec * pspec);
  35 static void gst_omx_aac_enc_get_property (GObject * object, guint prop_id,
  36     GValue * value, GParamSpec * pspec);
  37 static gboolean gst_omx_aac_enc_set_format (GstOMXAudioEnc * enc,
  38     GstOMXPort * port, GstAudioInfo * info);
  39 static GstCaps *gst_omx_aac_enc_get_caps (GstOMXAudioEnc * enc,
  40     GstOMXPort * port, GstAudioInfo * info);
  41 static guint gst_omx_aac_enc_get_num_samples (GstOMXAudioEnc * enc,
  42     GstOMXPort * port, GstAudioInfo * info, GstOMXBuffer * buf);
  43
  44 enum
  45 {
  46   PROP_0,
  47   PROP_BITRATE,
  48   PROP_AAC_TOOLS,
  49   PROP_AAC_ERROR_RESILIENCE_TOOLS
  50 };
  51
  52 #define DEFAULT_BITRATE (128000)
  53 #define DEFAULT_AAC_TOOLS (OMX_AUDIO_AACToolMS | OMX_AUDIO_AACToolIS | OMX_AUDIO_AACToolTNS | OMX_AUDIO_AACToolPNS | OMX_AUDIO_AACToolLTP)
  54 #define DEFAULT_AAC_ER_TOOLS (OMX_AUDIO_AACERNone)
  55
  56 #define GST_TYPE_OMX_AAC_TOOLS (gst_omx_aac_tools_get_type ())
  57 static GType
  58 gst_omx_aac_tools_get_type (void)
  59 {
  60   static gsize id = 0;
  61   static const GFlagsValue values[] = {
  62     {OMX_AUDIO_AACToolMS, "Mid/side joint coding", "ms"},
  63     {OMX_AUDIO_AACToolIS, "Intensity stereo", "is"},
  64     {OMX_AUDIO_AACToolTNS, "Temporal noise shaping", "tns"},
  65     {OMX_AUDIO_AACToolPNS, "Perceptual noise substitution", "pns"},
  66     {OMX_AUDIO_AACToolLTP, "Long term prediction", "ltp"},
  67     {0, NULL, NULL}
  68   };
  69
  70   if (g_once_init_enter (&id)) {
  71     GType tmp = g_flags_register_static ("GstOMXAACTools", values);
  72     g_once_init_leave (&id, tmp);
  73   }
  74
  75   return (GType) id;
  76 }
  77
  78 #define GST_TYPE_OMX_AAC_ER_TOOLS (gst_omx_aac_er_tools_get_type ())
  79 static GType
  80 gst_omx_aac_er_tools_get_type (void)
  81 {
  82   static gsize id = 0;
  83   static const GFlagsValue values[] = {
  84     {OMX_AUDIO_AACERVCB11, "Virtual code books", "vcb11"},
  85     {OMX_AUDIO_AACERRVLC, "Reversible variable length coding", "rvlc"},
  86     {OMX_AUDIO_AACERHCR, "Huffman codeword reordering", "hcr"},
  87     {0, NULL, NULL}
  88   };
  89
  90   if (g_once_init_enter (&id)) {
  91     GType tmp = g_flags_register_static ("GstOMXAACERTools", values);
  92     g_once_init_leave (&id, tmp);
  93   }
  94
  95   return (GType) id;
  96 }
  97
  98 /* class initialization */
  99
 100 #define DEBUG_INIT \
 101   GST_DEBUG_CATEGORY_INIT (gst_omx_aac_enc_debug_category, "omxaacenc", 0, \
 102       "debug category for gst-omx audio encoder base class");
 103
 104 G_DEFINE_TYPE_WITH_CODE (GstOMXAACEnc, gst_omx_aac_enc,
 105     GST_TYPE_OMX_AUDIO_ENC, DEBUG_INIT);
 106
 107
 108 static void
 109 gst_omx_aac_enc_class_init (GstOMXAACEncClass * klass)
 110 {
 111   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 112   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 113   GstOMXAudioEncClass *audioenc_class = GST_OMX_AUDIO_ENC_CLASS (klass);
 114
 115   gobject_class->set_property = gst_omx_aac_enc_set_property;
 116   gobject_class->get_property = gst_omx_aac_enc_get_property;
 117
 118   g_object_class_install_property (gobject_class, PROP_BITRATE,
 119       g_param_spec_uint ("bitrate", "Bitrate",
 120           "Bitrate",
 121           0, G_MAXUINT, DEFAULT_BITRATE,
 122           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 123           GST_PARAM_MUTABLE_READY));
 124
 125   g_object_class_install_property (gobject_class, PROP_AAC_TOOLS,
 126       g_param_spec_flags ("aac-tools", "AAC Tools",
 127           "Allowed AAC tools",
 128           GST_TYPE_OMX_AAC_TOOLS,
 129           DEFAULT_AAC_TOOLS,
 130           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 131           GST_PARAM_MUTABLE_READY));
 132
 133   g_object_class_install_property (gobject_class,
 134       PROP_AAC_ERROR_RESILIENCE_TOOLS,
 135       g_param_spec_flags ("aac-error-resilience-tools",
 136           "AAC Error Resilience Tools", "Allowed AAC error resilience tools",
 137           GST_TYPE_OMX_AAC_ER_TOOLS, DEFAULT_AAC_ER_TOOLS,
 138           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 139           GST_PARAM_MUTABLE_READY));
 140
 141   audioenc_class->set_format = GST_DEBUG_FUNCPTR (gst_omx_aac_enc_set_format);
 142   audioenc_class->get_caps = GST_DEBUG_FUNCPTR (gst_omx_aac_enc_get_caps);
 143   audioenc_class->get_num_samples =
 144       GST_DEBUG_FUNCPTR (gst_omx_aac_enc_get_num_samples);
 145
 146   audioenc_class->cdata.default_src_template_caps = "audio/mpeg, "
 147       "mpegversion=(int){2, 4}, "
 148       "stream-format=(string){raw, adts, adif, loas, latm}";
 149
 150
 151   gst_element_class_set_static_metadata (element_class,
 152       "OpenMAX AAC Audio Encoder",
 153       "Codec/Encoder/Audio/Hardware",
 154       "Encode AAC audio streams",
 155       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 156
 157   gst_omx_set_default_role (&audioenc_class->cdata, "audio_encoder.aac");
 158 }
 159
 160 static void
 161 gst_omx_aac_enc_init (GstOMXAACEnc * self)
 162 {
 163   self->bitrate = DEFAULT_BITRATE;
 164   self->aac_tools = DEFAULT_AAC_TOOLS;
 165   self->aac_er_tools = DEFAULT_AAC_ER_TOOLS;
 166 }
 167
 168 static void
 169 gst_omx_aac_enc_set_property (GObject * object, guint prop_id,
 170     const GValue * value, GParamSpec * pspec)
 171 {
 172   GstOMXAACEnc *self = GST_OMX_AAC_ENC (object);
 173
 174   switch (prop_id) {
 175     case PROP_BITRATE:
 176       self->bitrate = g_value_get_uint (value);
 177       break;
 178     case PROP_AAC_TOOLS:
 179       self->aac_tools = g_value_get_flags (value);
 180       break;
 181     case PROP_AAC_ERROR_RESILIENCE_TOOLS:
 182       self->aac_er_tools = g_value_get_flags (value);
 183       break;
 184     default:
 185       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 186       break;
 187   }
 188 }
 189
 190 static void
 191 gst_omx_aac_enc_get_property (GObject * object, guint prop_id, GValue * value,
 192     GParamSpec * pspec)
 193 {
 194   GstOMXAACEnc *self = GST_OMX_AAC_ENC (object);
 195
 196   switch (prop_id) {
 197     case PROP_BITRATE:
 198       g_value_set_uint (value, self->bitrate);
 199       break;
 200     case PROP_AAC_TOOLS:
 201       g_value_set_flags (value, self->aac_tools);
 202       break;
 203     case PROP_AAC_ERROR_RESILIENCE_TOOLS:
 204       g_value_set_flags (value, self->aac_er_tools);
 205       break;
 206     default:
 207       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 208       break;
 209   }
 210 }
 211
 212 static gboolean
 213 gst_omx_aac_enc_set_format (GstOMXAudioEnc * enc, GstOMXPort * port,
 214     GstAudioInfo * info)
 215 {
 216   GstOMXAACEnc *self = GST_OMX_AAC_ENC (enc);
 217   OMX_AUDIO_PARAM_AACPROFILETYPE aac_profile;
 218   GstCaps *peercaps;
 219   OMX_ERRORTYPE err;
 220
 221   GST_OMX_INIT_STRUCT (&aac_profile);
 222   aac_profile.nPortIndex = enc->enc_out_port->index;
 223
 224   err =
 225       gst_omx_component_get_parameter (enc->enc, OMX_IndexParamAudioAac,
 226       &aac_profile);
 227   if (err != OMX_ErrorNone) {
 228     GST_ERROR_OBJECT (self,
 229         "Failed to get AAC parameters from component: %s (0x%08x)",
 230         gst_omx_error_to_string (err), err);
 231     return FALSE;
 232   }
 233
 234   peercaps = gst_pad_peer_query_caps (GST_AUDIO_ENCODER_SRC_PAD (self),
 235       gst_pad_get_pad_template_caps (GST_AUDIO_ENCODER_SRC_PAD (self)));
 236   if (peercaps) {
 237     GstStructure *s;
 238     gint mpegversion = 0;
 239     const gchar *profile_string, *stream_format_string;
 240
 241     if (gst_caps_is_empty (peercaps)) {
 242       gst_caps_unref (peercaps);
 243       GST_ERROR_OBJECT (self, "Empty caps");
 244       return FALSE;
 245     }
 246
 247     s = gst_caps_get_structure (peercaps, 0);
 248
 249     if (gst_structure_get_int (s, "mpegversion", &mpegversion)) {
 250       profile_string =
 251           gst_structure_get_string (s,
 252           ((mpegversion == 2) ? "profile" : "base-profile"));
 253
 254       if (profile_string) {
 255         if (g_str_equal (profile_string, "main")) {
 256           aac_profile.eAACProfile = OMX_AUDIO_AACObjectMain;
 257         } else if (g_str_equal (profile_string, "lc")) {
 258           aac_profile.eAACProfile = OMX_AUDIO_AACObjectLC;
 259         } else if (g_str_equal (profile_string, "ssr")) {
 260           aac_profile.eAACProfile = OMX_AUDIO_AACObjectSSR;
 261         } else if (g_str_equal (profile_string, "ltp")) {
 262           aac_profile.eAACProfile = OMX_AUDIO_AACObjectLTP;
 263         } else {
 264           GST_ERROR_OBJECT (self, "Unsupported profile '%s'", profile_string);
 265           gst_caps_unref (peercaps);
 266           return FALSE;
 267         }
 268       }
 269     }
 270
 271     stream_format_string = gst_structure_get_string (s, "stream-format");
 272     if (stream_format_string) {
 273       if (g_str_equal (stream_format_string, "raw")) {
 274         aac_profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
 275       } else if (g_str_equal (stream_format_string, "adts")) {
 276         if (mpegversion == 2) {
 277           aac_profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP2ADTS;
 278         } else {
 279           aac_profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS;
 280         }
 281       } else if (g_str_equal (stream_format_string, "loas")) {
 282         aac_profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4LOAS;
 283       } else if (g_str_equal (stream_format_string, "latm")) {
 284         aac_profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4LATM;
 285       } else if (g_str_equal (stream_format_string, "adif")) {
 286         aac_profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatADIF;
 287       } else {
 288         GST_ERROR_OBJECT (self, "Unsupported stream-format '%s'",
 289             stream_format_string);
 290         gst_caps_unref (peercaps);
 291         return FALSE;
 292       }
 293     }
 294
 295     gst_caps_unref (peercaps);
 296
 297     aac_profile.nSampleRate = info->rate;
 298     aac_profile.nChannels = info->channels;
 299   }
 300
 301   aac_profile.nAACtools = self->aac_tools;
 302   aac_profile.nAACERtools = self->aac_er_tools;
 303
 304   aac_profile.nBitRate = self->bitrate;
 305
 306   err =
 307       gst_omx_component_set_parameter (enc->enc, OMX_IndexParamAudioAac,
 308       &aac_profile);
 309   if (err != OMX_ErrorNone) {
 310     GST_ERROR_OBJECT (self, "Error setting AAC parameters: %s (0x%08x)",
 311         gst_omx_error_to_string (err), err);
 312     return FALSE;
 313   }
 314
 315   return TRUE;
 316 }
 317
 318 typedef enum adts_sample_index__
 319 {
 320   ADTS_SAMPLE_INDEX_96000 = 0x0,
 321   ADTS_SAMPLE_INDEX_88200,
 322   ADTS_SAMPLE_INDEX_64000,
 323   ADTS_SAMPLE_INDEX_48000,
 324   ADTS_SAMPLE_INDEX_44100,
 325   ADTS_SAMPLE_INDEX_32000,
 326   ADTS_SAMPLE_INDEX_24000,
 327   ADTS_SAMPLE_INDEX_22050,
 328   ADTS_SAMPLE_INDEX_16000,
 329   ADTS_SAMPLE_INDEX_12000,
 330   ADTS_SAMPLE_INDEX_11025,
 331   ADTS_SAMPLE_INDEX_8000,
 332   ADTS_SAMPLE_INDEX_7350,
 333   ADTS_SAMPLE_INDEX_MAX
 334 } adts_sample_index;
 335
 336 static adts_sample_index
 337 map_adts_sample_index (guint32 srate)
 338 {
 339   adts_sample_index ret;
 340
 341   switch (srate) {
 342
 343     case 96000:
 344       ret = ADTS_SAMPLE_INDEX_96000;
 345       break;
 346     case 88200:
 347       ret = ADTS_SAMPLE_INDEX_88200;
 348       break;
 349     case 64000:
 350       ret = ADTS_SAMPLE_INDEX_64000;
 351       break;
 352     case 48000:
 353       ret = ADTS_SAMPLE_INDEX_48000;
 354       break;
 355     case 44100:
 356       ret = ADTS_SAMPLE_INDEX_44100;
 357       break;
 358     case 32000:
 359       ret = ADTS_SAMPLE_INDEX_32000;
 360       break;
 361     case 24000:
 362       ret = ADTS_SAMPLE_INDEX_24000;
 363       break;
 364     case 22050:
 365       ret = ADTS_SAMPLE_INDEX_22050;
 366       break;
 367     case 16000:
 368       ret = ADTS_SAMPLE_INDEX_16000;
 369       break;
 370     case 12000:
 371       ret = ADTS_SAMPLE_INDEX_12000;
 372       break;
 373     case 11025:
 374       ret = ADTS_SAMPLE_INDEX_11025;
 375       break;
 376     case 8000:
 377       ret = ADTS_SAMPLE_INDEX_8000;
 378       break;
 379     case 7350:
 380       ret = ADTS_SAMPLE_INDEX_7350;
 381       break;
 382     default:
 383       ret = ADTS_SAMPLE_INDEX_44100;
 384       break;
 385   }
 386   return ret;
 387 }
 388
 389 static GstCaps *
 390 gst_omx_aac_enc_get_caps (GstOMXAudioEnc * enc, GstOMXPort * port,
 391     GstAudioInfo * info)
 392 {
 393   GstCaps *caps;
 394   OMX_ERRORTYPE err;
 395   OMX_AUDIO_PARAM_AACPROFILETYPE aac_profile;
 396   gint mpegversion = 4;
 397   const gchar *stream_format = NULL, *profile = NULL;
 398
 399   GST_OMX_INIT_STRUCT (&aac_profile);
 400   aac_profile.nPortIndex = enc->enc_out_port->index;
 401
 402   err =
 403       gst_omx_component_get_parameter (enc->enc, OMX_IndexParamAudioAac,
 404       &aac_profile);
 405   if (err != OMX_ErrorNone) {
 406     GST_ERROR_OBJECT (enc,
 407         "Failed to get AAC parameters from component: %s (0x%08x)",
 408         gst_omx_error_to_string (err), err);
 409     return NULL;
 410   }
 411
 412   switch (aac_profile.eAACProfile) {
 413     case OMX_AUDIO_AACObjectMain:
 414       profile = "main";
 415       break;
 416     case OMX_AUDIO_AACObjectLC:
 417       profile = "lc";
 418       break;
 419     case OMX_AUDIO_AACObjectSSR:
 420       profile = "ssr";
 421       break;
 422     case OMX_AUDIO_AACObjectLTP:
 423       profile = "ltp";
 424       break;
 425     case OMX_AUDIO_AACObjectHE:
 426     case OMX_AUDIO_AACObjectScalable:
 427     case OMX_AUDIO_AACObjectERLC:
 428     case OMX_AUDIO_AACObjectLD:
 429     case OMX_AUDIO_AACObjectHE_PS:
 430     default:
 431       GST_ERROR_OBJECT (enc, "Unsupported profile %d", aac_profile.eAACProfile);
 432       break;
 433   }
 434
 435   switch (aac_profile.eAACStreamFormat) {
 436     case OMX_AUDIO_AACStreamFormatMP2ADTS:
 437       mpegversion = 2;
 438       stream_format = "adts";
 439       break;
 440     case OMX_AUDIO_AACStreamFormatMP4ADTS:
 441       mpegversion = 4;
 442       stream_format = "adts";
 443       break;
 444     case OMX_AUDIO_AACStreamFormatMP4LOAS:
 445       mpegversion = 4;
 446       stream_format = "loas";
 447       break;
 448     case OMX_AUDIO_AACStreamFormatMP4LATM:
 449       mpegversion = 4;
 450       stream_format = "latm";
 451       break;
 452     case OMX_AUDIO_AACStreamFormatADIF:
 453       mpegversion = 4;
 454       stream_format = "adif";
 455       break;
 456     case OMX_AUDIO_AACStreamFormatRAW:
 457       mpegversion = 4;
 458       stream_format = "raw";
 459       break;
 460     case OMX_AUDIO_AACStreamFormatMP4FF:
 461     default:
 462       GST_ERROR_OBJECT (enc, "Unsupported stream-format %u",
 463           aac_profile.eAACStreamFormat);
 464       break;
 465   }
 466
 467   caps = gst_caps_new_empty_simple ("audio/mpeg");
 468
 469   if (mpegversion != 0)
 470     gst_caps_set_simple (caps, "mpegversion", G_TYPE_INT, mpegversion,
 471         "stream-format", G_TYPE_STRING, stream_format, NULL);
 472   if (profile != NULL && (mpegversion == 2 || mpegversion == 4))
 473     gst_caps_set_simple (caps, "profile", G_TYPE_STRING, profile, NULL);
 474   if (profile != NULL && mpegversion == 4)
 475     gst_caps_set_simple (caps, "base-profile", G_TYPE_STRING, profile, NULL);
 476   if (aac_profile.nChannels != 0)
 477     gst_caps_set_simple (caps, "channels", G_TYPE_INT, aac_profile.nChannels,
 478         NULL);
 479   if (aac_profile.nSampleRate != 0)
 480     gst_caps_set_simple (caps, "rate", G_TYPE_INT, aac_profile.nSampleRate,
 481         NULL);
 482
 483   if (aac_profile.eAACStreamFormat == OMX_AUDIO_AACStreamFormatRAW) {
 484     GstBuffer *codec_data;
 485     adts_sample_index sr_idx;
 486     GstMapInfo map = GST_MAP_INFO_INIT;
 487
 488     codec_data = gst_buffer_new_and_alloc (2);
 489     gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
 490     sr_idx = map_adts_sample_index (aac_profile.nSampleRate);
 491     map.data[0] = ((aac_profile.eAACProfile & 0x1F) << 3) |
 492         ((sr_idx & 0xE) >> 1);
 493     map.data[1] = ((sr_idx & 0x1) << 7) | ((aac_profile.nChannels & 0xF) << 3);
 494     gst_buffer_unmap (codec_data, &map);
 495
 496     GST_DEBUG_OBJECT (enc, "setting new codec_data");
 497     gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
 498
 499     gst_buffer_unref (codec_data);
 500   }
 501   return caps;
 502
 503 }
 504
 505 static guint
 506 gst_omx_aac_enc_get_num_samples (GstOMXAudioEnc * enc, GstOMXPort * port,
 507     GstAudioInfo * info, GstOMXBuffer * buf)
 508 {
 509   /* FIXME: Depends on the profile at least */
 510   return 1024;
 511 }