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) {
 310       GstMapInfo map;
 311       guint sr_idx;
 312
 313       gst_buffer_map (buf, &map, GST_MAP_READ);
 314
 315       sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
 316       aacparse->object_type = (map.data[0] & 0xf8) >> 3;
 317       aacparse->sample_rate =
 318           gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
 319       aacparse->channels = (map.data[1] & 0x78) >> 3;
 320       if (aacparse->channels == 7)
 321         aacparse->channels = 8;
 322       else if (aacparse->channels == 11)
 323         aacparse->channels = 7;
 324       else if (aacparse->channels == 12 || aacparse->channels == 14)
 325         aacparse->channels = 8;
 326       aacparse->header_type = DSPAAC_HEADER_NONE;
 327       aacparse->mpegversion = 4;
 328       aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
 329       gst_buffer_unmap (buf, &map);
 330
 331       GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
 332           "samples=%d", aacparse->object_type, aacparse->sample_rate,
 333           aacparse->channels, aacparse->frame_samples);
 334
 335       /* arrange for metadata and get out of the way */
 336       gst_aac_parse_set_src_caps (aacparse, caps);
 337       if (aacparse->header_type == aacparse->output_header_type)
 338         gst_base_parse_set_passthrough (parse, TRUE);
 339     } else {
 340       return FALSE;
 341     }
 342
 343     /* caps info overrides */
 344     gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
 345     gst_structure_get_int (structure, "channels", &aacparse->channels);
 346   } else {
 347     const gchar *stream_format =
 348         gst_structure_get_string (structure, "stream-format");
 349
 350     if (g_strcmp0 (stream_format, "raw") == 0) {
 351       GST_ERROR_OBJECT (parse, "Need codec_data for raw AAC");
 352       return FALSE;
 353     } else {
 354       aacparse->sample_rate = 0;
 355       aacparse->channels = 0;
 356       aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
 357       gst_base_parse_set_passthrough (parse, FALSE);
 358     }
 359   }
 360   return TRUE;
 361 }
 362
 363
 364 /**
 365  * gst_aac_parse_adts_get_frame_len:
 366  * @data: block of data containing an ADTS header.
 367  *
 368  * This function calculates ADTS frame length from the given header.
 369  *
 370  * Returns: size of the ADTS frame.
 371  */
 372 static inline guint
 373 gst_aac_parse_adts_get_frame_len (const guint8 * data)
 374 {
 375   return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
 376 }
 377
 378
 379 /**
 380  * gst_aac_parse_check_adts_frame:
 381  * @aacparse: #GstAacParse.
 382  * @data: Data to be checked.
 383  * @avail: Amount of data passed.
 384  * @framesize: If valid ADTS frame was found, this will be set to tell the
 385  *             found frame size in bytes.
 386  * @needed_data: If frame was not found, this may be set to tell how much
 387  *               more data is needed in the next round to detect the frame
 388  *               reliably. This may happen when a frame header candidate
 389  *               is found but it cannot be guaranteed to be the header without
 390  *               peeking the following data.
 391  *
 392  * Check if the given data contains contains ADTS frame. The algorithm
 393  * will examine ADTS frame header and calculate the frame size. Also, another
 394  * consecutive ADTS frame header need to be present after the found frame.
 395  * Otherwise the data is not considered as a valid ADTS frame. However, this
 396  * "extra check" is omitted when EOS has been received. In this case it is
 397  * enough when data[0] contains a valid ADTS header.
 398  *
 399  * This function may set the #needed_data to indicate that a possible frame
 400  * candidate has been found, but more data (#needed_data bytes) is needed to
 401  * be absolutely sure. When this situation occurs, FALSE will be returned.
 402  *
 403  * When a valid frame is detected, this function will use
 404  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 405  * to set the needed bytes for next frame.This way next data chunk is already
 406  * of correct size.
 407  *
 408  * Returns: TRUE if the given data contains a valid ADTS header.
 409  */
 410 static gboolean
 411 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
 412     const guint8 * data, const guint avail, gboolean drain,
 413     guint * framesize, guint * needed_data)
 414 {
 415   guint crc_size;
 416
 417   *needed_data = 0;
 418
 419   /* Absolute minimum to perform the ADTS syncword,
 420      layer and sampling frequency tests */
 421   if (G_UNLIKELY (avail < 3)) {
 422     *needed_data = 3;
 423     return FALSE;
 424   }
 425
 426   /* Syncword and layer tests */
 427   if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
 428
 429     /* Sampling frequency test */
 430     if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
 431       return FALSE;
 432
 433     /* This looks like an ADTS frame header but
 434        we need at least 6 bytes to proceed */
 435     if (G_UNLIKELY (avail < 6)) {
 436       *needed_data = 6;
 437       return FALSE;
 438     }
 439
 440     *framesize = gst_aac_parse_adts_get_frame_len (data);
 441
 442     /* If frame has CRC, it needs 2 bytes
 443        for it at the end of the header */
 444     crc_size = (data[1] & 0x01) ? 0 : 2;
 445
 446     /* CRC size test */
 447     if (*framesize < 7 + crc_size) {
 448       *needed_data = 7 + crc_size;
 449       return FALSE;
 450     }
 451
 452     /* In EOS mode this is enough. No need to examine the data further.
 453        We also relax the check when we have sync, on the assumption that
 454        if we're not looking at random data, we have a much higher chance
 455        to get the correct sync, and this avoids losing two frames when
 456        a single bit corruption happens. */
 457     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 458       return TRUE;
 459     }
 460
 461     if (*framesize + ADTS_MAX_SIZE > avail) {
 462       /* We have found a possible frame header candidate, but can't be
 463          sure since we don't have enough data to check the next frame */
 464       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 465           *framesize + ADTS_MAX_SIZE, avail);
 466       *needed_data = *framesize + ADTS_MAX_SIZE;
 467       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 468           *framesize + ADTS_MAX_SIZE);
 469       return FALSE;
 470     }
 471
 472     if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
 473       guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
 474
 475       GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
 476       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 477           nextlen + ADTS_MAX_SIZE);
 478       return TRUE;
 479     }
 480   }
 481   return FALSE;
 482 }
 483
 484 static gboolean
 485 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
 486     guint32 * value)
 487 {
 488   guint8 bytes, i, byte;
 489
 490   *value = 0;
 491   if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
 492     return FALSE;
 493   for (i = 0; i <= bytes; ++i) {
 494     *value <<= 8;
 495     if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
 496       return FALSE;
 497     *value += byte;
 498   }
 499   return TRUE;
 500 }
 501
 502 static gboolean
 503 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
 504     guint8 * audio_object_type)
 505 {
 506   if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
 507     return FALSE;
 508   if (*audio_object_type == 31) {
 509     if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
 510       return FALSE;
 511     *audio_object_type += 32;
 512   }
 513   GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
 514   return TRUE;
 515 }
 516
 517 static gboolean
 518 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
 519     gint * sample_rate)
 520 {
 521   guint8 sampling_frequency_index;
 522   if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
 523     return FALSE;
 524   GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
 525       sampling_frequency_index);
 526   if (sampling_frequency_index == 0xf) {
 527     guint32 sampling_rate;
 528     if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
 529       return FALSE;
 530     *sample_rate = sampling_rate;
 531   } else {
 532     *sample_rate = loas_sample_rate_table[sampling_frequency_index];
 533     if (!*sample_rate)
 534       return FALSE;
 535   }
 536   aacparse->last_parsed_sample_rate = *sample_rate;
 537   return TRUE;
 538 }
 539
 540 /* See table 1.13 in ISO/IEC 14496-3 */
 541 static gboolean
 542 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
 543     GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
 544 {
 545   guint8 audio_object_type, channel_configuration;
 546
 547   if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
 548     return FALSE;
 549
 550   if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
 551     return FALSE;
 552
 553   if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
 554     return FALSE;
 555   GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
 556   *channels = loas_channels_table[channel_configuration];
 557   if (!*channels)
 558     return FALSE;
 559
 560   if (audio_object_type == 5) {
 561     GST_LOG_OBJECT (aacparse,
 562         "Audio object type 5, so rereading sampling rate...");
 563     if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
 564       return FALSE;
 565   }
 566
 567   GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
 568       *sample_rate, *channels);
 569
 570   /* There's LOTS of stuff next, but we ignore it for now as we have
 571      what we want (sample rate and number of channels */
 572   GST_DEBUG_OBJECT (aacparse,
 573       "Need more code to parse humongous LOAS data, currently ignored");
 574   if (bits)
 575     *bits = 0;
 576   aacparse->last_parsed_channels = *channels;
 577   return TRUE;
 578 }
 579
 580
 581 static gboolean
 582 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
 583     guint avail, gint * sample_rate, gint * channels, gint * version)
 584 {
 585   GstBitReader br;
 586   guint8 u8, v, vA;
 587
 588   /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
 589   if (version)
 590     *version = 4;
 591
 592   gst_bit_reader_init (&br, data, avail);
 593
 594   /* skip sync word (11 bits) and size (13 bits) */
 595   if (!gst_bit_reader_skip (&br, 11 + 13))
 596     return FALSE;
 597
 598   /* First bit is "use last config" */
 599   if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
 600     return FALSE;
 601   if (u8) {
 602     GST_LOG_OBJECT (aacparse, "Frame uses previous config");
 603     if (!aacparse->last_parsed_sample_rate || !aacparse->last_parsed_channels) {
 604       GST_DEBUG_OBJECT (aacparse,
 605           "No previous config to use. We'll look for more data.");
 606       return FALSE;
 607     }
 608     *sample_rate = aacparse->last_parsed_sample_rate;
 609     *channels = aacparse->last_parsed_channels;
 610     return TRUE;
 611   }
 612
 613   GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
 614
 615   if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
 616     return FALSE;
 617   if (v) {
 618     if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
 619       return FALSE;
 620   } else
 621     vA = 0;
 622
 623   GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
 624   if (vA == 0) {
 625     guint8 same_time, subframes, num_program, prog;
 626     if (v == 1) {
 627       guint32 value;
 628       if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
 629         return FALSE;
 630     }
 631     if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
 632       return FALSE;
 633     if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
 634       return FALSE;
 635     if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
 636       return FALSE;
 637     GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
 638         same_time, subframes, num_program);
 639
 640     for (prog = 0; prog <= num_program; ++prog) {
 641       guint8 num_layer, layer;
 642       if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
 643         return FALSE;
 644       GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
 645
 646       for (layer = 0; layer <= num_layer; ++layer) {
 647         guint8 use_same_config;
 648         if (prog == 0 && layer == 0) {
 649           use_same_config = 0;
 650         } else {
 651           if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
 652             return FALSE;
 653         }
 654         if (!use_same_config) {
 655           if (v == 0) {
 656             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 657                     sample_rate, channels, NULL))
 658               return FALSE;
 659           } else {
 660             guint32 bits, asc_len;
 661             if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
 662               return FALSE;
 663             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 664                     sample_rate, channels, &bits))
 665               return FALSE;
 666             asc_len -= bits;
 667             if (!gst_bit_reader_skip (&br, asc_len))
 668               return FALSE;
 669           }
 670         }
 671       }
 672     }
 673     GST_LOG_OBJECT (aacparse, "More data ignored");
 674   } else {
 675     GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
 676     return FALSE;
 677   }
 678   return TRUE;
 679 }
 680
 681 /**
 682  * gst_aac_parse_loas_get_frame_len:
 683  * @data: block of data containing a LOAS header.
 684  *
 685  * This function calculates LOAS frame length from the given header.
 686  *
 687  * Returns: size of the LOAS frame.
 688  */
 689 static inline guint
 690 gst_aac_parse_loas_get_frame_len (const guint8 * data)
 691 {
 692   return (((data[1] & 0x1f) << 8) | data[2]) + 3;
 693 }
 694
 695
 696 /**
 697  * gst_aac_parse_check_loas_frame:
 698  * @aacparse: #GstAacParse.
 699  * @data: Data to be checked.
 700  * @avail: Amount of data passed.
 701  * @framesize: If valid LOAS frame was found, this will be set to tell the
 702  *             found frame size in bytes.
 703  * @needed_data: If frame was not found, this may be set to tell how much
 704  *               more data is needed in the next round to detect the frame
 705  *               reliably. This may happen when a frame header candidate
 706  *               is found but it cannot be guaranteed to be the header without
 707  *               peeking the following data.
 708  *
 709  * Check if the given data contains contains LOAS frame. The algorithm
 710  * will examine LOAS frame header and calculate the frame size. Also, another
 711  * consecutive LOAS frame header need to be present after the found frame.
 712  * Otherwise the data is not considered as a valid LOAS frame. However, this
 713  * "extra check" is omitted when EOS has been received. In this case it is
 714  * enough when data[0] contains a valid LOAS header.
 715  *
 716  * This function may set the #needed_data to indicate that a possible frame
 717  * candidate has been found, but more data (#needed_data bytes) is needed to
 718  * be absolutely sure. When this situation occurs, FALSE will be returned.
 719  *
 720  * When a valid frame is detected, this function will use
 721  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 722  * to set the needed bytes for next frame.This way next data chunk is already
 723  * of correct size.
 724  *
 725  * LOAS can have three different formats, if I read the spec correctly. Only
 726  * one of them is supported here, as the two samples I have use this one.
 727  *
 728  * Returns: TRUE if the given data contains a valid LOAS header.
 729  */
 730 static gboolean
 731 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
 732     const guint8 * data, const guint avail, gboolean drain,
 733     guint * framesize, guint * needed_data)
 734 {
 735   *needed_data = 0;
 736
 737   /* 3 byte header */
 738   if (G_UNLIKELY (avail < 3)) {
 739     *needed_data = 3;
 740     return FALSE;
 741   }
 742
 743   if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
 744     *framesize = gst_aac_parse_loas_get_frame_len (data);
 745     GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
 746
 747     /* In EOS mode this is enough. No need to examine the data further.
 748        We also relax the check when we have sync, on the assumption that
 749        if we're not looking at random data, we have a much higher chance
 750        to get the correct sync, and this avoids losing two frames when
 751        a single bit corruption happens. */
 752     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 753       return TRUE;
 754     }
 755
 756     if (*framesize + LOAS_MAX_SIZE > avail) {
 757       /* We have found a possible frame header candidate, but can't be
 758          sure since we don't have enough data to check the next frame */
 759       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 760           *framesize + LOAS_MAX_SIZE, avail);
 761       *needed_data = *framesize + LOAS_MAX_SIZE;
 762       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 763           *framesize + LOAS_MAX_SIZE);
 764       return FALSE;
 765     }
 766
 767     if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
 768       guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
 769
 770       GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
 771       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 772           nextlen + LOAS_MAX_SIZE);
 773       return TRUE;
 774     }
 775   }
 776   return FALSE;
 777 }
 778
 779 /* caller ensure sufficient data */
 780 static inline void
 781 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
 782     gint * rate, gint * channels, gint * object, gint * version)
 783 {
 784
 785   if (rate) {
 786     gint sr_idx = (data[2] & 0x3c) >> 2;
 787
 788     *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
 789   }
 790   if (channels) {
 791     *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
 792     if (*channels == 7)
 793       *channels = 8;
 794   }
 795
 796   if (version)
 797     *version = (data[1] & 0x08) ? 2 : 4;
 798   if (object)
 799     *object = ((data[2] & 0xc0) >> 6) + 1;
 800 }
 801
 802 /**
 803  * gst_aac_parse_detect_stream:
 804  * @aacparse: #GstAacParse.
 805  * @data: A block of data that needs to be examined for stream characteristics.
 806  * @avail: Size of the given datablock.
 807  * @framesize: If valid stream was found, this will be set to tell the
 808  *             first frame size in bytes.
 809  * @skipsize: If valid stream was found, this will be set to tell the first
 810  *            audio frame position within the given data.
 811  *
 812  * Examines the given piece of data and try to detect the format of it. It
 813  * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
 814  * header. If the stream is detected, TRUE will be returned and #framesize
 815  * is set to indicate the found frame size. Additionally, #skipsize might
 816  * be set to indicate the number of bytes that need to be skipped, a.k.a. the
 817  * position of the frame inside given data chunk.
 818  *
 819  * Returns: TRUE on success.
 820  */
 821 static gboolean
 822 gst_aac_parse_detect_stream (GstAacParse * aacparse,
 823     const guint8 * data, const guint avail, gboolean drain,
 824     guint * framesize, gint * skipsize)
 825 {
 826   gboolean found = FALSE;
 827   guint need_data_adts = 0, need_data_loas;
 828   guint i = 0;
 829
 830   GST_DEBUG_OBJECT (aacparse, "Parsing header data");
 831
 832   /* FIXME: No need to check for ADIF if we are not in the beginning of the
 833      stream */
 834
 835   /* Can we even parse the header? */
 836   if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
 837     GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
 838     return FALSE;
 839   }
 840
 841   for (i = 0; i < avail - 4; i++) {
 842     if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
 843         ((data[i] == 0x56) && ((data[i + 1] & 0xe0) == 0xe0)) ||
 844         strncmp ((char *) data + i, "ADIF", 4) == 0) {
 845       GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
 846       found = TRUE;
 847
 848       if (i) {
 849         /* Trick: tell the parent class that we didn't find the frame yet,
 850            but make it skip 'i' amount of bytes. Next time we arrive
 851            here we have full frame in the beginning of the data. */
 852         *skipsize = i;
 853         return FALSE;
 854       }
 855       break;
 856     }
 857   }
 858   if (!found) {
 859     if (i)
 860       *skipsize = i;
 861     return FALSE;
 862   }
 863
 864   if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
 865           framesize, &need_data_adts)) {
 866     gint rate, channels;
 867
 868     GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
 869
 870     gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
 871         &aacparse->object_type, &aacparse->mpegversion);
 872
 873     if (!channels || !framesize) {
 874       GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
 875       return FALSE;
 876     }
 877
 878     aacparse->header_type = DSPAAC_HEADER_ADTS;
 879     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 880         aacparse->frame_samples, 2, 2);
 881
 882     GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
 883         rate, channels, aacparse->object_type, aacparse->mpegversion);
 884
 885     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 886
 887     return TRUE;
 888   }
 889
 890   if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
 891           framesize, &need_data_loas)) {
 892     gint rate = 0, channels = 0;
 893
 894     GST_INFO ("LOAS, framesize: %d", *framesize);
 895
 896     aacparse->header_type = DSPAAC_HEADER_LOAS;
 897
 898     if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
 899             &channels, &aacparse->mpegversion)) {
 900       /* This is pretty normal when skipping data at the start of
 901        * random stream (MPEG-TS capture for example) */
 902       GST_LOG_OBJECT (aacparse, "Error reading LOAS config");
 903       return FALSE;
 904     }
 905
 906     if (rate && channels) {
 907       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 908           aacparse->frame_samples, 2, 2);
 909
 910       /* Don't store the sample rate and channels yet -
 911        * this is just format detection. */
 912       GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
 913           rate, channels, aacparse->object_type, aacparse->mpegversion);
 914     }
 915
 916     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 917
 918     return TRUE;
 919   }
 920
 921   if (need_data_adts || need_data_loas) {
 922     /* This tells the parent class not to skip any data */
 923     *skipsize = 0;
 924     return FALSE;
 925   }
 926
 927   if (avail < ADIF_MAX_SIZE)
 928     return FALSE;
 929
 930   if (memcmp (data + i, "ADIF", 4) == 0) {
 931     const guint8 *adif;
 932     int skip_size = 0;
 933     int bitstream_type;
 934     int sr_idx;
 935     GstCaps *sinkcaps;
 936
 937     aacparse->header_type = DSPAAC_HEADER_ADIF;
 938     aacparse->mpegversion = 4;
 939
 940     /* Skip the "ADIF" bytes */
 941     adif = data + i + 4;
 942
 943     /* copyright string */
 944     if (adif[0] & 0x80)
 945       skip_size += 9;           /* skip 9 bytes */
 946
 947     bitstream_type = adif[0 + skip_size] & 0x10;
 948     aacparse->bitrate =
 949         ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
 950         ((unsigned int) adif[1 + skip_size] << 11) |
 951         ((unsigned int) adif[2 + skip_size] << 3) |
 952         ((unsigned int) adif[3 + skip_size] & 0xe0);
 953
 954     /* CBR */
 955     if (bitstream_type == 0) {
 956 #if 0
 957       /* Buffer fullness parsing. Currently not needed... */
 958       guint num_elems = 0;
 959       guint fullness = 0;
 960
 961       num_elems = (adif[3 + skip_size] & 0x1e);
 962       GST_INFO ("ADIF num_config_elems: %d", num_elems);
 963
 964       fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
 965           ((unsigned int) adif[4 + skip_size] << 11) |
 966           ((unsigned int) adif[5 + skip_size] << 3) |
 967           ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
 968
 969       GST_INFO ("ADIF buffer fullness: %d", fullness);
 970 #endif
 971       aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
 972           ((adif[7 + skip_size] & 0x80) >> 7);
 973       sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
 974     }
 975     /* VBR */
 976     else {
 977       aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
 978       sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
 979           ((adif[5 + skip_size] & 0x80) >> 7);
 980     }
 981
 982     /* FIXME: This gives totally wrong results. Duration calculation cannot
 983        be based on this */
 984     aacparse->sample_rate =
 985         gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
 986
 987     /* baseparse is not given any fps,
 988      * so it will give up on timestamps, seeking, etc */
 989
 990     /* FIXME: Can we assume this? */
 991     aacparse->channels = 2;
 992
 993     GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
 994         aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
 995
 996     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
 997
 998     /* arrange for metadata and get out of the way */
 999     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
1000     gst_aac_parse_set_src_caps (aacparse, sinkcaps);
1001     if (sinkcaps)
1002       gst_caps_unref (sinkcaps);
1003
1004     /* not syncable, not easily seekable (unless we push data from start */
1005     gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
1006     gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
1007     gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
1008
1009     *framesize = avail;
1010     return TRUE;
1011   }
1012
1013   /* This should never happen */
1014   return FALSE;
1015 }
1016
1017 /**
1018  * gst_aac_parse_get_audio_profile_object_type
1019  * @aacparse: #GstAacParse.
1020  *
1021  * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
1022  * mpegversion and profile of @aacparse's src pad caps, according to the
1023  * values defined by table 1.A.11 in ISO/IEC 14496-3.
1024  *
1025  * Returns: the profile or object type value corresponding to @aacparse's src
1026  * pad caps, if such a value exists; otherwise G_MAXUINT8.
1027  */
1028 static guint8
1029 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
1030 {
1031   GstCaps *srccaps;
1032   GstStructure *srcstruct;
1033   const gchar *profile;
1034   guint8 ret;
1035
1036   srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1037   if (G_UNLIKELY (srccaps == NULL)) {
1038     return G_MAXUINT8;
1039   }
1040
1041   srcstruct = gst_caps_get_structure (srccaps, 0);
1042   profile = gst_structure_get_string (srcstruct, "profile");
1043   if (G_UNLIKELY (profile == NULL)) {
1044     gst_caps_unref (srccaps);
1045     return G_MAXUINT8;
1046   }
1047
1048   if (g_strcmp0 (profile, "main") == 0) {
1049     ret = (guint8) 0U;
1050   } else if (g_strcmp0 (profile, "lc") == 0) {
1051     ret = (guint8) 1U;
1052   } else if (g_strcmp0 (profile, "ssr") == 0) {
1053     ret = (guint8) 2U;
1054   } else if (g_strcmp0 (profile, "ltp") == 0) {
1055     if (G_LIKELY (aacparse->mpegversion == 4))
1056       ret = (guint8) 3U;
1057     else
1058       ret = G_MAXUINT8;         /* LTP Object Type allowed only for MPEG-4 */
1059   } else {
1060     ret = G_MAXUINT8;
1061   }
1062
1063   gst_caps_unref (srccaps);
1064   return ret;
1065 }
1066
1067 /**
1068  * gst_aac_parse_get_audio_channel_configuration
1069  * @num_channels: number of audio channels.
1070  *
1071  * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1072  * 14496-3, for a given number of audio channels.
1073  *
1074  * Returns: the Channel Configuration value corresponding to @num_channels, if
1075  * such a value exists; otherwise G_MAXUINT8.
1076  */
1077 static guint8
1078 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1079 {
1080   if (num_channels >= 1 && num_channels <= 6)   /* Mono up to & including 5.1 */
1081     return (guint8) num_channels;
1082   else if (num_channels == 8)   /* 7.1 */
1083     return (guint8) 7U;
1084   else
1085     return G_MAXUINT8;
1086
1087   /* FIXME: Add support for configurations 11, 12 and 14 from
1088    * ISO/IEC 14496-3:2009/PDAM 4 based on the actual channel layout
1089    */
1090 }
1091
1092 /**
1093  * gst_aac_parse_get_audio_sampling_frequency_index:
1094  * @sample_rate: audio sampling rate.
1095  *
1096  * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1097  * 14496-3, for a given sampling rate.
1098  *
1099  * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1100  * if such a value exists; otherwise G_MAXUINT8.
1101  */
1102 static guint8
1103 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1104 {
1105   switch (sample_rate) {
1106     case 96000:
1107       return 0x0U;
1108     case 88200:
1109       return 0x1U;
1110     case 64000:
1111       return 0x2U;
1112     case 48000:
1113       return 0x3U;
1114     case 44100:
1115       return 0x4U;
1116     case 32000:
1117       return 0x5U;
1118     case 24000:
1119       return 0x6U;
1120     case 22050:
1121       return 0x7U;
1122     case 16000:
1123       return 0x8U;
1124     case 12000:
1125       return 0x9U;
1126     case 11025:
1127       return 0xAU;
1128     case 8000:
1129       return 0xBU;
1130     case 7350:
1131       return 0xCU;
1132     default:
1133       return G_MAXUINT8;
1134   }
1135 }
1136
1137 /**
1138  * gst_aac_parse_prepend_adts_headers:
1139  * @aacparse: #GstAacParse.
1140  * @frame: raw AAC frame to which ADTS headers shall be prepended.
1141  *
1142  * Prepends ADTS headers to a raw AAC audio frame.
1143  *
1144  * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1145  */
1146 static gboolean
1147 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1148     GstBaseParseFrame * frame)
1149 {
1150   GstMemory *mem;
1151   guint8 *adts_headers;
1152   gsize buf_size;
1153   gsize frame_size;
1154   guint8 id, profile, channel_configuration, sampling_frequency_index;
1155
1156   id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1157   profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1158   if (profile == G_MAXUINT8) {
1159     GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1160     return FALSE;
1161   }
1162   channel_configuration =
1163       gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1164   if (channel_configuration == G_MAXUINT8) {
1165     GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1166     return FALSE;
1167   }
1168   sampling_frequency_index =
1169       gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1170   if (sampling_frequency_index == G_MAXUINT8) {
1171     GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1172     return FALSE;
1173   }
1174
1175   frame->out_buffer = gst_buffer_copy (frame->buffer);
1176   buf_size = gst_buffer_get_size (frame->out_buffer);
1177   frame_size = buf_size + ADTS_HEADERS_LENGTH;
1178
1179   if (G_UNLIKELY (frame_size >= 0x4000)) {
1180     GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1181     return FALSE;
1182   }
1183
1184   adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1185
1186   /* Note: no error correction bits are added to the resulting ADTS frames */
1187   adts_headers[0] = 0xFFU;
1188   adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1189   adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1190       (channel_configuration & 0x4U);
1191   adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1192       (guint8) (frame_size >> 11);
1193   adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1194   adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1195   adts_headers[6] = 0xFCU;
1196
1197   mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1198       ADTS_HEADERS_LENGTH, adts_headers, g_free);
1199   gst_buffer_prepend_memory (frame->out_buffer, mem);
1200
1201   return TRUE;
1202 }
1203
1204 /**
1205  * gst_aac_parse_check_valid_frame:
1206  * @parse: #GstBaseParse.
1207  * @frame: #GstBaseParseFrame.
1208  * @skipsize: How much data parent class should skip in order to find the
1209  *            frame header.
1210  *
1211  * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1212  *
1213  * Also determines frame overhead.
1214  * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1215  * a per-frame header. LOAS has 3 bytes.
1216  *
1217  * We're making a couple of simplifying assumptions:
1218  *
1219  * 1. We count Program Configuration Elements rather than searching for them
1220  *    in the streams to discount them - the overhead is negligible.
1221  *
1222  * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1223  *    bits, which should still not be significant enough to warrant the
1224  *    additional parsing through the headers
1225  *
1226  * Returns: a #GstFlowReturn.
1227  */
1228 static GstFlowReturn
1229 gst_aac_parse_handle_frame (GstBaseParse * parse,
1230     GstBaseParseFrame * frame, gint * skipsize)
1231 {
1232   GstMapInfo map;
1233   GstAacParse *aacparse;
1234   gboolean ret = FALSE;
1235   gboolean lost_sync;
1236   GstBuffer *buffer;
1237   guint framesize;
1238   gint rate = 0, channels = 0;
1239
1240   aacparse = GST_AAC_PARSE (parse);
1241   buffer = frame->buffer;
1242
1243   gst_buffer_map (buffer, &map, GST_MAP_READ);
1244
1245   *skipsize = -1;
1246   lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1247
1248   if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1249       aacparse->header_type == DSPAAC_HEADER_NONE) {
1250     /* There is nothing to parse */
1251     framesize = map.size;
1252     ret = TRUE;
1253
1254   } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1255
1256     ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1257         GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1258
1259   } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1260     guint needed_data = 1024;
1261
1262     ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1263         GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1264
1265     if (!ret && needed_data) {
1266       GST_DEBUG ("buffer didn't contain valid frame");
1267       *skipsize = 0;
1268       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1269           needed_data);
1270     }
1271
1272   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1273     guint needed_data = 1024;
1274
1275     ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1276         map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1277
1278     if (!ret && needed_data) {
1279       GST_DEBUG ("buffer didn't contain valid frame");
1280       *skipsize = 0;
1281       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1282           needed_data);
1283     }
1284
1285   } else {
1286     GST_DEBUG ("buffer didn't contain valid frame");
1287     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1288         ADTS_MAX_SIZE);
1289   }
1290
1291   if (G_UNLIKELY (!ret))
1292     goto exit;
1293
1294   if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1295     /* see above */
1296     frame->overhead = 7;
1297
1298     gst_aac_parse_parse_adts_header (aacparse, map.data,
1299         &rate, &channels, NULL, NULL);
1300
1301     GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1302
1303     if (G_UNLIKELY (rate != aacparse->sample_rate
1304             || channels != aacparse->channels)) {
1305       aacparse->sample_rate = rate;
1306       aacparse->channels = channels;
1307
1308       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1309         /* If linking fails, we need to return appropriate error */
1310         ret = GST_FLOW_NOT_LINKED;
1311       }
1312
1313       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1314           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1315     }
1316   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1317     gboolean setcaps = FALSE;
1318
1319     /* see above */
1320     frame->overhead = 3;
1321
1322     if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1323             &channels, NULL) || !rate || !channels) {
1324       /* This is pretty normal when skipping data at the start of
1325        * random stream (MPEG-TS capture for example) */
1326       GST_DEBUG_OBJECT (aacparse, "Error reading LOAS config. Skipping.");
1327       /* Since we don't fully parse the LOAS config, we don't know for sure
1328        * how much to skip. Just skip 1 to end up to the next marker and
1329        * resume parsing from there */
1330       *skipsize = 1;
1331       goto exit;
1332     }
1333
1334     if (G_UNLIKELY (rate != aacparse->sample_rate
1335             || channels != aacparse->channels)) {
1336       aacparse->sample_rate = rate;
1337       aacparse->channels = channels;
1338       setcaps = TRUE;
1339       GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1340           channels);
1341     }
1342
1343     /* We want to set caps both at start, and when rate/channels change.
1344        Since only some LOAS frames have that info, we may receive frames
1345        before knowing about rate/channels. */
1346     if (setcaps
1347         || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1348       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1349         /* If linking fails, we need to return appropriate error */
1350         ret = GST_FLOW_NOT_LINKED;
1351       }
1352
1353       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1354           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1355     }
1356   }
1357
1358   if (aacparse->header_type == DSPAAC_HEADER_NONE
1359       && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1360     if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1361       GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1362       ret = GST_FLOW_ERROR;
1363     }
1364   }
1365
1366 exit:
1367   gst_buffer_unmap (buffer, &map);
1368
1369   if (ret) {
1370     /* found, skip if needed */
1371     if (*skipsize > 0)
1372       return GST_FLOW_OK;
1373     *skipsize = 0;
1374   } else {
1375     if (*skipsize < 0)
1376       *skipsize = 1;
1377   }
1378
1379   if (ret && framesize <= map.size) {
1380     return gst_base_parse_finish_frame (parse, frame, framesize);
1381   }
1382
1383   return GST_FLOW_OK;
1384 }
1385
1386 static GstFlowReturn
1387 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1388 {
1389   GstAacParse *aacparse = GST_AAC_PARSE (parse);
1390
1391   if (!aacparse->sent_codec_tag) {
1392     GstTagList *taglist;
1393     GstCaps *caps;
1394
1395     /* codec tag */
1396     caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1397     if (caps == NULL) {
1398       if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
1399         GST_INFO_OBJECT (parse, "Src pad is flushing");
1400         return GST_FLOW_FLUSHING;
1401       } else {
1402         GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
1403         return GST_FLOW_NOT_NEGOTIATED;
1404       }
1405     }
1406
1407     taglist = gst_tag_list_new_empty ();
1408     gst_pb_utils_add_codec_description_to_tag_list (taglist,
1409         GST_TAG_AUDIO_CODEC, caps);
1410     gst_caps_unref (caps);
1411
1412     gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
1413     gst_tag_list_unref (taglist);
1414
1415     /* also signals the end of first-frame processing */
1416     aacparse->sent_codec_tag = TRUE;
1417   }
1418
1419   /* As a special case, we can remove the ADTS framing and output raw AAC. */
1420   if (aacparse->header_type == DSPAAC_HEADER_ADTS
1421       && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1422     guint header_size;
1423     GstMapInfo map;
1424     gst_buffer_map (frame->buffer, &map, GST_MAP_READ);
1425     header_size = (map.data[1] & 1) ? 7 : 9;    /* optional CRC */
1426     gst_buffer_unmap (frame->buffer, &map);
1427     gst_buffer_resize (frame->buffer, header_size,
1428         gst_buffer_get_size (frame->buffer) - header_size);
1429   }
1430
1431   return GST_FLOW_OK;
1432 }
1433
1434
1435 /**
1436  * gst_aac_parse_start:
1437  * @parse: #GstBaseParse.
1438  *
1439  * Implementation of "start" vmethod in #GstBaseParse class.
1440  *
1441  * Returns: TRUE if startup succeeded.
1442  */
1443 static gboolean
1444 gst_aac_parse_start (GstBaseParse * parse)
1445 {
1446   GstAacParse *aacparse;
1447
1448   aacparse = GST_AAC_PARSE (parse);
1449   GST_DEBUG ("start");
1450   aacparse->frame_samples = 1024;
1451   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1452   aacparse->sent_codec_tag = FALSE;
1453   aacparse->last_parsed_channels = 0;
1454   aacparse->last_parsed_sample_rate = 0;
1455   return TRUE;
1456 }
1457
1458
1459 /**
1460  * gst_aac_parse_stop:
1461  * @parse: #GstBaseParse.
1462  *
1463  * Implementation of "stop" vmethod in #GstBaseParse class.
1464  *
1465  * Returns: TRUE is stopping succeeded.
1466  */
1467 static gboolean
1468 gst_aac_parse_stop (GstBaseParse * parse)
1469 {
1470   GST_DEBUG ("stop");
1471   return TRUE;
1472 }
1473
1474 static void
1475 remove_fields (GstCaps * caps)
1476 {
1477   guint i, n;
1478
1479   n = gst_caps_get_size (caps);
1480   for (i = 0; i < n; i++) {
1481     GstStructure *s = gst_caps_get_structure (caps, i);
1482
1483     gst_structure_remove_field (s, "framed");
1484   }
1485 }
1486
1487 static void
1488 add_conversion_fields (GstCaps * caps)
1489 {
1490   guint i, n;
1491
1492   n = gst_caps_get_size (caps);
1493   for (i = 0; i < n; i++) {
1494     GstStructure *s = gst_caps_get_structure (caps, i);
1495
1496     if (gst_structure_has_field (s, "stream-format")) {
1497       const GValue *v = gst_structure_get_value (s, "stream-format");
1498
1499       if (G_VALUE_HOLDS_STRING (v)) {
1500         const gchar *str = g_value_get_string (v);
1501
1502         if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1503           GValue va = G_VALUE_INIT;
1504           GValue vs = G_VALUE_INIT;
1505
1506           g_value_init (&va, GST_TYPE_LIST);
1507           g_value_init (&vs, G_TYPE_STRING);
1508           g_value_set_string (&vs, "adts");
1509           gst_value_list_append_value (&va, &vs);
1510           g_value_set_string (&vs, "raw");
1511           gst_value_list_append_value (&va, &vs);
1512           gst_structure_set_value (s, "stream-format", &va);
1513           g_value_unset (&va);
1514           g_value_unset (&vs);
1515         }
1516       } else if (GST_VALUE_HOLDS_LIST (v)) {
1517         gboolean contains_raw = FALSE;
1518         gboolean contains_adts = FALSE;
1519         guint m = gst_value_list_get_size (v), j;
1520
1521         for (j = 0; j < m; j++) {
1522           const GValue *ve = gst_value_list_get_value (v, j);
1523           const gchar *str;
1524
1525           if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1526             if (strcmp (str, "adts") == 0)
1527               contains_adts = TRUE;
1528             else if (strcmp (str, "raw") == 0)
1529               contains_raw = TRUE;
1530           }
1531         }
1532
1533         if (contains_adts || contains_raw) {
1534           GValue va = G_VALUE_INIT;
1535           GValue vs = G_VALUE_INIT;
1536
1537           g_value_init (&va, GST_TYPE_LIST);
1538           g_value_init (&vs, G_TYPE_STRING);
1539           g_value_copy (v, &va);
1540
1541           if (!contains_raw) {
1542             g_value_set_string (&vs, "raw");
1543             gst_value_list_append_value (&va, &vs);
1544           }
1545           if (!contains_adts) {
1546             g_value_set_string (&vs, "adts");
1547             gst_value_list_append_value (&va, &vs);
1548           }
1549
1550           gst_structure_set_value (s, "stream-format", &va);
1551
1552           g_value_unset (&vs);
1553           g_value_unset (&va);
1554         }
1555       }
1556     }
1557   }
1558 }
1559
1560 static GstCaps *
1561 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1562 {
1563   GstCaps *peercaps, *templ;
1564   GstCaps *res;
1565
1566   templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1567
1568   if (filter) {
1569     GstCaps *fcopy = gst_caps_copy (filter);
1570     /* Remove the fields we convert */
1571     remove_fields (fcopy);
1572     add_conversion_fields (fcopy);
1573     peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1574     gst_caps_unref (fcopy);
1575   } else
1576     peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1577
1578   if (peercaps) {
1579     peercaps = gst_caps_make_writable (peercaps);
1580     /* Remove the fields we convert */
1581     remove_fields (peercaps);
1582     add_conversion_fields (peercaps);
1583
1584     res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1585     gst_caps_unref (peercaps);
1586     gst_caps_unref (templ);
1587   } else {
1588     res = templ;
1589   }
1590
1591   if (filter) {
1592     GstCaps *intersection;
1593
1594     intersection =
1595         gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1596     gst_caps_unref (res);
1597     res = intersection;
1598   }
1599
1600   return res;
1601 }
1602
1603 static gboolean
1604 gst_aac_parse_src_event (GstBaseParse * parse, GstEvent * event)
1605 {
1606   GstAacParse *aacparse = GST_AAC_PARSE (parse);
1607
1608   if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
1609     aacparse->last_parsed_channels = 0;
1610     aacparse->last_parsed_sample_rate = 0;
1611   }
1612
1613   return GST_BASE_PARSE_CLASS (parent_class)->src_event (parse, event);
1614 }