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