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