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