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