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