gst/audioparsers/gstaacparse.c

   1 /* GStreamer AAC parser plugin
   2  * Copyright (C) 2008 Nokia Corporation. All rights reserved.
   3  *
   4  * Contact: Stefan Kost <stefan.kost@nokia.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 /**
  23  * SECTION:element-aacparse
  24  * @short_description: AAC parser
  25  * @see_also: #GstAmrParse
  26  *
  27  * This is an AAC parser which handles both ADIF and ADTS stream formats.
  28  *
  29  * As ADIF format is not framed, it is not seekable and stream duration cannot
  30  * be determined either. However, ADTS format AAC clips can be seeked, and parser
  31  * can also estimate playback position and clip duration.
  32  *
  33  * <refsect2>
  34  * <title>Example launch line</title>
  35  * |[
  36  * gst-launch-1.0 filesrc location=abc.aac ! aacparse ! faad ! audioresample ! audioconvert ! alsasink
  37  * ]|
  38  * </refsect2>
  39  */
  40
  41 #ifdef HAVE_CONFIG_H
  42 #include "config.h"
  43 #endif
  44
  45 #include <string.h>
  46
  47 #include <gst/base/gstbitreader.h>
  48 #include <gst/pbutils/pbutils.h>
  49 #include "gstaacparse.h"
  50
  51
  52 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  53     GST_PAD_SRC,
  54     GST_PAD_ALWAYS,
  55     GST_STATIC_CAPS ("audio/mpeg, "
  56         "framed = (boolean) true, " "mpegversion = (int) { 2, 4 }, "
  57         "stream-format = (string) { raw, adts, adif, loas };"));
  58
  59 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  60     GST_PAD_SINK,
  61     GST_PAD_ALWAYS,
  62     GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) { 2, 4 };"));
  63
  64 GST_DEBUG_CATEGORY_STATIC (aacparse_debug);
  65 #define GST_CAT_DEFAULT aacparse_debug
  66
  67
  68 #define ADIF_MAX_SIZE 40        /* Should be enough */
  69 #define ADTS_MAX_SIZE 10        /* Should be enough */
  70 #define LOAS_MAX_SIZE 3         /* Should be enough */
  71
  72 #define ADTS_HEADERS_LENGTH 7UL /* Total byte-length of fixed and variable
  73                                    headers prepended during raw to ADTS
  74                                    conversion */
  75
  76 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
  77
  78 static const gint loas_sample_rate_table[16] = {
  79   96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
  80   16000, 12000, 11025, 8000, 7350, 0, 0, 0
  81 };
  82
  83 static const gint loas_channels_table[16] = {
  84   0, 1, 2, 3, 4, 5, 6, 8,
  85   0, 0, 0, 7, 8, 0, 8, 0
  86 };
  87
  88 static gboolean gst_aac_parse_start (GstBaseParse * parse);
  89 static gboolean gst_aac_parse_stop (GstBaseParse * parse);
  90
  91 static gboolean gst_aac_parse_sink_setcaps (GstBaseParse * parse,
  92     GstCaps * caps);
  93 static GstCaps *gst_aac_parse_sink_getcaps (GstBaseParse * parse,
  94     GstCaps * filter);
  95
  96 static GstFlowReturn gst_aac_parse_handle_frame (GstBaseParse * parse,
  97     GstBaseParseFrame * frame, gint * skipsize);
  98 static GstFlowReturn gst_aac_parse_pre_push_frame (GstBaseParse * parse,
  99     GstBaseParseFrame * frame);
 100 static gboolean gst_aac_parse_src_event (GstBaseParse * parse,
 101     GstEvent * event);
 102
 103 #define gst_aac_parse_parent_class parent_class
 104 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
 105
 106 /**
 107  * gst_aac_parse_class_init:
 108  * @klass: #GstAacParseClass.
 109  *
 110  */
 111 static void
 112 gst_aac_parse_class_init (GstAacParseClass * klass)
 113 {
 114   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 115   GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
 116
 117   GST_DEBUG_CATEGORY_INIT (aacparse_debug, "aacparse", 0,
 118       "AAC audio stream parser");
 119
 120   gst_element_class_add_static_pad_template (element_class, &sink_template);
 121   gst_element_class_add_static_pad_template (element_class, &src_template);
 122
 123   gst_element_class_set_static_metadata (element_class,
 124       "AAC audio stream parser", "Codec/Parser/Audio",
 125       "Advanced Audio Coding parser", "Stefan Kost <stefan.kost@nokia.com>");
 126
 127   parse_class->start = GST_DEBUG_FUNCPTR (gst_aac_parse_start);
 128   parse_class->stop = GST_DEBUG_FUNCPTR (gst_aac_parse_stop);
 129   parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_setcaps);
 130   parse_class->get_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_getcaps);
 131   parse_class->handle_frame = GST_DEBUG_FUNCPTR (gst_aac_parse_handle_frame);
 132   parse_class->pre_push_frame =
 133       GST_DEBUG_FUNCPTR (gst_aac_parse_pre_push_frame);
 134   parse_class->src_event = GST_DEBUG_FUNCPTR (gst_aac_parse_src_event);
 135 }
 136
 137
 138 /**
 139  * gst_aac_parse_init:
 140  * @aacparse: #GstAacParse.
 141  * @klass: #GstAacParseClass.
 142  *
 143  */
 144 static void
 145 gst_aac_parse_init (GstAacParse * aacparse)
 146 {
 147   GST_DEBUG ("initialized");
 148   GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (aacparse));
 149   GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (aacparse));
 150
 151   aacparse->last_parsed_sample_rate = 0;
 152   aacparse->last_parsed_channels = 0;
 153 }
 154
 155
 156 /**
 157  * gst_aac_parse_set_src_caps:
 158  * @aacparse: #GstAacParse.
 159  * @sink_caps: (proposed) caps of sink pad
 160  *
 161  * Set source pad caps according to current knowledge about the
 162  * audio stream.
 163  *
 164  * Returns: TRUE if caps were successfully set.
 165  */
 166 static gboolean
 167 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
 168 {
 169   GstStructure *s;
 170   GstCaps *src_caps = NULL, *allowed;
 171   gboolean res = FALSE;
 172   const gchar *stream_format;
 173   guint8 codec_data[2];
 174   guint16 codec_data_data;
 175   gint sample_rate_idx;
 176
 177   GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
 178   if (sink_caps)
 179     src_caps = gst_caps_copy (sink_caps);
 180   else
 181     src_caps = gst_caps_new_empty_simple ("audio/mpeg");
 182
 183   gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
 184       "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
 185
 186   aacparse->output_header_type = aacparse->header_type;
 187   switch (aacparse->header_type) {
 188     case DSPAAC_HEADER_NONE:
 189       stream_format = "raw";
 190       break;
 191     case DSPAAC_HEADER_ADTS:
 192       stream_format = "adts";
 193       break;
 194     case DSPAAC_HEADER_ADIF:
 195       stream_format = "adif";
 196       break;
 197     case DSPAAC_HEADER_LOAS:
 198       stream_format = "loas";
 199       break;
 200     default:
 201       stream_format = NULL;
 202   }
 203
 204   /* Generate codec data to be able to set profile/level on the caps */
 205   sample_rate_idx =
 206       gst_codec_utils_aac_get_index_from_sample_rate (aacparse->sample_rate);
 207   if (sample_rate_idx < 0)
 208     goto not_a_known_rate;
 209   codec_data_data =
 210       (aacparse->object_type << 11) |
 211       (sample_rate_idx << 7) | (aacparse->channels << 3);
 212   GST_WRITE_UINT16_BE (codec_data, codec_data_data);
 213   gst_codec_utils_aac_caps_set_level_and_profile (src_caps, codec_data, 2);
 214
 215   s = gst_caps_get_structure (src_caps, 0);
 216   if (aacparse->sample_rate > 0)
 217     gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
 218   if (aacparse->channels > 0)
 219     gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
 220   if (stream_format)
 221     gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
 222
 223   allowed = gst_pad_get_allowed_caps (GST_BASE_PARSE (aacparse)->srcpad);
 224   if (allowed && !gst_caps_can_intersect (src_caps, allowed)) {
 225     GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
 226         "Caps can not intersect");
 227     if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 228       GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
 229           "Input is ADTS, trying raw");
 230       gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "raw",
 231           NULL);
 232       if (gst_caps_can_intersect (src_caps, allowed)) {
 233         GstBuffer *codec_data_buffer;
 234
 235         GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
 236             "Caps can intersect, we will drop the ADTS layer");
 237         aacparse->output_header_type = DSPAAC_HEADER_NONE;
 238
 239         /* The codec_data data is according to AudioSpecificConfig,
 240            ISO/IEC 14496-3, 1.6.2.1 */
 241         codec_data_buffer = gst_buffer_new_and_alloc (2);
 242         gst_buffer_fill (codec_data_buffer, 0, codec_data, 2);
 243         gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER,
 244             codec_data_buffer, NULL);
 245       }
 246     } else if (aacparse->header_type == DSPAAC_HEADER_NONE) {
 247       GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
 248           "Input is raw, trying ADTS");
 249       gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adts",
 250           NULL);
 251       if (gst_caps_can_intersect (src_caps, allowed)) {
 252         GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
 253             "Caps can intersect, we will prepend ADTS headers");
 254         aacparse->output_header_type = DSPAAC_HEADER_ADTS;
 255       }
 256     }
 257   }
 258   if (allowed)
 259     gst_caps_unref (allowed);
 260
 261   aacparse->last_parsed_channels = 0;
 262   aacparse->last_parsed_sample_rate = 0;
 263
 264   GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
 265
 266   res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
 267   gst_caps_unref (src_caps);
 268   return res;
 269
 270 not_a_known_rate:
 271   GST_ERROR_OBJECT (aacparse, "Not a known sample rate: %d",
 272       aacparse->sample_rate);
 273   gst_caps_unref (src_caps);
 274   return FALSE;
 275 }
 276
 277
 278 /**
 279  * gst_aac_parse_sink_setcaps:
 280  * @sinkpad: GstPad
 281  * @caps: GstCaps
 282  *
 283  * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
 284  *
 285  * Returns: TRUE on success.
 286  */
 287 static gboolean
 288 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
 289 {
 290   GstAacParse *aacparse;
 291   GstStructure *structure;
 292   gchar *caps_str;
 293   const GValue *value;
 294
 295   aacparse = GST_AAC_PARSE (parse);
 296   structure = gst_caps_get_structure (caps, 0);
 297   caps_str = gst_caps_to_string (caps);
 298
 299   GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
 300   g_free (caps_str);
 301
 302   /* This is needed at least in case of RTP
 303    * Parses the codec_data information to get ObjectType,
 304    * number of channels and samplerate */
 305   value = gst_structure_get_value (structure, "codec_data");
 306   if (value) {
 307     GstBuffer *buf = gst_value_get_buffer (value);
 308
 309     if (buf && gst_buffer_get_size (buf) >= 2) {
 310       GstMapInfo map;
 311       guint sr_idx;
 312
 313       if (!gst_buffer_map (buf, &map, GST_MAP_READ))
 314         return FALSE;
 315
 316       sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
 317       aacparse->object_type = (map.data[0] & 0xf8) >> 3;
 318       aacparse->sample_rate =
 319           gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
 320       aacparse->channels = (map.data[1] & 0x78) >> 3;
 321       if (aacparse->channels == 7)
 322         aacparse->channels = 8;
 323       else if (aacparse->channels == 11)
 324         aacparse->channels = 7;
 325       else if (aacparse->channels == 12 || aacparse->channels == 14)
 326         aacparse->channels = 8;
 327       aacparse->header_type = DSPAAC_HEADER_NONE;
 328       aacparse->mpegversion = 4;
 329       aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
 330       gst_buffer_unmap (buf, &map);
 331
 332       GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
 333           "samples=%d", aacparse->object_type, aacparse->sample_rate,
 334           aacparse->channels, aacparse->frame_samples);
 335
 336       /* arrange for metadata and get out of the way */
 337       gst_aac_parse_set_src_caps (aacparse, caps);
 338       if (aacparse->header_type == aacparse->output_header_type)
 339         gst_base_parse_set_passthrough (parse, TRUE);
 340     } else {
 341       return FALSE;
 342     }
 343
 344     /* caps info overrides */
 345     gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
 346     gst_structure_get_int (structure, "channels", &aacparse->channels);
 347   } else {
 348     const gchar *stream_format =
 349         gst_structure_get_string (structure, "stream-format");
 350
 351     if (g_strcmp0 (stream_format, "raw") == 0) {
 352       GST_ERROR_OBJECT (parse, "Need codec_data for raw AAC");
 353       return FALSE;
 354     } else {
 355       aacparse->sample_rate = 0;
 356       aacparse->channels = 0;
 357       aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
 358       gst_base_parse_set_passthrough (parse, FALSE);
 359     }
 360   }
 361   return TRUE;
 362 }
 363
 364
 365 /**
 366  * gst_aac_parse_adts_get_frame_len:
 367  * @data: block of data containing an ADTS header.
 368  *
 369  * This function calculates ADTS frame length from the given header.
 370  *
 371  * Returns: size of the ADTS frame.
 372  */
 373 static inline guint
 374 gst_aac_parse_adts_get_frame_len (const guint8 * data)
 375 {
 376   return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
 377 }
 378
 379
 380 /**
 381  * gst_aac_parse_check_adts_frame:
 382  * @aacparse: #GstAacParse.
 383  * @data: Data to be checked.
 384  * @avail: Amount of data passed.
 385  * @framesize: If valid ADTS frame was found, this will be set to tell the
 386  *             found frame size in bytes.
 387  * @needed_data: If frame was not found, this may be set to tell how much
 388  *               more data is needed in the next round to detect the frame
 389  *               reliably. This may happen when a frame header candidate
 390  *               is found but it cannot be guaranteed to be the header without
 391  *               peeking the following data.
 392  *
 393  * Check if the given data contains contains ADTS frame. The algorithm
 394  * will examine ADTS frame header and calculate the frame size. Also, another
 395  * consecutive ADTS frame header need to be present after the found frame.
 396  * Otherwise the data is not considered as a valid ADTS frame. However, this
 397  * "extra check" is omitted when EOS has been received. In this case it is
 398  * enough when data[0] contains a valid ADTS header.
 399  *
 400  * This function may set the #needed_data to indicate that a possible frame
 401  * candidate has been found, but more data (#needed_data bytes) is needed to
 402  * be absolutely sure. When this situation occurs, FALSE will be returned.
 403  *
 404  * When a valid frame is detected, this function will use
 405  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 406  * to set the needed bytes for next frame.This way next data chunk is already
 407  * of correct size.
 408  *
 409  * Returns: TRUE if the given data contains a valid ADTS header.
 410  */
 411 static gboolean
 412 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
 413     const guint8 * data, const guint avail, gboolean drain,
 414     guint * framesize, guint * needed_data)
 415 {
 416   guint crc_size;
 417
 418   *needed_data = 0;
 419
 420   /* Absolute minimum to perform the ADTS syncword,
 421      layer and sampling frequency tests */
 422   if (G_UNLIKELY (avail < 3)) {
 423     *needed_data = 3;
 424     return FALSE;
 425   }
 426
 427   /* Syncword and layer tests */
 428   if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
 429
 430     /* Sampling frequency test */
 431     if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
 432       return FALSE;
 433
 434     /* This looks like an ADTS frame header but
 435        we need at least 6 bytes to proceed */
 436     if (G_UNLIKELY (avail < 6)) {
 437       *needed_data = 6;
 438       return FALSE;
 439     }
 440
 441     *framesize = gst_aac_parse_adts_get_frame_len (data);
 442
 443     /* If frame has CRC, it needs 2 bytes
 444        for it at the end of the header */
 445     crc_size = (data[1] & 0x01) ? 0 : 2;
 446
 447     /* CRC size test */
 448     if (*framesize < 7 + crc_size) {
 449       *needed_data = 7 + crc_size;
 450       return FALSE;
 451     }
 452
 453     /* In EOS mode this is enough. No need to examine the data further.
 454        We also relax the check when we have sync, on the assumption that
 455        if we're not looking at random data, we have a much higher chance
 456        to get the correct sync, and this avoids losing two frames when
 457        a single bit corruption happens. */
 458     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 459       return TRUE;
 460     }
 461
 462     if (*framesize + ADTS_MAX_SIZE > avail) {
 463       /* We have found a possible frame header candidate, but can't be
 464          sure since we don't have enough data to check the next frame */
 465       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 466           *framesize + ADTS_MAX_SIZE, avail);
 467       *needed_data = *framesize + ADTS_MAX_SIZE;
 468       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 469           *framesize + ADTS_MAX_SIZE);
 470       return FALSE;
 471     }
 472
 473     if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
 474       guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
 475
 476       GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
 477       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 478           nextlen + ADTS_MAX_SIZE);
 479       return TRUE;
 480     }
 481   }
 482   return FALSE;
 483 }
 484
 485 static gboolean
 486 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
 487     guint32 * value)
 488 {
 489   guint8 bytes, i, byte;
 490
 491   *value = 0;
 492   if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
 493     return FALSE;
 494   for (i = 0; i <= bytes; ++i) {
 495     *value <<= 8;
 496     if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
 497       return FALSE;
 498     *value += byte;
 499   }
 500   return TRUE;
 501 }
 502
 503 static gboolean
 504 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
 505     guint8 * audio_object_type)
 506 {
 507   if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
 508     return FALSE;
 509   if (*audio_object_type == 31) {
 510     if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
 511       return FALSE;
 512     *audio_object_type += 32;
 513   }
 514   GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
 515   return TRUE;
 516 }
 517
 518 static gboolean
 519 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
 520     gint * sample_rate)
 521 {
 522   guint8 sampling_frequency_index;
 523   if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
 524     return FALSE;
 525   GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
 526       sampling_frequency_index);
 527   if (sampling_frequency_index == 0xf) {
 528     guint32 sampling_rate;
 529     if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
 530       return FALSE;
 531     *sample_rate = sampling_rate;
 532   } else {
 533     *sample_rate = loas_sample_rate_table[sampling_frequency_index];
 534     if (!*sample_rate)
 535       return FALSE;
 536   }
 537   aacparse->last_parsed_sample_rate = *sample_rate;
 538   return TRUE;
 539 }
 540
 541 /* See table 1.13 in ISO/IEC 14496-3 */
 542 static gboolean
 543 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
 544     GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
 545 {
 546   guint8 audio_object_type;
 547   guint8 G_GNUC_UNUSED extension_audio_object_type;
 548   guint8 channel_configuration, extension_channel_configuration;
 549   gboolean G_GNUC_UNUSED sbr = FALSE, ps = FALSE;
 550
 551   if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
 552     return FALSE;
 553
 554   if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
 555     return FALSE;
 556
 557   if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
 558     return FALSE;
 559   *channels = loas_channels_table[channel_configuration];
 560   GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
 561   if (!*channels)
 562     return FALSE;
 563
 564   if (audio_object_type == 5 || audio_object_type == 29) {
 565     extension_audio_object_type = 5;
 566     sbr = TRUE;
 567     if (audio_object_type == 29)
 568       ps = TRUE;
 569
 570     GST_LOG_OBJECT (aacparse,
 571         "Audio object type 5 or 29, so rereading sampling rate...");
 572     if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
 573       return FALSE;
 574
 575     if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
 576       return FALSE;
 577
 578     if (audio_object_type == 22) {
 579       /* extension channel configuration */
 580       if (!gst_bit_reader_get_bits_uint8 (br, &extension_channel_configuration,
 581               4))
 582         return FALSE;
 583       GST_LOG_OBJECT (aacparse, "extension channel_configuration: %d",
 584           extension_channel_configuration);
 585       *channels = loas_channels_table[extension_channel_configuration];
 586       if (!*channels)
 587         return FALSE;
 588     }
 589   } else {
 590     extension_audio_object_type = 0;
 591   }
 592
 593   GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
 594       *sample_rate, *channels);
 595
 596   /* There's LOTS of stuff next, but we ignore it for now as we have
 597      what we want (sample rate and number of channels */
 598   GST_DEBUG_OBJECT (aacparse,
 599       "Need more code to parse humongous LOAS data, currently ignored");
 600   if (bits)
 601     *bits = 0;
 602   aacparse->last_parsed_channels = *channels;
 603   return TRUE;
 604 }
 605
 606
 607 static gboolean
 608 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
 609     guint avail, gint * sample_rate, gint * channels, gint * version)
 610 {
 611   GstBitReader br;
 612   guint8 u8, v, vA;
 613
 614   /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
 615   if (version)
 616     *version = 4;
 617
 618   gst_bit_reader_init (&br, data, avail);
 619
 620   /* skip sync word (11 bits) and size (13 bits) */
 621   if (!gst_bit_reader_skip (&br, 11 + 13))
 622     return FALSE;
 623
 624   /* First bit is "use last config" */
 625   if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
 626     return FALSE;
 627   if (u8) {
 628     GST_LOG_OBJECT (aacparse, "Frame uses previous config");
 629     if (!aacparse->last_parsed_sample_rate || !aacparse->last_parsed_channels) {
 630       GST_DEBUG_OBJECT (aacparse,
 631           "No previous config to use. We'll look for more data.");
 632       return FALSE;
 633     }
 634     *sample_rate = aacparse->last_parsed_sample_rate;
 635     *channels = aacparse->last_parsed_channels;
 636     return TRUE;
 637   }
 638
 639   GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
 640
 641   /* audioMuxVersion */
 642   if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
 643     return FALSE;
 644   if (v) {
 645     /* audioMuxVersionA */
 646     if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
 647       return FALSE;
 648   } else
 649     vA = 0;
 650
 651   GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
 652   if (vA == 0) {
 653     guint8 same_time, subframes, num_program, prog;
 654     if (v == 1) {
 655       guint32 value;
 656       /* taraBufferFullness */
 657       if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
 658         return FALSE;
 659     }
 660     if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
 661       return FALSE;
 662     if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
 663       return FALSE;
 664     if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
 665       return FALSE;
 666     GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
 667         same_time, subframes, num_program);
 668
 669     for (prog = 0; prog <= num_program; ++prog) {
 670       guint8 num_layer, layer;
 671       if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
 672         return FALSE;
 673       GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
 674
 675       for (layer = 0; layer <= num_layer; ++layer) {
 676         guint8 use_same_config;
 677         if (prog == 0 && layer == 0) {
 678           use_same_config = 0;
 679         } else {
 680           if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
 681             return FALSE;
 682         }
 683         if (!use_same_config) {
 684           if (v == 0) {
 685             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 686                     sample_rate, channels, NULL))
 687               return FALSE;
 688           } else {
 689             guint32 bits, asc_len;
 690             if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
 691               return FALSE;
 692             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 693                     sample_rate, channels, &bits))
 694               return FALSE;
 695             asc_len -= bits;
 696             if (!gst_bit_reader_skip (&br, asc_len))
 697               return FALSE;
 698           }
 699         }
 700       }
 701     }
 702     GST_LOG_OBJECT (aacparse, "More data ignored");
 703   } else {
 704     GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
 705     return FALSE;
 706   }
 707   return TRUE;
 708 }
 709
 710 /**
 711  * gst_aac_parse_loas_get_frame_len:
 712  * @data: block of data containing a LOAS header.
 713  *
 714  * This function calculates LOAS frame length from the given header.
 715  *
 716  * Returns: size of the LOAS frame.
 717  */
 718 static inline guint
 719 gst_aac_parse_loas_get_frame_len (const guint8 * data)
 720 {
 721   return (((data[1] & 0x1f) << 8) | data[2]) + 3;
 722 }
 723
 724
 725 /**
 726  * gst_aac_parse_check_loas_frame:
 727  * @aacparse: #GstAacParse.
 728  * @data: Data to be checked.
 729  * @avail: Amount of data passed.
 730  * @framesize: If valid LOAS frame was found, this will be set to tell the
 731  *             found frame size in bytes.
 732  * @needed_data: If frame was not found, this may be set to tell how much
 733  *               more data is needed in the next round to detect the frame
 734  *               reliably. This may happen when a frame header candidate
 735  *               is found but it cannot be guaranteed to be the header without
 736  *               peeking the following data.
 737  *
 738  * Check if the given data contains contains LOAS frame. The algorithm
 739  * will examine LOAS frame header and calculate the frame size. Also, another
 740  * consecutive LOAS frame header need to be present after the found frame.
 741  * Otherwise the data is not considered as a valid LOAS frame. However, this
 742  * "extra check" is omitted when EOS has been received. In this case it is
 743  * enough when data[0] contains a valid LOAS header.
 744  *
 745  * This function may set the #needed_data to indicate that a possible frame
 746  * candidate has been found, but more data (#needed_data bytes) is needed to
 747  * be absolutely sure. When this situation occurs, FALSE will be returned.
 748  *
 749  * When a valid frame is detected, this function will use
 750  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 751  * to set the needed bytes for next frame.This way next data chunk is already
 752  * of correct size.
 753  *
 754  * LOAS can have three different formats, if I read the spec correctly. Only
 755  * one of them is supported here, as the two samples I have use this one.
 756  *
 757  * Returns: TRUE if the given data contains a valid LOAS header.
 758  */
 759 static gboolean
 760 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
 761     const guint8 * data, const guint avail, gboolean drain,
 762     guint * framesize, guint * needed_data)
 763 {
 764   *needed_data = 0;
 765
 766   /* 3 byte header */
 767   if (G_UNLIKELY (avail < 3)) {
 768     *needed_data = 3;
 769     return FALSE;
 770   }
 771
 772   if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
 773     *framesize = gst_aac_parse_loas_get_frame_len (data);
 774     GST_DEBUG_OBJECT (aacparse, "Found possible %u byte LOAS frame",
 775         *framesize);
 776
 777     /* In EOS mode this is enough. No need to examine the data further.
 778        We also relax the check when we have sync, on the assumption that
 779        if we're not looking at random data, we have a much higher chance
 780        to get the correct sync, and this avoids losing two frames when
 781        a single bit corruption happens. */
 782     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 783       return TRUE;
 784     }
 785
 786     if (*framesize + LOAS_MAX_SIZE > avail) {
 787       /* We have found a possible frame header candidate, but can't be
 788          sure since we don't have enough data to check the next frame */
 789       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 790           *framesize + LOAS_MAX_SIZE, avail);
 791       *needed_data = *framesize + LOAS_MAX_SIZE;
 792       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 793           *framesize + LOAS_MAX_SIZE);
 794       return FALSE;
 795     }
 796
 797     if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
 798       guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
 799
 800       GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
 801       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 802           nextlen + LOAS_MAX_SIZE);
 803       return TRUE;
 804     } else {
 805       GST_DEBUG_OBJECT (aacparse, "That was a false positive");
 806     }
 807   }
 808   return FALSE;
 809 }
 810
 811 /* caller ensure sufficient data */
 812 static inline void
 813 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
 814     gint * rate, gint * channels, gint * object, gint * version)
 815 {
 816
 817   if (rate) {
 818     gint sr_idx = (data[2] & 0x3c) >> 2;
 819
 820     *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
 821   }
 822   if (channels) {
 823     *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
 824     if (*channels == 7)
 825       *channels = 8;
 826   }
 827
 828   if (version)
 829     *version = (data[1] & 0x08) ? 2 : 4;
 830   if (object)
 831     *object = ((data[2] & 0xc0) >> 6) + 1;
 832 }
 833
 834 /**
 835  * gst_aac_parse_detect_stream:
 836  * @aacparse: #GstAacParse.
 837  * @data: A block of data that needs to be examined for stream characteristics.
 838  * @avail: Size of the given datablock.
 839  * @framesize: If valid stream was found, this will be set to tell the
 840  *             first frame size in bytes.
 841  * @skipsize: If valid stream was found, this will be set to tell the first
 842  *            audio frame position within the given data.
 843  *
 844  * Examines the given piece of data and try to detect the format of it. It
 845  * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
 846  * header. If the stream is detected, TRUE will be returned and #framesize
 847  * is set to indicate the found frame size. Additionally, #skipsize might
 848  * be set to indicate the number of bytes that need to be skipped, a.k.a. the
 849  * position of the frame inside given data chunk.
 850  *
 851  * Returns: TRUE on success.
 852  */
 853 static gboolean
 854 gst_aac_parse_detect_stream (GstAacParse * aacparse,
 855     const guint8 * data, const guint avail, gboolean drain,
 856     guint * framesize, gint * skipsize)
 857 {
 858   gboolean found = FALSE;
 859   guint need_data_adts = 0, need_data_loas;
 860   guint i = 0;
 861
 862   GST_DEBUG_OBJECT (aacparse, "Parsing header data");
 863
 864   /* FIXME: No need to check for ADIF if we are not in the beginning of the
 865      stream */
 866
 867   /* Can we even parse the header? */
 868   if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
 869     GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
 870     return FALSE;
 871   }
 872
 873   for (i = 0; i < avail - 4; i++) {
 874     if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
 875         ((data[i] == 0x56) && ((data[i + 1] & 0xe0) == 0xe0)) ||
 876         strncmp ((char *) data + i, "ADIF", 4) == 0) {
 877       GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
 878       found = TRUE;
 879
 880       if (i) {
 881         /* Trick: tell the parent class that we didn't find the frame yet,
 882            but make it skip 'i' amount of bytes. Next time we arrive
 883            here we have full frame in the beginning of the data. */
 884         *skipsize = i;
 885         return FALSE;
 886       }
 887       break;
 888     }
 889   }
 890   if (!found) {
 891     if (i)
 892       *skipsize = i;
 893     return FALSE;
 894   }
 895
 896   if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
 897           framesize, &need_data_adts)) {
 898     gint rate, channels;
 899
 900     GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
 901
 902     gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
 903         &aacparse->object_type, &aacparse->mpegversion);
 904
 905     if (!channels || !framesize) {
 906       GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
 907       return FALSE;
 908     }
 909
 910     aacparse->header_type = DSPAAC_HEADER_ADTS;
 911     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 912         aacparse->frame_samples, 2, 2);
 913
 914     GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
 915         rate, channels, aacparse->object_type, aacparse->mpegversion);
 916
 917     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 918
 919     return TRUE;
 920   }
 921
 922   if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
 923           framesize, &need_data_loas)) {
 924     gint rate = 0, channels = 0;
 925
 926     GST_INFO ("LOAS, framesize: %d", *framesize);
 927
 928     aacparse->header_type = DSPAAC_HEADER_LOAS;
 929
 930     if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
 931             &channels, &aacparse->mpegversion)) {
 932       /* This is pretty normal when skipping data at the start of
 933        * random stream (MPEG-TS capture for example) */
 934       GST_LOG_OBJECT (aacparse, "Error reading LOAS config");
 935       return FALSE;
 936     }
 937
 938     if (rate && channels) {
 939       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 940           aacparse->frame_samples, 2, 2);
 941
 942       /* Don't store the sample rate and channels yet -
 943        * this is just format detection. */
 944       GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
 945           rate, channels, aacparse->object_type, aacparse->mpegversion);
 946     }
 947
 948     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 949
 950     return TRUE;
 951   }
 952
 953   if (need_data_adts || need_data_loas) {
 954     /* This tells the parent class not to skip any data */
 955     *skipsize = 0;
 956     return FALSE;
 957   }
 958
 959   if (avail < ADIF_MAX_SIZE)
 960     return FALSE;
 961
 962   if (memcmp (data + i, "ADIF", 4) == 0) {
 963     const guint8 *adif;
 964     int skip_size = 0;
 965     int bitstream_type;
 966     int sr_idx;
 967     GstCaps *sinkcaps;
 968
 969     aacparse->header_type = DSPAAC_HEADER_ADIF;
 970     aacparse->mpegversion = 4;
 971
 972     /* Skip the "ADIF" bytes */
 973     adif = data + i + 4;
 974
 975     /* copyright string */
 976     if (adif[0] & 0x80)
 977       skip_size += 9;           /* skip 9 bytes */
 978
 979     bitstream_type = adif[0 + skip_size] & 0x10;
 980     aacparse->bitrate =
 981         ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
 982         ((unsigned int) adif[1 + skip_size] << 11) |
 983         ((unsigned int) adif[2 + skip_size] << 3) |
 984         ((unsigned int) adif[3 + skip_size] & 0xe0);
 985
 986     /* CBR */
 987     if (bitstream_type == 0) {
 988 #if 0
 989       /* Buffer fullness parsing. Currently not needed... */
 990       guint num_elems = 0;
 991       guint fullness = 0;
 992
 993       num_elems = (adif[3 + skip_size] & 0x1e);
 994       GST_INFO ("ADIF num_config_elems: %d", num_elems);
 995
 996       fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
 997           ((unsigned int) adif[4 + skip_size] << 11) |
 998           ((unsigned int) adif[5 + skip_size] << 3) |
 999           ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
1000
1001       GST_INFO ("ADIF buffer fullness: %d", fullness);
1002 #endif
1003       aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
1004           ((adif[7 + skip_size] & 0x80) >> 7);
1005       sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
1006     }
1007     /* VBR */
1008     else {
1009       aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
1010       sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
1011           ((adif[5 + skip_size] & 0x80) >> 7);
1012     }
1013
1014     /* FIXME: This gives totally wrong results. Duration calculation cannot
1015        be based on this */
1016     aacparse->sample_rate =
1017         gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
1018
1019     /* baseparse is not given any fps,
1020      * so it will give up on timestamps, seeking, etc */
1021
1022     /* FIXME: Can we assume this? */
1023     aacparse->channels = 2;
1024
1025     GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
1026         aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
1027
1028     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
1029
1030     /* arrange for metadata and get out of the way */
1031     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
1032     gst_aac_parse_set_src_caps (aacparse, sinkcaps);
1033     if (sinkcaps)
1034       gst_caps_unref (sinkcaps);
1035
1036     /* not syncable, not easily seekable (unless we push data from start */
1037     gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
1038     gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
1039     gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
1040
1041     *framesize = avail;
1042     return TRUE;
1043   }
1044
1045   /* This should never happen */
1046   return FALSE;
1047 }
1048
1049 /**
1050  * gst_aac_parse_get_audio_profile_object_type
1051  * @aacparse: #GstAacParse.
1052  *
1053  * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
1054  * mpegversion and profile of @aacparse's src pad caps, according to the
1055  * values defined by table 1.A.11 in ISO/IEC 14496-3.
1056  *
1057  * Returns: the profile or object type value corresponding to @aacparse's src
1058  * pad caps, if such a value exists; otherwise G_MAXUINT8.
1059  */
1060 static guint8
1061 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
1062 {
1063   GstCaps *srccaps;
1064   GstStructure *srcstruct;
1065   const gchar *profile;
1066   guint8 ret;
1067
1068   srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1069   if (G_UNLIKELY (srccaps == NULL)) {
1070     return G_MAXUINT8;
1071   }
1072
1073   srcstruct = gst_caps_get_structure (srccaps, 0);
1074   profile = gst_structure_get_string (srcstruct, "profile");
1075   if (G_UNLIKELY (profile == NULL)) {
1076     gst_caps_unref (srccaps);
1077     return G_MAXUINT8;
1078   }
1079
1080   if (g_strcmp0 (profile, "main") == 0) {
1081     ret = (guint8) 0U;
1082   } else if (g_strcmp0 (profile, "lc") == 0) {
1083     ret = (guint8) 1U;
1084   } else if (g_strcmp0 (profile, "ssr") == 0) {
1085     ret = (guint8) 2U;
1086   } else if (g_strcmp0 (profile, "ltp") == 0) {
1087     if (G_LIKELY (aacparse->mpegversion == 4))
1088       ret = (guint8) 3U;
1089     else
1090       ret = G_MAXUINT8;         /* LTP Object Type allowed only for MPEG-4 */
1091   } else {
1092     ret = G_MAXUINT8;
1093   }
1094
1095   gst_caps_unref (srccaps);
1096   return ret;
1097 }
1098
1099 /**
1100  * gst_aac_parse_get_audio_channel_configuration
1101  * @num_channels: number of audio channels.
1102  *
1103  * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1104  * 14496-3, for a given number of audio channels.
1105  *
1106  * Returns: the Channel Configuration value corresponding to @num_channels, if
1107  * such a value exists; otherwise G_MAXUINT8.
1108  */
1109 static guint8
1110 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1111 {
1112   if (num_channels >= 1 && num_channels <= 6)   /* Mono up to & including 5.1 */
1113     return (guint8) num_channels;
1114   else if (num_channels == 8)   /* 7.1 */
1115     return (guint8) 7U;
1116   else
1117     return G_MAXUINT8;
1118
1119   /* FIXME: Add support for configurations 11, 12 and 14 from
1120    * ISO/IEC 14496-3:2009/PDAM 4 based on the actual channel layout
1121    */
1122 }
1123
1124 /**
1125  * gst_aac_parse_get_audio_sampling_frequency_index:
1126  * @sample_rate: audio sampling rate.
1127  *
1128  * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1129  * 14496-3, for a given sampling rate.
1130  *
1131  * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1132  * if such a value exists; otherwise G_MAXUINT8.
1133  */
1134 static guint8
1135 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1136 {
1137   switch (sample_rate) {
1138     case 96000:
1139       return 0x0U;
1140     case 88200:
1141       return 0x1U;
1142     case 64000:
1143       return 0x2U;
1144     case 48000:
1145       return 0x3U;
1146     case 44100:
1147       return 0x4U;
1148     case 32000:
1149       return 0x5U;
1150     case 24000:
1151       return 0x6U;
1152     case 22050:
1153       return 0x7U;
1154     case 16000:
1155       return 0x8U;
1156     case 12000:
1157       return 0x9U;
1158     case 11025:
1159       return 0xAU;
1160     case 8000:
1161       return 0xBU;
1162     case 7350:
1163       return 0xCU;
1164     default:
1165       return G_MAXUINT8;
1166   }
1167 }
1168
1169 /**
1170  * gst_aac_parse_prepend_adts_headers:
1171  * @aacparse: #GstAacParse.
1172  * @frame: raw AAC frame to which ADTS headers shall be prepended.
1173  *
1174  * Prepends ADTS headers to a raw AAC audio frame.
1175  *
1176  * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1177  */
1178 static gboolean
1179 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1180     GstBaseParseFrame * frame)
1181 {
1182   GstMemory *mem;
1183   guint8 *adts_headers;
1184   gsize buf_size;
1185   gsize frame_size;
1186   guint8 id, profile, channel_configuration, sampling_frequency_index;
1187
1188   id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1189   profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1190   if (profile == G_MAXUINT8) {
1191     GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1192     return FALSE;
1193   }
1194   channel_configuration =
1195       gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1196   if (channel_configuration == G_MAXUINT8) {
1197     GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1198     return FALSE;
1199   }
1200   sampling_frequency_index =
1201       gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1202   if (sampling_frequency_index == G_MAXUINT8) {
1203     GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1204     return FALSE;
1205   }
1206
1207   frame->out_buffer = gst_buffer_copy (frame->buffer);
1208   buf_size = gst_buffer_get_size (frame->out_buffer);
1209   frame_size = buf_size + ADTS_HEADERS_LENGTH;
1210
1211   if (G_UNLIKELY (frame_size >= 0x4000)) {
1212     GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1213     return FALSE;
1214   }
1215
1216   adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1217
1218   /* Note: no error correction bits are added to the resulting ADTS frames */
1219   adts_headers[0] = 0xFFU;
1220   adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1221   adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1222       (channel_configuration & 0x4U);
1223   adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1224       (guint8) (frame_size >> 11);
1225   adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1226   adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1227   adts_headers[6] = 0xFCU;
1228
1229   mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1230       ADTS_HEADERS_LENGTH, adts_headers, g_free);
1231   gst_buffer_prepend_memory (frame->out_buffer, mem);
1232
1233   return TRUE;
1234 }
1235
1236 /**
1237  * gst_aac_parse_check_valid_frame:
1238  * @parse: #GstBaseParse.
1239  * @frame: #GstBaseParseFrame.
1240  * @skipsize: How much data parent class should skip in order to find the
1241  *            frame header.
1242  *
1243  * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1244  *
1245  * Also determines frame overhead.
1246  * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1247  * a per-frame header. LOAS has 3 bytes.
1248  *
1249  * We're making a couple of simplifying assumptions:
1250  *
1251  * 1. We count Program Configuration Elements rather than searching for them
1252  *    in the streams to discount them - the overhead is negligible.
1253  *
1254  * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1255  *    bits, which should still not be significant enough to warrant the
1256  *    additional parsing through the headers
1257  *
1258  * Returns: a #GstFlowReturn.
1259  */
1260 static GstFlowReturn
1261 gst_aac_parse_handle_frame (GstBaseParse * parse,
1262     GstBaseParseFrame * frame, gint * skipsize)
1263 {
1264   GstMapInfo map;
1265   GstAacParse *aacparse;
1266   gboolean ret = FALSE;
1267   gboolean lost_sync;
1268   GstBuffer *buffer;
1269   guint framesize;
1270   gint rate = 0, channels = 0;
1271
1272   aacparse = GST_AAC_PARSE (parse);
1273   buffer = frame->buffer;
1274
1275   gst_buffer_map (buffer, &map, GST_MAP_READ);
1276
1277   *skipsize = -1;
1278   lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1279
1280   if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1281       aacparse->header_type == DSPAAC_HEADER_NONE) {
1282     /* There is nothing to parse */
1283     framesize = map.size;
1284     ret = TRUE;
1285
1286   } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1287
1288     ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1289         GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1290
1291   } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1292     guint needed_data = 1024;
1293
1294     ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1295         GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1296
1297     if (!ret && needed_data) {
1298       GST_DEBUG ("buffer didn't contain valid frame");
1299       *skipsize = 0;
1300       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1301           needed_data);
1302     }
1303
1304   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1305     guint needed_data = 1024;
1306
1307     ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1308         map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1309
1310     if (!ret && needed_data) {
1311       GST_DEBUG ("buffer didn't contain valid frame");
1312       *skipsize = 0;
1313       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1314           needed_data);
1315     }
1316
1317   } else {
1318     GST_DEBUG ("buffer didn't contain valid frame");
1319     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1320         ADTS_MAX_SIZE);
1321   }
1322
1323   if (G_UNLIKELY (!ret))
1324     goto exit;
1325
1326   if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1327     /* see above */
1328     frame->overhead = 7;
1329
1330     gst_aac_parse_parse_adts_header (aacparse, map.data,
1331         &rate, &channels, NULL, NULL);
1332
1333     GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1334
1335     if (G_UNLIKELY (rate != aacparse->sample_rate
1336             || channels != aacparse->channels)) {
1337       aacparse->sample_rate = rate;
1338       aacparse->channels = channels;
1339
1340       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1341         /* If linking fails, we need to return appropriate error */
1342         ret = GST_FLOW_NOT_LINKED;
1343       }
1344
1345       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1346           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1347     }
1348   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1349     gboolean setcaps = FALSE;
1350
1351     /* see above */
1352     frame->overhead = 3;
1353
1354     if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1355             &channels, NULL) || !rate || !channels) {
1356       /* This is pretty normal when skipping data at the start of
1357        * random stream (MPEG-TS capture for example) */
1358       GST_DEBUG_OBJECT (aacparse, "Error reading LOAS config. Skipping.");
1359       /* Since we don't fully parse the LOAS config, we don't know for sure
1360        * how much to skip. Just skip 1 to end up to the next marker and
1361        * resume parsing from there */
1362       *skipsize = 1;
1363       goto exit;
1364     }
1365
1366     if (G_UNLIKELY (rate != aacparse->sample_rate
1367             || channels != aacparse->channels)) {
1368       aacparse->sample_rate = rate;
1369       aacparse->channels = channels;
1370       setcaps = TRUE;
1371       GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1372           channels);
1373     }
1374
1375     /* We want to set caps both at start, and when rate/channels change.
1376        Since only some LOAS frames have that info, we may receive frames
1377        before knowing about rate/channels. */
1378     if (setcaps
1379         || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1380       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1381         /* If linking fails, we need to return appropriate error */
1382         ret = GST_FLOW_NOT_LINKED;
1383       }
1384
1385       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1386           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1387     }
1388   }
1389
1390   if (aacparse->header_type == DSPAAC_HEADER_NONE
1391       && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1392     if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1393       GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1394       ret = GST_FLOW_ERROR;
1395     }
1396   }
1397
1398 exit:
1399   gst_buffer_unmap (buffer, &map);
1400
1401   if (ret) {
1402     /* found, skip if needed */
1403     if (*skipsize > 0)
1404       return GST_FLOW_OK;
1405     *skipsize = 0;
1406   } else {
1407     if (*skipsize < 0)
1408       *skipsize = 1;
1409   }
1410
1411   if (ret && framesize <= map.size) {
1412     return gst_base_parse_finish_frame (parse, frame, framesize);
1413   }
1414
1415   return GST_FLOW_OK;
1416 }
1417
1418 static GstFlowReturn
1419 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1420 {
1421   GstAacParse *aacparse = GST_AAC_PARSE (parse);
1422
1423   if (!aacparse->sent_codec_tag) {
1424     GstTagList *taglist;
1425     GstCaps *caps;
1426
1427     /* codec tag */
1428     caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1429     if (caps == NULL) {
1430       if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
1431         GST_INFO_OBJECT (parse, "Src pad is flushing");
1432         return GST_FLOW_FLUSHING;
1433       } else {
1434         GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
1435         return GST_FLOW_NOT_NEGOTIATED;
1436       }
1437     }
1438
1439     taglist = gst_tag_list_new_empty ();
1440     gst_pb_utils_add_codec_description_to_tag_list (taglist,
1441         GST_TAG_AUDIO_CODEC, caps);
1442     gst_caps_unref (caps);
1443
1444     gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
1445     gst_tag_list_unref (taglist);
1446
1447     /* also signals the end of first-frame processing */
1448     aacparse->sent_codec_tag = TRUE;
1449   }
1450
1451   /* As a special case, we can remove the ADTS framing and output raw AAC. */
1452   if (aacparse->header_type == DSPAAC_HEADER_ADTS
1453       && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1454     guint header_size;
1455     GstMapInfo map;
1456     frame->out_buffer = gst_buffer_make_writable (frame->buffer);
1457     frame->buffer = NULL;
1458     gst_buffer_map (frame->out_buffer, &map, GST_MAP_READ);
1459     header_size = (map.data[1] & 1) ? 7 : 9;    /* optional CRC */
1460     gst_buffer_unmap (frame->out_buffer, &map);
1461     gst_buffer_resize (frame->out_buffer, header_size,
1462         gst_buffer_get_size (frame->out_buffer) - header_size);
1463   }
1464
1465   return GST_FLOW_OK;
1466 }
1467
1468
1469 /**
1470  * gst_aac_parse_start:
1471  * @parse: #GstBaseParse.
1472  *
1473  * Implementation of "start" vmethod in #GstBaseParse class.
1474  *
1475  * Returns: TRUE if startup succeeded.
1476  */
1477 static gboolean
1478 gst_aac_parse_start (GstBaseParse * parse)
1479 {
1480   GstAacParse *aacparse;
1481
1482   aacparse = GST_AAC_PARSE (parse);
1483   GST_DEBUG ("start");
1484   aacparse->frame_samples = 1024;
1485   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1486   aacparse->sent_codec_tag = FALSE;
1487   aacparse->last_parsed_channels = 0;
1488   aacparse->last_parsed_sample_rate = 0;
1489   return TRUE;
1490 }
1491
1492
1493 /**
1494  * gst_aac_parse_stop:
1495  * @parse: #GstBaseParse.
1496  *
1497  * Implementation of "stop" vmethod in #GstBaseParse class.
1498  *
1499  * Returns: TRUE is stopping succeeded.
1500  */
1501 static gboolean
1502 gst_aac_parse_stop (GstBaseParse * parse)
1503 {
1504   GST_DEBUG ("stop");
1505   return TRUE;
1506 }
1507
1508 static void
1509 remove_fields (GstCaps * caps)
1510 {
1511   guint i, n;
1512
1513   n = gst_caps_get_size (caps);
1514   for (i = 0; i < n; i++) {
1515     GstStructure *s = gst_caps_get_structure (caps, i);
1516
1517     gst_structure_remove_field (s, "framed");
1518   }
1519 }
1520
1521 static void
1522 add_conversion_fields (GstCaps * caps)
1523 {
1524   guint i, n;
1525
1526   n = gst_caps_get_size (caps);
1527   for (i = 0; i < n; i++) {
1528     GstStructure *s = gst_caps_get_structure (caps, i);
1529
1530     if (gst_structure_has_field (s, "stream-format")) {
1531       const GValue *v = gst_structure_get_value (s, "stream-format");
1532
1533       if (G_VALUE_HOLDS_STRING (v)) {
1534         const gchar *str = g_value_get_string (v);
1535
1536         if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1537           GValue va = G_VALUE_INIT;
1538           GValue vs = G_VALUE_INIT;
1539
1540           g_value_init (&va, GST_TYPE_LIST);
1541           g_value_init (&vs, G_TYPE_STRING);
1542           g_value_set_string (&vs, "adts");
1543           gst_value_list_append_value (&va, &vs);
1544           g_value_set_string (&vs, "raw");
1545           gst_value_list_append_value (&va, &vs);
1546           gst_structure_set_value (s, "stream-format", &va);
1547           g_value_unset (&va);
1548           g_value_unset (&vs);
1549         }
1550       } else if (GST_VALUE_HOLDS_LIST (v)) {
1551         gboolean contains_raw = FALSE;
1552         gboolean contains_adts = FALSE;
1553         guint m = gst_value_list_get_size (v), j;
1554
1555         for (j = 0; j < m; j++) {
1556           const GValue *ve = gst_value_list_get_value (v, j);
1557           const gchar *str;
1558
1559           if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1560             if (strcmp (str, "adts") == 0)
1561               contains_adts = TRUE;
1562             else if (strcmp (str, "raw") == 0)
1563               contains_raw = TRUE;
1564           }
1565         }
1566
1567         if (contains_adts || contains_raw) {
1568           GValue va = G_VALUE_INIT;
1569           GValue vs = G_VALUE_INIT;
1570
1571           g_value_init (&va, GST_TYPE_LIST);
1572           g_value_init (&vs, G_TYPE_STRING);
1573           g_value_copy (v, &va);
1574
1575           if (!contains_raw) {
1576             g_value_set_string (&vs, "raw");
1577             gst_value_list_append_value (&va, &vs);
1578           }
1579           if (!contains_adts) {
1580             g_value_set_string (&vs, "adts");
1581             gst_value_list_append_value (&va, &vs);
1582           }
1583
1584           gst_structure_set_value (s, "stream-format", &va);
1585
1586           g_value_unset (&vs);
1587           g_value_unset (&va);
1588         }
1589       }
1590     }
1591   }
1592 }
1593
1594 static GstCaps *
1595 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1596 {
1597   GstCaps *peercaps, *templ;
1598   GstCaps *res;
1599
1600   templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1601
1602   if (filter) {
1603     GstCaps *fcopy = gst_caps_copy (filter);
1604     /* Remove the fields we convert */
1605     remove_fields (fcopy);
1606     add_conversion_fields (fcopy);
1607     peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1608     gst_caps_unref (fcopy);
1609   } else
1610     peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1611
1612   if (peercaps) {
1613     peercaps = gst_caps_make_writable (peercaps);
1614     /* Remove the fields we convert */
1615     remove_fields (peercaps);
1616     add_conversion_fields (peercaps);
1617
1618     res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1619     gst_caps_unref (peercaps);
1620     gst_caps_unref (templ);
1621   } else {
1622     res = templ;
1623   }
1624
1625   if (filter) {
1626     GstCaps *intersection;
1627
1628     intersection =
1629         gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1630     gst_caps_unref (res);
1631     res = intersection;
1632   }
1633
1634   return res;
1635 }
1636
1637 static gboolean
1638 gst_aac_parse_src_event (GstBaseParse * parse, GstEvent * event)
1639 {
1640   GstAacParse *aacparse = GST_AAC_PARSE (parse);
1641
1642   if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
1643     aacparse->last_parsed_channels = 0;
1644     aacparse->last_parsed_sample_rate = 0;
1645   }
1646
1647   return GST_BASE_PARSE_CLASS (parent_class)->src_event (parse, event);
1648 }