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 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     gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
 749         &aacparse->object_type, &aacparse->mpegversion);
 750
 751     if (!channels || !framesize) {
 752       GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
 753       return FALSE;
 754     }
 755
 756     aacparse->header_type = DSPAAC_HEADER_ADTS;
 757     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 758         aacparse->frame_samples, 2, 2);
 759
 760     GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
 761         rate, channels, aacparse->object_type, aacparse->mpegversion);
 762
 763     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 764
 765     return TRUE;
 766   }
 767
 768   if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
 769           framesize, &need_data_loas)) {
 770     gint rate, channels;
 771
 772     GST_INFO ("LOAS, framesize: %d", *framesize);
 773
 774     aacparse->header_type = DSPAAC_HEADER_LOAS;
 775
 776     if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
 777             &channels, &aacparse->mpegversion)) {
 778       GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
 779       return FALSE;
 780     }
 781
 782     if (rate && channels) {
 783       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
 784           aacparse->frame_samples, 2, 2);
 785
 786       GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
 787           rate, channels, aacparse->object_type, aacparse->mpegversion);
 788       aacparse->sample_rate = rate;
 789       aacparse->channels = channels;
 790     }
 791
 792     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
 793
 794     return TRUE;
 795   }
 796
 797   if (need_data_adts || need_data_loas) {
 798     /* This tells the parent class not to skip any data */
 799     *skipsize = 0;
 800     return FALSE;
 801   }
 802
 803   if (avail < ADIF_MAX_SIZE)
 804     return FALSE;
 805
 806   if (memcmp (data + i, "ADIF", 4) == 0) {
 807     const guint8 *adif;
 808     int skip_size = 0;
 809     int bitstream_type;
 810     int sr_idx;
 811     GstCaps *sinkcaps;
 812
 813     aacparse->header_type = DSPAAC_HEADER_ADIF;
 814     aacparse->mpegversion = 4;
 815
 816     /* Skip the "ADIF" bytes */
 817     adif = data + i + 4;
 818
 819     /* copyright string */
 820     if (adif[0] & 0x80)
 821       skip_size += 9;           /* skip 9 bytes */
 822
 823     bitstream_type = adif[0 + skip_size] & 0x10;
 824     aacparse->bitrate =
 825         ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
 826         ((unsigned int) adif[1 + skip_size] << 11) |
 827         ((unsigned int) adif[2 + skip_size] << 3) |
 828         ((unsigned int) adif[3 + skip_size] & 0xe0);
 829
 830     /* CBR */
 831     if (bitstream_type == 0) {
 832 #if 0
 833       /* Buffer fullness parsing. Currently not needed... */
 834       guint num_elems = 0;
 835       guint fullness = 0;
 836
 837       num_elems = (adif[3 + skip_size] & 0x1e);
 838       GST_INFO ("ADIF num_config_elems: %d", num_elems);
 839
 840       fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
 841           ((unsigned int) adif[4 + skip_size] << 11) |
 842           ((unsigned int) adif[5 + skip_size] << 3) |
 843           ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
 844
 845       GST_INFO ("ADIF buffer fullness: %d", fullness);
 846 #endif
 847       aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
 848           ((adif[7 + skip_size] & 0x80) >> 7);
 849       sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
 850     }
 851     /* VBR */
 852     else {
 853       aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
 854       sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
 855           ((adif[5 + skip_size] & 0x80) >> 7);
 856     }
 857
 858     /* FIXME: This gives totally wrong results. Duration calculation cannot
 859        be based on this */
 860     aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
 861
 862     /* baseparse is not given any fps,
 863      * so it will give up on timestamps, seeking, etc */
 864
 865     /* FIXME: Can we assume this? */
 866     aacparse->channels = 2;
 867
 868     GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
 869         aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
 870
 871     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
 872
 873     /* arrange for metadata and get out of the way */
 874     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
 875     gst_aac_parse_set_src_caps (aacparse, sinkcaps);
 876     if (sinkcaps)
 877       gst_caps_unref (sinkcaps);
 878
 879     /* not syncable, not easily seekable (unless we push data from start */
 880     gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
 881     gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
 882     gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
 883
 884     *framesize = avail;
 885     return TRUE;
 886   }
 887
 888   /* This should never happen */
 889   return FALSE;
 890 }
 891
 892
 893 /**
 894  * gst_aac_parse_check_valid_frame:
 895  * @parse: #GstBaseParse.
 896  * @frame: #GstBaseParseFrame.
 897  * @skipsize: How much data parent class should skip in order to find the
 898  *            frame header.
 899  *
 900  * Implementation of "handle_frame" vmethod in #GstBaseParse class.
 901  *
 902  * Also determines frame overhead.
 903  * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
 904  * a per-frame header. LOAS has 3 bytes.
 905  *
 906  * We're making a couple of simplifying assumptions:
 907  *
 908  * 1. We count Program Configuration Elements rather than searching for them
 909  *    in the streams to discount them - the overhead is negligible.
 910  *
 911  * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
 912  *    bits, which should still not be significant enough to warrant the
 913  *    additional parsing through the headers
 914  *
 915  * Returns: a #GstFlowReturn.
 916  */
 917 static GstFlowReturn
 918 gst_aac_parse_handle_frame (GstBaseParse * parse,
 919     GstBaseParseFrame * frame, gint * skipsize)
 920 {
 921   GstMapInfo map;
 922   GstAacParse *aacparse;
 923   gboolean ret = FALSE;
 924   gboolean lost_sync;
 925   GstBuffer *buffer;
 926   guint framesize;
 927   gint rate, channels;
 928
 929   aacparse = GST_AAC_PARSE (parse);
 930   buffer = frame->buffer;
 931
 932   gst_buffer_map (buffer, &map, GST_MAP_READ);
 933
 934   *skipsize = -1;
 935   lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
 936
 937   if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
 938       aacparse->header_type == DSPAAC_HEADER_NONE) {
 939     /* There is nothing to parse */
 940     framesize = map.size;
 941     ret = TRUE;
 942
 943   } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
 944
 945     ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
 946         GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
 947
 948   } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 949     guint needed_data = 1024;
 950
 951     ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
 952         GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
 953
 954     if (!ret) {
 955       GST_DEBUG ("buffer didn't contain valid frame");
 956       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 957           needed_data);
 958     }
 959
 960   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
 961     guint needed_data = 1024;
 962
 963     ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
 964         map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
 965
 966     if (!ret) {
 967       GST_DEBUG ("buffer didn't contain valid frame");
 968       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 969           needed_data);
 970     }
 971
 972   } else {
 973     GST_DEBUG ("buffer didn't contain valid frame");
 974     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
 975         ADTS_MAX_SIZE);
 976   }
 977
 978   if (G_UNLIKELY (!ret))
 979     goto exit;
 980
 981   if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
 982     /* see above */
 983     frame->overhead = 7;
 984
 985     gst_aac_parse_parse_adts_header (aacparse, map.data,
 986         &rate, &channels, NULL, NULL);
 987
 988     GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
 989
 990     if (G_UNLIKELY (rate != aacparse->sample_rate
 991             || channels != aacparse->channels)) {
 992       aacparse->sample_rate = rate;
 993       aacparse->channels = channels;
 994
 995       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
 996         /* If linking fails, we need to return appropriate error */
 997         ret = GST_FLOW_NOT_LINKED;
 998       }
 999
1000       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1001           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1002     }
1003   } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1004     gboolean setcaps = FALSE;
1005
1006     /* see above */
1007     frame->overhead = 3;
1008
1009     if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1010             &channels, NULL)) {
1011       GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
1012     } else if (G_UNLIKELY (rate != aacparse->sample_rate
1013             || channels != aacparse->channels)) {
1014       aacparse->sample_rate = rate;
1015       aacparse->channels = channels;
1016       setcaps = TRUE;
1017       GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1018           channels);
1019     }
1020
1021     /* We want to set caps both at start, and when rate/channels change.
1022        Since only some LOAS frames have that info, we may receive frames
1023        before knowing about rate/channels. */
1024     if (setcaps
1025         || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1026       if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1027         /* If linking fails, we need to return appropriate error */
1028         ret = GST_FLOW_NOT_LINKED;
1029       }
1030
1031       gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1032           aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1033     }
1034   }
1035
1036 exit:
1037   gst_buffer_unmap (buffer, &map);
1038
1039   if (ret) {
1040     /* found, skip if needed */
1041     if (*skipsize > 0)
1042       return GST_FLOW_OK;
1043     *skipsize = 0;
1044   } else {
1045     if (*skipsize < 0)
1046       *skipsize = 1;
1047   }
1048
1049   if (ret && framesize <= map.size) {
1050     return gst_base_parse_finish_frame (parse, frame, framesize);
1051   }
1052
1053   return GST_FLOW_OK;
1054 }
1055
1056
1057 /**
1058  * gst_aac_parse_start:
1059  * @parse: #GstBaseParse.
1060  *
1061  * Implementation of "start" vmethod in #GstBaseParse class.
1062  *
1063  * Returns: TRUE if startup succeeded.
1064  */
1065 static gboolean
1066 gst_aac_parse_start (GstBaseParse * parse)
1067 {
1068   GstAacParse *aacparse;
1069
1070   aacparse = GST_AAC_PARSE (parse);
1071   GST_DEBUG ("start");
1072   aacparse->frame_samples = 1024;
1073   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1074   return TRUE;
1075 }
1076
1077
1078 /**
1079  * gst_aac_parse_stop:
1080  * @parse: #GstBaseParse.
1081  *
1082  * Implementation of "stop" vmethod in #GstBaseParse class.
1083  *
1084  * Returns: TRUE is stopping succeeded.
1085  */
1086 static gboolean
1087 gst_aac_parse_stop (GstBaseParse * parse)
1088 {
1089   GST_DEBUG ("stop");
1090   return TRUE;
1091 }
1092
1093 static GstCaps *
1094 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1095 {
1096   GstCaps *peercaps, *templ;
1097   GstCaps *res;
1098
1099   templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1100   peercaps = gst_pad_get_allowed_caps (GST_BASE_PARSE_SRC_PAD (parse));
1101   if (peercaps) {
1102     guint i, n;
1103
1104     /* Remove the framed field */
1105     peercaps = gst_caps_make_writable (peercaps);
1106     n = gst_caps_get_size (peercaps);
1107     for (i = 0; i < n; i++) {
1108       GstStructure *s = gst_caps_get_structure (peercaps, i);
1109
1110       gst_structure_remove_field (s, "framed");
1111     }
1112
1113     res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1114     gst_caps_unref (peercaps);
1115
1116     /* Append the template caps because we still want to accept
1117      * caps without any fields in the case upstream does not
1118      * know anything.
1119      */
1120     gst_caps_append (res, templ);
1121   } else {
1122     res = templ;
1123   }
1124
1125   if (filter) {
1126     GstCaps *intersection;
1127
1128     intersection =
1129         gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1130     gst_caps_unref (res);
1131     res = intersection;
1132   }
1133
1134   return res;
1135 }