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., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, 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 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 "gstaacparse.h"
  49
  50
  51 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  52     GST_PAD_SRC,
  53     GST_PAD_ALWAYS,
  54     GST_STATIC_CAPS ("audio/mpeg, "
  55         "framed = (boolean) true, " "mpegversion = (int) { 2, 4 }, "
  56         "stream-format = (string) { raw, adts, adif, loas };"));
  57
  58 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  59     GST_PAD_SINK,
  60     GST_PAD_ALWAYS,
  61     GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) { 2, 4 };"));
  62
  63 GST_DEBUG_CATEGORY_STATIC (aacparse_debug);
  64 #define GST_CAT_DEFAULT aacparse_debug
  65
  66
  67 #define ADIF_MAX_SIZE 40        /* Should be enough */
  68 #define ADTS_MAX_SIZE 10        /* Should be enough */
  69 #define LOAS_MAX_SIZE 3         /* Should be enough */
  70
  71
  72 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
  73
  74 static const gint loas_sample_rate_table[32] = {
  75   96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
  76   16000, 12000, 11025, 8000, 7350, 0, 0, 0
  77 };
  78
  79 static const gint loas_channels_table[32] = {
  80   0, 1, 2, 3, 4, 5, 6, 8,
  81   0, 0, 0, 0, 0, 0, 0, 0
  82 };
  83
  84 static gboolean gst_aac_parse_start (GstBaseParse * parse);
  85 static gboolean gst_aac_parse_stop (GstBaseParse * parse);
  86
  87 static gboolean gst_aac_parse_sink_setcaps (GstBaseParse * parse,
  88     GstCaps * caps);
  89 static GstCaps *gst_aac_parse_sink_getcaps (GstBaseParse * parse,
  90     GstCaps * filter);
  91
  92 static GstFlowReturn gst_aac_parse_handle_frame (GstBaseParse * parse,
  93     GstBaseParseFrame * frame, gint * skipsize);
  94
  95 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
  96
  97 static inline gint
  98 gst_aac_parse_get_sample_rate_from_index (guint sr_idx)
  99 {
 100   static const guint aac_sample_rates[] = { 96000, 88200, 64000, 48000, 44100,
 101     32000, 24000, 22050, 16000, 12000, 11025, 8000
 102   };
 103
 104   if (sr_idx < G_N_ELEMENTS (aac_sample_rates))
 105     return aac_sample_rates[sr_idx];
 106   GST_WARNING ("Invalid sample rate index %u", sr_idx);
 107   return 0;
 108 }
 109
 110 /**
 111  * gst_aac_parse_class_init:
 112  * @klass: #GstAacParseClass.
 113  *
 114  */
 115 static void
 116 gst_aac_parse_class_init (GstAacParseClass * klass)
 117 {
 118   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 119   GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
 120
 121   GST_DEBUG_CATEGORY_INIT (aacparse_debug, "aacparse", 0,
 122       "AAC audio stream parser");
 123
 124   gst_element_class_add_pad_template (element_class,
 125       gst_static_pad_template_get (&sink_template));
 126   gst_element_class_add_pad_template (element_class,
 127       gst_static_pad_template_get (&src_template));
 128
 129   gst_element_class_set_details_simple (element_class,
 130       "AAC audio stream parser", "Codec/Parser/Audio",
 131       "Advanced Audio Coding parser", "Stefan Kost <stefan.kost@nokia.com>");
 132
 133   parse_class->start = GST_DEBUG_FUNCPTR (gst_aac_parse_start);
 134   parse_class->stop = GST_DEBUG_FUNCPTR (gst_aac_parse_stop);
 135   parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_setcaps);
 136   parse_class->get_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_getcaps);
 137   parse_class->handle_frame = GST_DEBUG_FUNCPTR (gst_aac_parse_handle_frame);
 138 }
 139
 140
 141 /**
 142  * gst_aac_parse_init:
 143  * @aacparse: #GstAacParse.
 144  * @klass: #GstAacParseClass.
 145  *
 146  */
 147 static void
 148 gst_aac_parse_init (GstAacParse * aacparse)
 149 {
 150   GST_DEBUG ("initialized");
 151 }
 152
 153
 154 /**
 155  * gst_aac_parse_set_src_caps:
 156  * @aacparse: #GstAacParse.
 157  * @sink_caps: (proposed) caps of sink pad
 158  *
 159  * Set source pad caps according to current knowledge about the
 160  * audio stream.
 161  *
 162  * Returns: TRUE if caps were successfully set.
 163  */
 164 static gboolean
 165 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
 166 {
 167   GstStructure *s;
 168   GstCaps *src_caps = NULL;
 169   gboolean res = FALSE;
 170   const gchar *stream_format;
 171
 172   GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
 173   if (sink_caps)
 174     src_caps = gst_caps_copy (sink_caps);
 175   else
 176     src_caps = gst_caps_new_empty_simple ("audio/mpeg");
 177
 178   gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
 179       "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
 180
 181   switch (aacparse->header_type) {
 182     case DSPAAC_HEADER_NONE:
 183       stream_format = "raw";
 184       break;
 185     case DSPAAC_HEADER_ADTS:
 186       stream_format = "adts";
 187       break;
 188     case DSPAAC_HEADER_ADIF:
 189       stream_format = "adif";
 190       break;
 191     case DSPAAC_HEADER_LOAS:
 192       stream_format = "loas";
 193       break;
 194     default:
 195       stream_format = NULL;
 196   }
 197
 198   s = gst_caps_get_structure (src_caps, 0);
 199   if (aacparse->sample_rate > 0)
 200     gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
 201   if (aacparse->channels > 0)
 202     gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
 203   if (stream_format)
 204     gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
 205
 206   GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
 207
 208   res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
 209   gst_caps_unref (src_caps);
 210   return res;
 211 }
 212
 213
 214 /**
 215  * gst_aac_parse_sink_setcaps:
 216  * @sinkpad: GstPad
 217  * @caps: GstCaps
 218  *
 219  * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
 220  *
 221  * Returns: TRUE on success.
 222  */
 223 static gboolean
 224 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
 225 {
 226   GstAacParse *aacparse;
 227   GstStructure *structure;
 228   gchar *caps_str;
 229   const GValue *value;
 230
 231   aacparse = GST_AAC_PARSE (parse);
 232   structure = gst_caps_get_structure (caps, 0);
 233   caps_str = gst_caps_to_string (caps);
 234
 235   GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
 236   g_free (caps_str);
 237
 238   /* This is needed at least in case of RTP
 239    * Parses the codec_data information to get ObjectType,
 240    * number of channels and samplerate */
 241   value = gst_structure_get_value (structure, "codec_data");
 242   if (value) {
 243     GstBuffer *buf = gst_value_get_buffer (value);
 244
 245     if (buf) {
 246       GstMapInfo map;
 247       guint sr_idx;
 248
 249       gst_buffer_map (buf, &map, GST_MAP_READ);
 250
 251       sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
 252       aacparse->object_type = (map.data[0] & 0xf8) >> 3;
 253       aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
 254       aacparse->channels = (map.data[1] & 0x78) >> 3;
 255       aacparse->header_type = DSPAAC_HEADER_NONE;
 256       aacparse->mpegversion = 4;
 257       aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
 258       gst_buffer_unmap (buf, &map);
 259
 260       GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
 261           "samples=%d", aacparse->object_type, aacparse->sample_rate,
 262           aacparse->channels, aacparse->frame_samples);
 263
 264       /* arrange for metadata and get out of the way */
 265       gst_aac_parse_set_src_caps (aacparse, caps);
 266       gst_base_parse_set_passthrough (parse, TRUE);
 267     } else
 268       return FALSE;
 269
 270     /* caps info overrides */
 271     gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
 272     gst_structure_get_int (structure, "channels", &aacparse->channels);
 273   } else {
 274     gst_base_parse_set_passthrough (parse, FALSE);
 275   }
 276
 277   return TRUE;
 278 }
 279
 280
 281 /**
 282  * gst_aac_parse_adts_get_frame_len:
 283  * @data: block of data containing an ADTS header.
 284  *
 285  * This function calculates ADTS frame length from the given header.
 286  *
 287  * Returns: size of the ADTS frame.
 288  */
 289 static inline guint
 290 gst_aac_parse_adts_get_frame_len (const guint8 * data)
 291 {
 292   return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
 293 }
 294
 295
 296 /**
 297  * gst_aac_parse_check_adts_frame:
 298  * @aacparse: #GstAacParse.
 299  * @data: Data to be checked.
 300  * @avail: Amount of data passed.
 301  * @framesize: If valid ADTS frame was found, this will be set to tell the
 302  *             found frame size in bytes.
 303  * @needed_data: If frame was not found, this may be set to tell how much
 304  *               more data is needed in the next round to detect the frame
 305  *               reliably. This may happen when a frame header candidate
 306  *               is found but it cannot be guaranteed to be the header without
 307  *               peeking the following data.
 308  *
 309  * Check if the given data contains contains ADTS frame. The algorithm
 310  * will examine ADTS frame header and calculate the frame size. Also, another
 311  * consecutive ADTS frame header need to be present after the found frame.
 312  * Otherwise the data is not considered as a valid ADTS frame. However, this
 313  * "extra check" is omitted when EOS has been received. In this case it is
 314  * enough when data[0] contains a valid ADTS header.
 315  *
 316  * This function may set the #needed_data to indicate that a possible frame
 317  * candidate has been found, but more data (#needed_data bytes) is needed to
 318  * be absolutely sure. When this situation occurs, FALSE will be returned.
 319  *
 320  * When a valid frame is detected, this function will use
 321  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 322  * to set the needed bytes for next frame.This way next data chunk is already
 323  * of correct size.
 324  *
 325  * Returns: TRUE if the given data contains a valid ADTS header.
 326  */
 327 static gboolean
 328 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
 329     const guint8 * data, const guint avail, gboolean drain,
 330     guint * framesize, guint * needed_data)
 331 {
 332   *needed_data = 0;
 333
 334   if (G_UNLIKELY (avail < 2))
 335     return FALSE;
 336
 337   if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
 338     *framesize = gst_aac_parse_adts_get_frame_len (data);
 339
 340     /* In EOS mode this is enough. No need to examine the data further.
 341        We also relax the check when we have sync, on the assumption that
 342        if we're not looking at random data, we have a much higher chance
 343        to get the correct sync, and this avoids losing two frames when
 344        a single bit corruption happens. */
 345     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 346       return TRUE;
 347     }
 348
 349     if (*framesize + ADTS_MAX_SIZE > avail) {
 350       /* We have found a possible frame header candidate, but can't be
 351          sure since we don't have enough data to check the next frame */
 352       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 353           *framesize + ADTS_MAX_SIZE, avail);
 354       *needed_data = *framesize + ADTS_MAX_SIZE;
 355       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 356           *framesize + ADTS_MAX_SIZE);
 357       return FALSE;
 358     }
 359
 360     if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
 361       guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
 362
 363       GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
 364       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 365           nextlen + ADTS_MAX_SIZE);
 366       return TRUE;
 367     }
 368   }
 369   return FALSE;
 370 }
 371
 372 static gboolean
 373 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
 374     guint32 * value)
 375 {
 376   guint8 bytes, i, byte;
 377
 378   *value = 0;
 379   if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
 380     return FALSE;
 381   for (i = 0; i < bytes; ++i) {
 382     *value <<= 8;
 383     if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
 384       return FALSE;
 385     *value += byte;
 386   }
 387   return TRUE;
 388 }
 389
 390 static gboolean
 391 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
 392     guint8 * audio_object_type)
 393 {
 394   if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
 395     return FALSE;
 396   if (*audio_object_type == 31) {
 397     if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
 398       return FALSE;
 399     *audio_object_type += 32;
 400   }
 401   GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
 402   return TRUE;
 403 }
 404
 405 static gboolean
 406 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
 407     gint * sample_rate)
 408 {
 409   guint8 sampling_frequency_index;
 410   if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
 411     return FALSE;
 412   GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
 413       sampling_frequency_index);
 414   if (sampling_frequency_index == 0xf) {
 415     guint32 sampling_rate;
 416     if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
 417       return FALSE;
 418     *sample_rate = sampling_rate;
 419   } else {
 420     *sample_rate = loas_sample_rate_table[sampling_frequency_index];
 421     if (!*sample_rate)
 422       return FALSE;
 423   }
 424   return TRUE;
 425 }
 426
 427 /* See table 1.13 in ISO/IEC 14496-3 */
 428 static gboolean
 429 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
 430     GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
 431 {
 432   guint8 audio_object_type, channel_configuration;
 433
 434   if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
 435     return FALSE;
 436
 437   if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
 438     return FALSE;
 439
 440   if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
 441     return FALSE;
 442   GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
 443   *channels = loas_channels_table[channel_configuration];
 444   if (!*channels)
 445     return FALSE;
 446
 447   if (audio_object_type == 5) {
 448     GST_LOG_OBJECT (aacparse,
 449         "Audio object type 5, so rereading sampling rate...");
 450     if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
 451       return FALSE;
 452   }
 453
 454   GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
 455       *sample_rate, *channels);
 456
 457   /* There's LOTS of stuff next, but we ignore it for now as we have
 458      what we want (sample rate and number of channels */
 459   GST_DEBUG_OBJECT (aacparse,
 460       "Need more code to parse humongous LOAS data, currently ignored");
 461   if (bits)
 462     *bits = 0;
 463   return TRUE;
 464 }
 465
 466
 467 static gboolean
 468 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
 469     guint avail, gint * sample_rate, gint * channels, gint * version)
 470 {
 471   GstBitReader br;
 472   guint8 u8, v, vA;
 473
 474   /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
 475   if (version)
 476     *version = 4;
 477
 478   gst_bit_reader_init (&br, data, avail);
 479
 480   /* skip sync word (11 bits) and size (13 bits) */
 481   gst_bit_reader_skip (&br, 11 + 13);
 482
 483   /* First bit is "use last config" */
 484   if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
 485     return FALSE;
 486   if (u8) {
 487     GST_DEBUG_OBJECT (aacparse, "Frame uses previous config");
 488     if (!aacparse->sample_rate || !aacparse->channels) {
 489       GST_WARNING_OBJECT (aacparse, "No previous config to use");
 490     }
 491     *sample_rate = aacparse->sample_rate;
 492     *channels = aacparse->channels;
 493     return TRUE;
 494   }
 495
 496   GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
 497
 498   if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
 499     return FALSE;
 500   if (v) {
 501     if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
 502       return FALSE;
 503   } else
 504     vA = 0;
 505
 506   GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
 507   if (vA == 0) {
 508     guint8 same_time, subframes, num_program, prog;
 509     if (v == 1) {
 510       guint32 value;
 511       if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
 512         return FALSE;
 513     }
 514     if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
 515       return FALSE;
 516     if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
 517       return FALSE;
 518     if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
 519       return FALSE;
 520     GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
 521         same_time, subframes, num_program);
 522
 523     for (prog = 0; prog <= num_program; ++prog) {
 524       guint8 num_layer, layer;
 525       if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
 526         return FALSE;
 527       GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
 528
 529       for (layer = 0; layer <= num_layer; ++layer) {
 530         guint8 use_same_config;
 531         if (prog == 0 && layer == 0) {
 532           use_same_config = 0;
 533         } else {
 534           if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
 535             return FALSE;
 536         }
 537         if (!use_same_config) {
 538           if (v == 0) {
 539             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 540                     sample_rate, channels, NULL))
 541               return FALSE;
 542           } else {
 543             guint32 bits, asc_len;
 544             if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
 545               return FALSE;
 546             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 547                     sample_rate, channels, &bits))
 548               return FALSE;
 549             asc_len -= bits;
 550             gst_bit_reader_skip (&br, asc_len);
 551           }
 552         }
 553       }
 554     }
 555     GST_WARNING_OBJECT (aacparse, "More data ignored");
 556   } else {
 557     GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
 558   }
 559   return TRUE;
 560 }
 561
 562 /**
 563  * gst_aac_parse_loas_get_frame_len:
 564  * @data: block of data containing a LOAS header.
 565  *
 566  * This function calculates LOAS frame length from the given header.
 567  *
 568  * Returns: size of the LOAS frame.
 569  */
 570 static inline guint
 571 gst_aac_parse_loas_get_frame_len (const guint8 * data)
 572 {
 573   return (((data[1] & 0x1f) << 8) | data[2]) + 3;
 574 }
 575
 576
 577 /**
 578  * gst_aac_parse_check_loas_frame:
 579  * @aacparse: #GstAacParse.
 580  * @data: Data to be checked.
 581  * @avail: Amount of data passed.
 582  * @framesize: If valid LOAS frame was found, this will be set to tell the
 583  *             found frame size in bytes.
 584  * @needed_data: If frame was not found, this may be set to tell how much
 585  *               more data is needed in the next round to detect the frame
 586  *               reliably. This may happen when a frame header candidate
 587  *               is found but it cannot be guaranteed to be the header without
 588  *               peeking the following data.
 589  *
 590  * Check if the given data contains contains LOAS frame. The algorithm
 591  * will examine LOAS frame header and calculate the frame size. Also, another
 592  * consecutive LOAS frame header need to be present after the found frame.
 593  * Otherwise the data is not considered as a valid LOAS frame. However, this
 594  * "extra check" is omitted when EOS has been received. In this case it is
 595  * enough when data[0] contains a valid LOAS header.
 596  *
 597  * This function may set the #needed_data to indicate that a possible frame
 598  * candidate has been found, but more data (#needed_data bytes) is needed to
 599  * be absolutely sure. When this situation occurs, FALSE will be returned.
 600  *
 601  * When a valid frame is detected, this function will use
 602  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 603  * to set the needed bytes for next frame.This way next data chunk is already
 604  * of correct size.
 605  *
 606  * LOAS can have three different formats, if I read the spec correctly. Only
 607  * one of them is supported here, as the two samples I have use this one.
 608  *
 609  * Returns: TRUE if the given data contains a valid LOAS header.
 610  */
 611 static gboolean
 612 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
 613     const guint8 * data, const guint avail, gboolean drain,
 614     guint * framesize, guint * needed_data)
 615 {
 616   *needed_data = 0;
 617
 618   /* 3 byte header */
 619   if (G_UNLIKELY (avail < 3))
 620     return FALSE;
 621
 622   if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
 623     *framesize = gst_aac_parse_loas_get_frame_len (data);
 624     GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
 625
 626     /* In EOS mode this is enough. No need to examine the data further.
 627        We also relax the check when we have sync, on the assumption that
 628        if we're not looking at random data, we have a much higher chance
 629        to get the correct sync, and this avoids losing two frames when
 630        a single bit corruption happens. */
 631     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 632       return TRUE;
 633     }
 634
 635     if (*framesize + LOAS_MAX_SIZE > avail) {
 636       /* We have found a possible frame header candidate, but can't be
 637          sure since we don't have enough data to check the next frame */
 638       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 639           *framesize + LOAS_MAX_SIZE, avail);
 640       *needed_data = *framesize + LOAS_MAX_SIZE;
 641       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 642           *framesize + LOAS_MAX_SIZE);
 643       return FALSE;
 644     }
 645
 646     if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
 647       guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
 648
 649       GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
 650       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 651           nextlen + LOAS_MAX_SIZE);
 652       return TRUE;
 653     }
 654   }
 655   return FALSE;
 656 }
 657
 658 /* caller ensure sufficient data */
 659 static inline void
 660 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
 661     gint * rate, gint * channels, gint * object, gint * version)
 662 {
 663
 664   if (rate) {
 665     gint sr_idx = (data[2] & 0x3c) >> 2;
 666
 667     *rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
 668   }
 669   if (channels)
 670     *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
 671
 672   if (version)
 673     *version = (data[1] & 0x08) ? 2 : 4;
 674   if (object)
 675     *object = (data[2] & 0xc0) >> 6;
 676 }
 677
 678 /**
 679  * gst_aac_parse_detect_stream:
 680  * @aacparse: #GstAacParse.
 681  * @data: A block of data that needs to be examined for stream characteristics.
 682  * @avail: Size of the given datablock.
 683  * @framesize: If valid stream was found, this will be set to tell the
 684  *             first frame size in bytes.
 685  * @skipsize: If valid stream was found, this will be set to tell the first
 686  *            audio frame position within the given data.
 687  *
 688  * Examines the given piece of data and try to detect the format of it. It
 689  * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
 690  * header. If the stream is detected, TRUE will be returned and #framesize
 691  * is set to indicate the found frame size. Additionally, #skipsize might
 692  * be set to indicate the number of bytes that need to be skipped, a.k.a. the
 693  * position of the frame inside given data chunk.
 694  *
 695  * Returns: TRUE on success.
 696  */
 697 static gboolean
 698 gst_aac_parse_detect_stream (GstAacParse * aacparse,
 699     const guint8 * data, const guint avail, gboolean drain,
 700     guint * framesize, gint * skipsize)
 701 {
 702   gboolean found = FALSE;
 703   guint need_data_adts = 0, need_data_loas;
 704   guint i = 0;
 705
 706   GST_DEBUG_OBJECT (aacparse, "Parsing header data");
 707
 708   /* FIXME: No need to check for ADIF if we are not in the beginning of the
 709      stream */
 710
 711   /* Can we even parse the header? */
 712   if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
 713     GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
 714     return FALSE;
 715   }
 716
 717   for (i = 0; i < avail - 4; i++) {
 718     if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
 719         ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) ||
 720         strncmp ((char *) data + i, "ADIF", 4) == 0) {
 721       GST_DEBUG_OBJECT (aacparse, "Found ADIF signature at offset %u", i);
 722       found = TRUE;
 723
 724       if (i) {
 725         /* Trick: tell the parent class that we didn't find the frame yet,
 726            but make it skip 'i' amount of bytes. Next time we arrive
 727            here we have full frame in the beginning of the data. */
 728         *skipsize = i;
 729         return FALSE;
 730       }
 731       break;
 732     }
 733   }
 734   if (!found) {
 735     if (i)
 736       *skipsize = i;
 737     return FALSE;
 738   }
 739
 740   if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
 741           framesize, &need_data_adts)) {
 742     gint rate, channels;
 743
 744     GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
 745
 746     aacparse->header_type = DSPAAC_HEADER_ADTS;
 747     gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
 748         &aacparse->object_type, &aacparse->mpegversion);
 749
 750     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 751         aacparse->frame_samples, 2, 2);
 752
 753     GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
 754         rate, channels, aacparse->object_type, aacparse->mpegversion);
 755
 756     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 757
 758     return TRUE;
 759   }
 760
 761   if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
 762           framesize, &need_data_loas)) {
 763     gint rate, channels;
 764
 765     GST_INFO ("LOAS, framesize: %d", *framesize);
 766
 767     aacparse->header_type = DSPAAC_HEADER_LOAS;
 768
 769     if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
 770             &channels, &aacparse->mpegversion)) {
 771       GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
 772       return FALSE;
 773     }
 774
 775     if (rate && channels) {
 776       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 777           aacparse->frame_samples, 2, 2);
 778
 779       GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
 780           rate, channels, aacparse->object_type, aacparse->mpegversion);
 781       aacparse->sample_rate = rate;
 782       aacparse->channels = channels;
 783     }
 784
 785     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 786
 787     return TRUE;
 788   }
 789
 790   if (need_data_adts || need_data_loas) {
 791     /* This tells the parent class not to skip any data */
 792     *skipsize = 0;
 793     return FALSE;
 794   }
 795
 796   if (avail < ADIF_MAX_SIZE)
 797     return FALSE;
 798
 799   if (memcmp (data + i, "ADIF", 4) == 0) {
 800     const guint8 *adif;
 801     int skip_size = 0;
 802     int bitstream_type;
 803     int sr_idx;
 804     GstCaps *sinkcaps;
 805
 806     aacparse->header_type = DSPAAC_HEADER_ADIF;
 807     aacparse->mpegversion = 4;
 808
 809     /* Skip the "ADIF" bytes */
 810     adif = data + i + 4;
 811
 812     /* copyright string */
 813     if (adif[0] & 0x80)
 814       skip_size += 9;           /* skip 9 bytes */
 815
 816     bitstream_type = adif[0 + skip_size] & 0x10;
 817     aacparse->bitrate =
 818         ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
 819         ((unsigned int) adif[1 + skip_size] << 11) |
 820         ((unsigned int) adif[2 + skip_size] << 3) |
 821         ((unsigned int) adif[3 + skip_size] & 0xe0);
 822
 823     /* CBR */
 824     if (bitstream_type == 0) {
 825 #if 0
 826       /* Buffer fullness parsing. Currently not needed... */
 827       guint num_elems = 0;
 828       guint fullness = 0;
 829
 830       num_elems = (adif[3 + skip_size] & 0x1e);
 831       GST_INFO ("ADIF num_config_elems: %d", num_elems);
 832
 833       fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
 834           ((unsigned int) adif[4 + skip_size] << 11) |
 835           ((unsigned int) adif[5 + skip_size] << 3) |
 836           ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
 837
 838       GST_INFO ("ADIF buffer fullness: %d", fullness);
 839 #endif
 840       aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
 841           ((adif[7 + skip_size] & 0x80) >> 7);
 842       sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
 843     }
 844     /* VBR */
 845     else {
 846       aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
 847       sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
 848           ((adif[5 + skip_size] & 0x80) >> 7);
 849     }
 850
 851     /* FIXME: This gives totally wrong results. Duration calculation cannot
 852        be based on this */
 853     aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
 854
 855     /* baseparse is not given any fps,
 856      * so it will give up on timestamps, seeking, etc */
 857
 858     /* FIXME: Can we assume this? */
 859     aacparse->channels = 2;
 860
 861     GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
 862         aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
 863
 864     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
 865
 866     /* arrange for metadata and get out of the way */
 867     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
 868     gst_aac_parse_set_src_caps (aacparse, sinkcaps);
 869     if (sinkcaps)
 870       gst_caps_unref (sinkcaps);
 871
 872     /* not syncable, not easily seekable (unless we push data from start */
 873     gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
 874     gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
 875     gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
 876
 877     *framesize = avail;
 878     return TRUE;
 879   }
 880
 881   /* This should never happen */
 882   return FALSE;
 883 }
 884
 885
 886 /**
 887  * gst_aac_parse_check_valid_frame:
 888  * @parse: #GstBaseParse.
 889  * @frame: #GstBaseParseFrame.
 890  * @skipsize: How much data parent class should skip in order to find the
 891  *            frame header.
 892  *
 893  * Implementation of "handle_frame" vmethod in #GstBaseParse class.
 894  *
 895  * Also determines frame overhead.
 896  * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
 897  * a per-frame header. LOAS has 3 bytes.
 898  *
 899  * We're making a couple of simplifying assumptions:
 900  *
 901  * 1. We count Program Configuration Elements rather than searching for them
 902  *    in the streams to discount them - the overhead is negligible.
 903  *
 904  * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
 905  *    bits, which should still not be significant enough to warrant the
 906  *    additional parsing through the headers
 907  *
 908  * Returns: a #GstFlowReturn.
 909  */
 910 static GstFlowReturn
 911 gst_aac_parse_handle_frame (GstBaseParse * parse,
 912     GstBaseParseFrame * frame, gint * skipsize)
 913 {
 914   GstMapInfo map;
 915   GstAacParse *aacparse;
 916   gboolean ret = FALSE;
 917   gboolean lost_sync;
 918   GstBuffer *buffer;
 919   guint framesize;
 920   gint rate, channels;
 921
 922   aacparse = GST_AAC_PARSE (parse);
 923   buffer = frame->buffer;
 924
 925   gst_buffer_map (buffer, &map, GST_MAP_READ);
 926
 927   *skipsize = -1;
 928   lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
 929
 930   if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
 931       aacparse->header_type == DSPAAC_HEADER_NONE) {
 932     /* There is nothing to parse */
 933     framesize = map.size;
 934     ret = TRUE;
 935
 936   } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
 937
 938     ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
 939         GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
 940
 941   } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 942     guint needed_data = 1024;
 943
 944     ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
 945         GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
 946
 947     if (!ret) {
 948       GST_DEBUG ("buffer didn't contain valid frame");
 949       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 950           needed_data);
 951     }
 952
 953   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
 954     guint needed_data = 1024;
 955
 956     ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
 957         map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
 958
 959     if (!ret) {
 960       GST_DEBUG ("buffer didn't contain valid frame");
 961       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 962           needed_data);
 963     }
 964
 965   } else {
 966     GST_DEBUG ("buffer didn't contain valid frame");
 967     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 968         ADTS_MAX_SIZE);
 969   }
 970
 971   if (G_UNLIKELY (!ret))
 972     goto exit;
 973
 974   if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 975     /* see above */
 976     frame->overhead = 7;
 977
 978     gst_aac_parse_parse_adts_header (aacparse, map.data,
 979         &rate, &channels, NULL, NULL);
 980
 981     GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
 982
 983     if (G_UNLIKELY (rate != aacparse->sample_rate
 984             || channels != aacparse->channels)) {
 985       aacparse->sample_rate = rate;
 986       aacparse->channels = channels;
 987
 988       GST_DEBUG_OBJECT (aacparse, "here");
 989
 990       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
 991         /* If linking fails, we need to return appropriate error */
 992         ret = GST_FLOW_NOT_LINKED;
 993       }
 994
 995       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
 996           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
 997     }
 998   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
 999     gboolean setcaps = FALSE;
1000
1001     /* see above */
1002     frame->overhead = 3;
1003
1004     if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1005             &channels, NULL)) {
1006       GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
1007     } else if (G_UNLIKELY (rate != aacparse->sample_rate
1008             || channels != aacparse->channels)) {
1009       aacparse->sample_rate = rate;
1010       aacparse->channels = channels;
1011       setcaps = TRUE;
1012       GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1013           channels);
1014     }
1015
1016     /* We want to set caps both at start, and when rate/channels change.
1017        Since only some LOAS frames have that info, we may receive frames
1018        before knowing about rate/channels. */
1019     if (setcaps
1020         || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1021       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1022         /* If linking fails, we need to return appropriate error */
1023         ret = GST_FLOW_NOT_LINKED;
1024       }
1025
1026       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1027           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1028     }
1029   }
1030
1031 exit:
1032   gst_buffer_unmap (buffer, &map);
1033
1034   if (ret) {
1035     /* found, skip if needed */
1036     if (*skipsize > 0)
1037       return GST_FLOW_OK;
1038     *skipsize = 0;
1039   } else {
1040     if (*skipsize < 0)
1041       *skipsize = 1;
1042   }
1043
1044   if (ret && framesize <= map.size) {
1045     return gst_base_parse_finish_frame (parse, frame, framesize);
1046   }
1047
1048   return GST_FLOW_OK;
1049 }
1050
1051
1052 /**
1053  * gst_aac_parse_start:
1054  * @parse: #GstBaseParse.
1055  *
1056  * Implementation of "start" vmethod in #GstBaseParse class.
1057  *
1058  * Returns: TRUE if startup succeeded.
1059  */
1060 static gboolean
1061 gst_aac_parse_start (GstBaseParse * parse)
1062 {
1063   GstAacParse *aacparse;
1064
1065   aacparse = GST_AAC_PARSE (parse);
1066   GST_DEBUG ("start");
1067   aacparse->frame_samples = 1024;
1068   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1069   return TRUE;
1070 }
1071
1072
1073 /**
1074  * gst_aac_parse_stop:
1075  * @parse: #GstBaseParse.
1076  *
1077  * Implementation of "stop" vmethod in #GstBaseParse class.
1078  *
1079  * Returns: TRUE is stopping succeeded.
1080  */
1081 static gboolean
1082 gst_aac_parse_stop (GstBaseParse * parse)
1083 {
1084   GST_DEBUG ("stop");
1085   return TRUE;
1086 }
1087
1088 static GstCaps *
1089 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1090 {
1091   GstCaps *peercaps;
1092   GstCaps *res;
1093
1094   /* FIXME: handle filter caps */
1095
1096   peercaps = gst_pad_get_allowed_caps (GST_BASE_PARSE_SRC_PAD (parse));
1097   if (peercaps) {
1098     guint i, n;
1099
1100     /* Remove the framed field */
1101     peercaps = gst_caps_make_writable (peercaps);
1102     n = gst_caps_get_size (peercaps);
1103     for (i = 0; i < n; i++) {
1104       GstStructure *s = gst_caps_get_structure (peercaps, i);
1105
1106       gst_structure_remove_field (s, "framed");
1107     }
1108
1109     res =
1110         gst_caps_intersect_full (peercaps,
1111         gst_pad_get_pad_template_caps (GST_BASE_PARSE_SRC_PAD (parse)),
1112         GST_CAPS_INTERSECT_FIRST);
1113     gst_caps_unref (peercaps);
1114   } else {
1115     res =
1116         gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD
1117             (parse)));
1118   }
1119
1120   return res;
1121 }