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_static_metadata (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   if (!gst_bit_reader_skip (&br, 11 + 13))
 482     return FALSE;
 483
 484   /* First bit is "use last config" */
 485   if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
 486     return FALSE;
 487   if (u8) {
 488     GST_DEBUG_OBJECT (aacparse, "Frame uses previous config");
 489     if (!aacparse->sample_rate || !aacparse->channels) {
 490       GST_WARNING_OBJECT (aacparse, "No previous config to use");
 491     }
 492     *sample_rate = aacparse->sample_rate;
 493     *channels = aacparse->channels;
 494     return TRUE;
 495   }
 496
 497   GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
 498
 499   if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
 500     return FALSE;
 501   if (v) {
 502     if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
 503       return FALSE;
 504   } else
 505     vA = 0;
 506
 507   GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
 508   if (vA == 0) {
 509     guint8 same_time, subframes, num_program, prog;
 510     if (v == 1) {
 511       guint32 value;
 512       if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
 513         return FALSE;
 514     }
 515     if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
 516       return FALSE;
 517     if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
 518       return FALSE;
 519     if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
 520       return FALSE;
 521     GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
 522         same_time, subframes, num_program);
 523
 524     for (prog = 0; prog <= num_program; ++prog) {
 525       guint8 num_layer, layer;
 526       if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
 527         return FALSE;
 528       GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
 529
 530       for (layer = 0; layer <= num_layer; ++layer) {
 531         guint8 use_same_config;
 532         if (prog == 0 && layer == 0) {
 533           use_same_config = 0;
 534         } else {
 535           if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
 536             return FALSE;
 537         }
 538         if (!use_same_config) {
 539           if (v == 0) {
 540             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 541                     sample_rate, channels, NULL))
 542               return FALSE;
 543           } else {
 544             guint32 bits, asc_len;
 545             if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
 546               return FALSE;
 547             if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
 548                     sample_rate, channels, &bits))
 549               return FALSE;
 550             asc_len -= bits;
 551             if (!gst_bit_reader_skip (&br, asc_len))
 552               return FALSE;
 553           }
 554         }
 555       }
 556     }
 557     GST_WARNING_OBJECT (aacparse, "More data ignored");
 558   } else {
 559     GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
 560   }
 561   return TRUE;
 562 }
 563
 564 /**
 565  * gst_aac_parse_loas_get_frame_len:
 566  * @data: block of data containing a LOAS header.
 567  *
 568  * This function calculates LOAS frame length from the given header.
 569  *
 570  * Returns: size of the LOAS frame.
 571  */
 572 static inline guint
 573 gst_aac_parse_loas_get_frame_len (const guint8 * data)
 574 {
 575   return (((data[1] & 0x1f) << 8) | data[2]) + 3;
 576 }
 577
 578
 579 /**
 580  * gst_aac_parse_check_loas_frame:
 581  * @aacparse: #GstAacParse.
 582  * @data: Data to be checked.
 583  * @avail: Amount of data passed.
 584  * @framesize: If valid LOAS frame was found, this will be set to tell the
 585  *             found frame size in bytes.
 586  * @needed_data: If frame was not found, this may be set to tell how much
 587  *               more data is needed in the next round to detect the frame
 588  *               reliably. This may happen when a frame header candidate
 589  *               is found but it cannot be guaranteed to be the header without
 590  *               peeking the following data.
 591  *
 592  * Check if the given data contains contains LOAS frame. The algorithm
 593  * will examine LOAS frame header and calculate the frame size. Also, another
 594  * consecutive LOAS frame header need to be present after the found frame.
 595  * Otherwise the data is not considered as a valid LOAS frame. However, this
 596  * "extra check" is omitted when EOS has been received. In this case it is
 597  * enough when data[0] contains a valid LOAS header.
 598  *
 599  * This function may set the #needed_data to indicate that a possible frame
 600  * candidate has been found, but more data (#needed_data bytes) is needed to
 601  * be absolutely sure. When this situation occurs, FALSE will be returned.
 602  *
 603  * When a valid frame is detected, this function will use
 604  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
 605  * to set the needed bytes for next frame.This way next data chunk is already
 606  * of correct size.
 607  *
 608  * LOAS can have three different formats, if I read the spec correctly. Only
 609  * one of them is supported here, as the two samples I have use this one.
 610  *
 611  * Returns: TRUE if the given data contains a valid LOAS header.
 612  */
 613 static gboolean
 614 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
 615     const guint8 * data, const guint avail, gboolean drain,
 616     guint * framesize, guint * needed_data)
 617 {
 618   *needed_data = 0;
 619
 620   /* 3 byte header */
 621   if (G_UNLIKELY (avail < 3))
 622     return FALSE;
 623
 624   if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
 625     *framesize = gst_aac_parse_loas_get_frame_len (data);
 626     GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
 627
 628     /* In EOS mode this is enough. No need to examine the data further.
 629        We also relax the check when we have sync, on the assumption that
 630        if we're not looking at random data, we have a much higher chance
 631        to get the correct sync, and this avoids losing two frames when
 632        a single bit corruption happens. */
 633     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
 634       return TRUE;
 635     }
 636
 637     if (*framesize + LOAS_MAX_SIZE > avail) {
 638       /* We have found a possible frame header candidate, but can't be
 639          sure since we don't have enough data to check the next frame */
 640       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
 641           *framesize + LOAS_MAX_SIZE, avail);
 642       *needed_data = *framesize + LOAS_MAX_SIZE;
 643       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 644           *framesize + LOAS_MAX_SIZE);
 645       return FALSE;
 646     }
 647
 648     if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
 649       guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
 650
 651       GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
 652       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 653           nextlen + LOAS_MAX_SIZE);
 654       return TRUE;
 655     }
 656   }
 657   return FALSE;
 658 }
 659
 660 /* caller ensure sufficient data */
 661 static inline void
 662 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
 663     gint * rate, gint * channels, gint * object, gint * version)
 664 {
 665
 666   if (rate) {
 667     gint sr_idx = (data[2] & 0x3c) >> 2;
 668
 669     *rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
 670   }
 671   if (channels)
 672     *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
 673
 674   if (version)
 675     *version = (data[1] & 0x08) ? 2 : 4;
 676   if (object)
 677     *object = (data[2] & 0xc0) >> 6;
 678 }
 679
 680 /**
 681  * gst_aac_parse_detect_stream:
 682  * @aacparse: #GstAacParse.
 683  * @data: A block of data that needs to be examined for stream characteristics.
 684  * @avail: Size of the given datablock.
 685  * @framesize: If valid stream was found, this will be set to tell the
 686  *             first frame size in bytes.
 687  * @skipsize: If valid stream was found, this will be set to tell the first
 688  *            audio frame position within the given data.
 689  *
 690  * Examines the given piece of data and try to detect the format of it. It
 691  * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
 692  * header. If the stream is detected, TRUE will be returned and #framesize
 693  * is set to indicate the found frame size. Additionally, #skipsize might
 694  * be set to indicate the number of bytes that need to be skipped, a.k.a. the
 695  * position of the frame inside given data chunk.
 696  *
 697  * Returns: TRUE on success.
 698  */
 699 static gboolean
 700 gst_aac_parse_detect_stream (GstAacParse * aacparse,
 701     const guint8 * data, const guint avail, gboolean drain,
 702     guint * framesize, gint * skipsize)
 703 {
 704   gboolean found = FALSE;
 705   guint need_data_adts = 0, need_data_loas;
 706   guint i = 0;
 707
 708   GST_DEBUG_OBJECT (aacparse, "Parsing header data");
 709
 710   /* FIXME: No need to check for ADIF if we are not in the beginning of the
 711      stream */
 712
 713   /* Can we even parse the header? */
 714   if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
 715     GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
 716     return FALSE;
 717   }
 718
 719   for (i = 0; i < avail - 4; i++) {
 720     if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
 721         ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) ||
 722         strncmp ((char *) data + i, "ADIF", 4) == 0) {
 723       GST_DEBUG_OBJECT (aacparse, "Found ADIF signature at offset %u", i);
 724       found = TRUE;
 725
 726       if (i) {
 727         /* Trick: tell the parent class that we didn't find the frame yet,
 728            but make it skip 'i' amount of bytes. Next time we arrive
 729            here we have full frame in the beginning of the data. */
 730         *skipsize = i;
 731         return FALSE;
 732       }
 733       break;
 734     }
 735   }
 736   if (!found) {
 737     if (i)
 738       *skipsize = i;
 739     return FALSE;
 740   }
 741
 742   if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
 743           framesize, &need_data_adts)) {
 744     gint rate, channels;
 745
 746     GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
 747
 748     aacparse->header_type = DSPAAC_HEADER_ADTS;
 749     gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
 750         &aacparse->object_type, &aacparse->mpegversion);
 751
 752     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 753         aacparse->frame_samples, 2, 2);
 754
 755     GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
 756         rate, channels, aacparse->object_type, aacparse->mpegversion);
 757
 758     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 759
 760     return TRUE;
 761   }
 762
 763   if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
 764           framesize, &need_data_loas)) {
 765     gint rate, channels;
 766
 767     GST_INFO ("LOAS, framesize: %d", *framesize);
 768
 769     aacparse->header_type = DSPAAC_HEADER_LOAS;
 770
 771     if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
 772             &channels, &aacparse->mpegversion)) {
 773       GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
 774       return FALSE;
 775     }
 776
 777     if (rate && channels) {
 778       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 779           aacparse->frame_samples, 2, 2);
 780
 781       GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
 782           rate, channels, aacparse->object_type, aacparse->mpegversion);
 783       aacparse->sample_rate = rate;
 784       aacparse->channels = channels;
 785     }
 786
 787     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 788
 789     return TRUE;
 790   }
 791
 792   if (need_data_adts || need_data_loas) {
 793     /* This tells the parent class not to skip any data */
 794     *skipsize = 0;
 795     return FALSE;
 796   }
 797
 798   if (avail < ADIF_MAX_SIZE)
 799     return FALSE;
 800
 801   if (memcmp (data + i, "ADIF", 4) == 0) {
 802     const guint8 *adif;
 803     int skip_size = 0;
 804     int bitstream_type;
 805     int sr_idx;
 806     GstCaps *sinkcaps;
 807
 808     aacparse->header_type = DSPAAC_HEADER_ADIF;
 809     aacparse->mpegversion = 4;
 810
 811     /* Skip the "ADIF" bytes */
 812     adif = data + i + 4;
 813
 814     /* copyright string */
 815     if (adif[0] & 0x80)
 816       skip_size += 9;           /* skip 9 bytes */
 817
 818     bitstream_type = adif[0 + skip_size] & 0x10;
 819     aacparse->bitrate =
 820         ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
 821         ((unsigned int) adif[1 + skip_size] << 11) |
 822         ((unsigned int) adif[2 + skip_size] << 3) |
 823         ((unsigned int) adif[3 + skip_size] & 0xe0);
 824
 825     /* CBR */
 826     if (bitstream_type == 0) {
 827 #if 0
 828       /* Buffer fullness parsing. Currently not needed... */
 829       guint num_elems = 0;
 830       guint fullness = 0;
 831
 832       num_elems = (adif[3 + skip_size] & 0x1e);
 833       GST_INFO ("ADIF num_config_elems: %d", num_elems);
 834
 835       fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
 836           ((unsigned int) adif[4 + skip_size] << 11) |
 837           ((unsigned int) adif[5 + skip_size] << 3) |
 838           ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
 839
 840       GST_INFO ("ADIF buffer fullness: %d", fullness);
 841 #endif
 842       aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
 843           ((adif[7 + skip_size] & 0x80) >> 7);
 844       sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
 845     }
 846     /* VBR */
 847     else {
 848       aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
 849       sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
 850           ((adif[5 + skip_size] & 0x80) >> 7);
 851     }
 852
 853     /* FIXME: This gives totally wrong results. Duration calculation cannot
 854        be based on this */
 855     aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
 856
 857     /* baseparse is not given any fps,
 858      * so it will give up on timestamps, seeking, etc */
 859
 860     /* FIXME: Can we assume this? */
 861     aacparse->channels = 2;
 862
 863     GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
 864         aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
 865
 866     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
 867
 868     /* arrange for metadata and get out of the way */
 869     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
 870     gst_aac_parse_set_src_caps (aacparse, sinkcaps);
 871     if (sinkcaps)
 872       gst_caps_unref (sinkcaps);
 873
 874     /* not syncable, not easily seekable (unless we push data from start */
 875     gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
 876     gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
 877     gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
 878
 879     *framesize = avail;
 880     return TRUE;
 881   }
 882
 883   /* This should never happen */
 884   return FALSE;
 885 }
 886
 887
 888 /**
 889  * gst_aac_parse_check_valid_frame:
 890  * @parse: #GstBaseParse.
 891  * @frame: #GstBaseParseFrame.
 892  * @skipsize: How much data parent class should skip in order to find the
 893  *            frame header.
 894  *
 895  * Implementation of "handle_frame" vmethod in #GstBaseParse class.
 896  *
 897  * Also determines frame overhead.
 898  * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
 899  * a per-frame header. LOAS has 3 bytes.
 900  *
 901  * We're making a couple of simplifying assumptions:
 902  *
 903  * 1. We count Program Configuration Elements rather than searching for them
 904  *    in the streams to discount them - the overhead is negligible.
 905  *
 906  * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
 907  *    bits, which should still not be significant enough to warrant the
 908  *    additional parsing through the headers
 909  *
 910  * Returns: a #GstFlowReturn.
 911  */
 912 static GstFlowReturn
 913 gst_aac_parse_handle_frame (GstBaseParse * parse,
 914     GstBaseParseFrame * frame, gint * skipsize)
 915 {
 916   GstMapInfo map;
 917   GstAacParse *aacparse;
 918   gboolean ret = FALSE;
 919   gboolean lost_sync;
 920   GstBuffer *buffer;
 921   guint framesize;
 922   gint rate, channels;
 923
 924   aacparse = GST_AAC_PARSE (parse);
 925   buffer = frame->buffer;
 926
 927   gst_buffer_map (buffer, &map, GST_MAP_READ);
 928
 929   *skipsize = -1;
 930   lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
 931
 932   if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
 933       aacparse->header_type == DSPAAC_HEADER_NONE) {
 934     /* There is nothing to parse */
 935     framesize = map.size;
 936     ret = TRUE;
 937
 938   } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
 939
 940     ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
 941         GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
 942
 943   } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 944     guint needed_data = 1024;
 945
 946     ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
 947         GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
 948
 949     if (!ret) {
 950       GST_DEBUG ("buffer didn't contain valid frame");
 951       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 952           needed_data);
 953     }
 954
 955   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
 956     guint needed_data = 1024;
 957
 958     ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
 959         map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
 960
 961     if (!ret) {
 962       GST_DEBUG ("buffer didn't contain valid frame");
 963       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 964           needed_data);
 965     }
 966
 967   } else {
 968     GST_DEBUG ("buffer didn't contain valid frame");
 969     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 970         ADTS_MAX_SIZE);
 971   }
 972
 973   if (G_UNLIKELY (!ret))
 974     goto exit;
 975
 976   if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 977     /* see above */
 978     frame->overhead = 7;
 979
 980     gst_aac_parse_parse_adts_header (aacparse, map.data,
 981         &rate, &channels, NULL, NULL);
 982
 983     GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
 984
 985     if (G_UNLIKELY (rate != aacparse->sample_rate
 986             || channels != aacparse->channels)) {
 987       aacparse->sample_rate = rate;
 988       aacparse->channels = channels;
 989
 990       GST_DEBUG_OBJECT (aacparse, "here");
 991
 992       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
 993         /* If linking fails, we need to return appropriate error */
 994         ret = GST_FLOW_NOT_LINKED;
 995       }
 996
 997       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
 998           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
 999     }
1000   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1001     gboolean setcaps = FALSE;
1002
1003     /* see above */
1004     frame->overhead = 3;
1005
1006     if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1007             &channels, NULL)) {
1008       GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
1009     } else if (G_UNLIKELY (rate != aacparse->sample_rate
1010             || channels != aacparse->channels)) {
1011       aacparse->sample_rate = rate;
1012       aacparse->channels = channels;
1013       setcaps = TRUE;
1014       GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1015           channels);
1016     }
1017
1018     /* We want to set caps both at start, and when rate/channels change.
1019        Since only some LOAS frames have that info, we may receive frames
1020        before knowing about rate/channels. */
1021     if (setcaps
1022         || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1023       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1024         /* If linking fails, we need to return appropriate error */
1025         ret = GST_FLOW_NOT_LINKED;
1026       }
1027
1028       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1029           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1030     }
1031   }
1032
1033 exit:
1034   gst_buffer_unmap (buffer, &map);
1035
1036   if (ret) {
1037     /* found, skip if needed */
1038     if (*skipsize > 0)
1039       return GST_FLOW_OK;
1040     *skipsize = 0;
1041   } else {
1042     if (*skipsize < 0)
1043       *skipsize = 1;
1044   }
1045
1046   if (ret && framesize <= map.size) {
1047     return gst_base_parse_finish_frame (parse, frame, framesize);
1048   }
1049
1050   return GST_FLOW_OK;
1051 }
1052
1053
1054 /**
1055  * gst_aac_parse_start:
1056  * @parse: #GstBaseParse.
1057  *
1058  * Implementation of "start" vmethod in #GstBaseParse class.
1059  *
1060  * Returns: TRUE if startup succeeded.
1061  */
1062 static gboolean
1063 gst_aac_parse_start (GstBaseParse * parse)
1064 {
1065   GstAacParse *aacparse;
1066
1067   aacparse = GST_AAC_PARSE (parse);
1068   GST_DEBUG ("start");
1069   aacparse->frame_samples = 1024;
1070   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1071   return TRUE;
1072 }
1073
1074
1075 /**
1076  * gst_aac_parse_stop:
1077  * @parse: #GstBaseParse.
1078  *
1079  * Implementation of "stop" vmethod in #GstBaseParse class.
1080  *
1081  * Returns: TRUE is stopping succeeded.
1082  */
1083 static gboolean
1084 gst_aac_parse_stop (GstBaseParse * parse)
1085 {
1086   GST_DEBUG ("stop");
1087   return TRUE;
1088 }
1089
1090 static GstCaps *
1091 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1092 {
1093   GstCaps *peercaps, *templ;
1094   GstCaps *res;
1095
1096   templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1097   peercaps = gst_pad_get_allowed_caps (GST_BASE_PARSE_SRC_PAD (parse));
1098   if (peercaps) {
1099     guint i, n;
1100
1101     /* Remove the framed field */
1102     peercaps = gst_caps_make_writable (peercaps);
1103     n = gst_caps_get_size (peercaps);
1104     for (i = 0; i < n; i++) {
1105       GstStructure *s = gst_caps_get_structure (peercaps, i);
1106
1107       gst_structure_remove_field (s, "framed");
1108     }
1109
1110     res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1111     gst_caps_unref (peercaps);
1112
1113     /* Append the template caps because we still want to accept
1114      * caps without any fields in the case upstream does not
1115      * know anything.
1116      */
1117     gst_caps_append (res, templ);
1118   } else {
1119     res = templ;
1120   }
1121
1122   if (filter) {
1123     GstCaps *intersection;
1124
1125     intersection =
1126         gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1127     gst_caps_unref (res);
1128     res = intersection;
1129   }
1130
1131   return res;
1132 }