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