1 /* GStreamer AAC parser plugin
2 * Copyright (C) 2008 Nokia Corporation. All rights reserved.
4 * Contact: Stefan Kost <stefan.kost@nokia.com>
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.
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.
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.
23 * SECTION:element-aacparse
24 * @short_description: AAC parser
25 * @see_also: #GstAmrParse
27 * This is an AAC parser which handles both ADIF and ADTS stream formats.
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.
34 * <title>Example launch line</title>
36 * gst-launch filesrc location=abc.aac ! aacparse ! faad ! audioresample ! audioconvert ! alsasink
47 #include <gst/base/gstbitreader.h>
48 #include "gstaacparse.h"
51 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
54 GST_STATIC_CAPS ("audio/mpeg, "
55 "framed = (boolean) true, " "mpegversion = (int) { 2, 4 }, "
56 "stream-format = (string) { raw, adts, adif, loas };"));
58 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
61 GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) { 2, 4 };"));
63 GST_DEBUG_CATEGORY_STATIC (aacparse_debug);
64 #define GST_CAT_DEFAULT aacparse_debug
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 */
72 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
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
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
84 static gboolean gst_aac_parse_start (GstBaseParse * parse);
85 static gboolean gst_aac_parse_stop (GstBaseParse * parse);
87 static gboolean gst_aac_parse_sink_setcaps (GstBaseParse * parse,
89 static GstCaps *gst_aac_parse_sink_getcaps (GstBaseParse * parse,
92 static gboolean gst_aac_parse_check_valid_frame (GstBaseParse * parse,
93 GstBaseParseFrame * frame, guint * size, gint * skipsize);
95 static GstFlowReturn gst_aac_parse_parse_frame (GstBaseParse * parse,
96 GstBaseParseFrame * frame);
98 gboolean gst_aac_parse_convert (GstBaseParse * parse,
100 gint64 src_value, GstFormat dest_format, gint64 * dest_value);
102 gint gst_aac_parse_get_frame_overhead (GstBaseParse * parse,
105 gboolean gst_aac_parse_event (GstBaseParse * parse, GstEvent * event);
107 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
110 gst_aac_parse_get_sample_rate_from_index (guint sr_idx)
112 static const guint aac_sample_rates[] = { 96000, 88200, 64000, 48000, 44100,
113 32000, 24000, 22050, 16000, 12000, 11025, 8000
116 if (sr_idx < G_N_ELEMENTS (aac_sample_rates))
117 return aac_sample_rates[sr_idx];
118 GST_WARNING ("Invalid sample rate index %u", sr_idx);
123 * gst_aac_parse_class_init:
124 * @klass: #GstAacParseClass.
128 gst_aac_parse_class_init (GstAacParseClass * klass)
130 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
131 GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
133 GST_DEBUG_CATEGORY_INIT (aacparse_debug, "aacparse", 0,
134 "AAC audio stream parser");
136 gst_element_class_add_pad_template (element_class,
137 gst_static_pad_template_get (&sink_template));
138 gst_element_class_add_pad_template (element_class,
139 gst_static_pad_template_get (&src_template));
141 gst_element_class_set_details_simple (element_class,
142 "AAC audio stream parser", "Codec/Parser/Audio",
143 "Advanced Audio Coding parser", "Stefan Kost <stefan.kost@nokia.com>");
145 parse_class->start = GST_DEBUG_FUNCPTR (gst_aac_parse_start);
146 parse_class->stop = GST_DEBUG_FUNCPTR (gst_aac_parse_stop);
147 parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_setcaps);
148 parse_class->get_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_getcaps);
149 parse_class->parse_frame = GST_DEBUG_FUNCPTR (gst_aac_parse_parse_frame);
150 parse_class->check_valid_frame =
151 GST_DEBUG_FUNCPTR (gst_aac_parse_check_valid_frame);
156 * gst_aac_parse_init:
157 * @aacparse: #GstAacParse.
158 * @klass: #GstAacParseClass.
162 gst_aac_parse_init (GstAacParse * aacparse)
164 GST_DEBUG ("initialized");
169 * gst_aac_parse_set_src_caps:
170 * @aacparse: #GstAacParse.
171 * @sink_caps: (proposed) caps of sink pad
173 * Set source pad caps according to current knowledge about the
176 * Returns: TRUE if caps were successfully set.
179 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
182 GstCaps *src_caps = NULL;
183 gboolean res = FALSE;
184 const gchar *stream_format;
186 GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
188 src_caps = gst_caps_copy (sink_caps);
190 src_caps = gst_caps_new_empty_simple ("audio/mpeg");
192 gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
193 "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
195 switch (aacparse->header_type) {
196 case DSPAAC_HEADER_NONE:
197 stream_format = "raw";
199 case DSPAAC_HEADER_ADTS:
200 stream_format = "adts";
202 case DSPAAC_HEADER_ADIF:
203 stream_format = "adif";
205 case DSPAAC_HEADER_LOAS:
206 stream_format = "loas";
209 stream_format = NULL;
212 s = gst_caps_get_structure (src_caps, 0);
213 if (aacparse->sample_rate > 0)
214 gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
215 if (aacparse->channels > 0)
216 gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
218 gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
220 GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
222 res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
223 gst_caps_unref (src_caps);
229 * gst_aac_parse_sink_setcaps:
233 * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
235 * Returns: TRUE on success.
238 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
240 GstAacParse *aacparse;
241 GstStructure *structure;
245 aacparse = GST_AAC_PARSE (parse);
246 structure = gst_caps_get_structure (caps, 0);
247 caps_str = gst_caps_to_string (caps);
249 GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
252 /* This is needed at least in case of RTP
253 * Parses the codec_data information to get ObjectType,
254 * number of channels and samplerate */
255 value = gst_structure_get_value (structure, "codec_data");
257 GstBuffer *buf = gst_value_get_buffer (value);
263 gst_buffer_map (buf, &map, GST_MAP_READ);
265 sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
266 aacparse->object_type = (map.data[0] & 0xf8) >> 3;
267 aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
268 aacparse->channels = (map.data[1] & 0x78) >> 3;
269 aacparse->header_type = DSPAAC_HEADER_NONE;
270 aacparse->mpegversion = 4;
271 aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
272 gst_buffer_unmap (buf, &map);
274 GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
275 "samples=%d", aacparse->object_type, aacparse->sample_rate,
276 aacparse->channels, aacparse->frame_samples);
278 /* arrange for metadata and get out of the way */
279 gst_aac_parse_set_src_caps (aacparse, caps);
280 gst_base_parse_set_passthrough (parse, TRUE);
284 /* caps info overrides */
285 gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
286 gst_structure_get_int (structure, "channels", &aacparse->channels);
288 gst_base_parse_set_passthrough (parse, FALSE);
296 * gst_aac_parse_adts_get_frame_len:
297 * @data: block of data containing an ADTS header.
299 * This function calculates ADTS frame length from the given header.
301 * Returns: size of the ADTS frame.
304 gst_aac_parse_adts_get_frame_len (const guint8 * data)
306 return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
311 * gst_aac_parse_check_adts_frame:
312 * @aacparse: #GstAacParse.
313 * @data: Data to be checked.
314 * @avail: Amount of data passed.
315 * @framesize: If valid ADTS frame was found, this will be set to tell the
316 * found frame size in bytes.
317 * @needed_data: If frame was not found, this may be set to tell how much
318 * more data is needed in the next round to detect the frame
319 * reliably. This may happen when a frame header candidate
320 * is found but it cannot be guaranteed to be the header without
321 * peeking the following data.
323 * Check if the given data contains contains ADTS frame. The algorithm
324 * will examine ADTS frame header and calculate the frame size. Also, another
325 * consecutive ADTS frame header need to be present after the found frame.
326 * Otherwise the data is not considered as a valid ADTS frame. However, this
327 * "extra check" is omitted when EOS has been received. In this case it is
328 * enough when data[0] contains a valid ADTS header.
330 * This function may set the #needed_data to indicate that a possible frame
331 * candidate has been found, but more data (#needed_data bytes) is needed to
332 * be absolutely sure. When this situation occurs, FALSE will be returned.
334 * When a valid frame is detected, this function will use
335 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
336 * to set the needed bytes for next frame.This way next data chunk is already
339 * Returns: TRUE if the given data contains a valid ADTS header.
342 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
343 const guint8 * data, const guint avail, gboolean drain,
344 guint * framesize, guint * needed_data)
348 if (G_UNLIKELY (avail < 2))
351 if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
352 *framesize = gst_aac_parse_adts_get_frame_len (data);
354 /* In EOS mode this is enough. No need to examine the data further.
355 We also relax the check when we have sync, on the assumption that
356 if we're not looking at random data, we have a much higher chance
357 to get the correct sync, and this avoids losing two frames when
358 a single bit corruption happens. */
359 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
363 if (*framesize + ADTS_MAX_SIZE > avail) {
364 /* We have found a possible frame header candidate, but can't be
365 sure since we don't have enough data to check the next frame */
366 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
367 *framesize + ADTS_MAX_SIZE, avail);
368 *needed_data = *framesize + ADTS_MAX_SIZE;
369 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
370 *framesize + ADTS_MAX_SIZE);
374 if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
375 guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
377 GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
378 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
379 nextlen + ADTS_MAX_SIZE);
387 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
390 guint8 bytes, i, byte;
393 if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
395 for (i = 0; i < bytes; ++i) {
397 if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
405 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
406 guint8 * audio_object_type)
408 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
410 if (*audio_object_type == 31) {
411 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
413 *audio_object_type += 32;
415 GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
420 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
423 guint8 sampling_frequency_index;
424 if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
426 GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
427 sampling_frequency_index);
428 if (sampling_frequency_index == 0xf) {
429 guint32 sampling_rate;
430 if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
432 *sample_rate = sampling_rate;
434 *sample_rate = loas_sample_rate_table[sampling_frequency_index];
441 /* See table 1.13 in ISO/IEC 14496-3 */
443 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
444 GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
446 guint8 audio_object_type, channel_configuration;
448 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
451 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
454 if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
456 GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
457 *channels = loas_channels_table[channel_configuration];
461 if (audio_object_type == 5) {
462 GST_LOG_OBJECT (aacparse,
463 "Audio object type 5, so rereading sampling rate...");
464 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
468 GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
469 *sample_rate, *channels);
471 /* There's LOTS of stuff next, but we ignore it for now as we have
472 what we want (sample rate and number of channels */
473 GST_DEBUG_OBJECT (aacparse,
474 "Need more code to parse humongous LOAS data, currently ignored");
482 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
483 guint avail, gint * sample_rate, gint * channels, gint * version)
488 /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
492 gst_bit_reader_init (&br, data, avail);
494 /* skip sync word (11 bits) and size (13 bits) */
495 gst_bit_reader_skip (&br, 11 + 13);
497 /* First bit is "use last config" */
498 if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
501 GST_DEBUG_OBJECT (aacparse, "Frame uses previous config");
502 if (!aacparse->sample_rate || !aacparse->channels) {
503 GST_WARNING_OBJECT (aacparse, "No previous config to use");
505 *sample_rate = aacparse->sample_rate;
506 *channels = aacparse->channels;
510 GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
512 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
515 if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
520 GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
522 guint8 same_time, subframes, num_program, prog;
525 if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
528 if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
530 if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
532 if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
534 GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
535 same_time, subframes, num_program);
537 for (prog = 0; prog <= num_program; ++prog) {
538 guint8 num_layer, layer;
539 if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
541 GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
543 for (layer = 0; layer <= num_layer; ++layer) {
544 guint8 use_same_config;
545 if (prog == 0 && layer == 0) {
548 if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
551 if (!use_same_config) {
553 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
554 sample_rate, channels, NULL))
557 guint32 bits, asc_len;
558 if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
560 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
561 sample_rate, channels, &bits))
564 gst_bit_reader_skip (&br, asc_len);
569 GST_WARNING_OBJECT (aacparse, "More data ignored");
571 GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
577 * gst_aac_parse_loas_get_frame_len:
578 * @data: block of data containing a LOAS header.
580 * This function calculates LOAS frame length from the given header.
582 * Returns: size of the LOAS frame.
585 gst_aac_parse_loas_get_frame_len (const guint8 * data)
587 return (((data[1] & 0x1f) << 8) | data[2]) + 3;
592 * gst_aac_parse_check_loas_frame:
593 * @aacparse: #GstAacParse.
594 * @data: Data to be checked.
595 * @avail: Amount of data passed.
596 * @framesize: If valid LOAS frame was found, this will be set to tell the
597 * found frame size in bytes.
598 * @needed_data: If frame was not found, this may be set to tell how much
599 * more data is needed in the next round to detect the frame
600 * reliably. This may happen when a frame header candidate
601 * is found but it cannot be guaranteed to be the header without
602 * peeking the following data.
604 * Check if the given data contains contains LOAS frame. The algorithm
605 * will examine LOAS frame header and calculate the frame size. Also, another
606 * consecutive LOAS frame header need to be present after the found frame.
607 * Otherwise the data is not considered as a valid LOAS frame. However, this
608 * "extra check" is omitted when EOS has been received. In this case it is
609 * enough when data[0] contains a valid LOAS header.
611 * This function may set the #needed_data to indicate that a possible frame
612 * candidate has been found, but more data (#needed_data bytes) is needed to
613 * be absolutely sure. When this situation occurs, FALSE will be returned.
615 * When a valid frame is detected, this function will use
616 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
617 * to set the needed bytes for next frame.This way next data chunk is already
620 * LOAS can have three different formats, if I read the spec correctly. Only
621 * one of them is supported here, as the two samples I have use this one.
623 * Returns: TRUE if the given data contains a valid LOAS header.
626 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
627 const guint8 * data, const guint avail, gboolean drain,
628 guint * framesize, guint * needed_data)
633 if (G_UNLIKELY (avail < 3))
636 if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
637 *framesize = gst_aac_parse_loas_get_frame_len (data);
638 GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
640 /* In EOS mode this is enough. No need to examine the data further.
641 We also relax the check when we have sync, on the assumption that
642 if we're not looking at random data, we have a much higher chance
643 to get the correct sync, and this avoids losing two frames when
644 a single bit corruption happens. */
645 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
649 if (*framesize + LOAS_MAX_SIZE > avail) {
650 /* We have found a possible frame header candidate, but can't be
651 sure since we don't have enough data to check the next frame */
652 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
653 *framesize + LOAS_MAX_SIZE, avail);
654 *needed_data = *framesize + LOAS_MAX_SIZE;
655 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
656 *framesize + LOAS_MAX_SIZE);
660 if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
661 guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
663 GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
664 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
665 nextlen + LOAS_MAX_SIZE);
672 /* caller ensure sufficient data */
674 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
675 gint * rate, gint * channels, gint * object, gint * version)
679 gint sr_idx = (data[2] & 0x3c) >> 2;
681 *rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
684 *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
687 *version = (data[1] & 0x08) ? 2 : 4;
689 *object = (data[2] & 0xc0) >> 6;
693 * gst_aac_parse_detect_stream:
694 * @aacparse: #GstAacParse.
695 * @data: A block of data that needs to be examined for stream characteristics.
696 * @avail: Size of the given datablock.
697 * @framesize: If valid stream was found, this will be set to tell the
698 * first frame size in bytes.
699 * @skipsize: If valid stream was found, this will be set to tell the first
700 * audio frame position within the given data.
702 * Examines the given piece of data and try to detect the format of it. It
703 * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
704 * header. If the stream is detected, TRUE will be returned and #framesize
705 * is set to indicate the found frame size. Additionally, #skipsize might
706 * be set to indicate the number of bytes that need to be skipped, a.k.a. the
707 * position of the frame inside given data chunk.
709 * Returns: TRUE on success.
712 gst_aac_parse_detect_stream (GstAacParse * aacparse,
713 const guint8 * data, const guint avail, gboolean drain,
714 guint * framesize, gint * skipsize)
716 gboolean found = FALSE;
717 guint need_data_adts = 0, need_data_loas;
720 GST_DEBUG_OBJECT (aacparse, "Parsing header data");
722 /* FIXME: No need to check for ADIF if we are not in the beginning of the
725 /* Can we even parse the header? */
726 if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
727 GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
731 for (i = 0; i < avail - 4; i++) {
732 if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
733 ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) ||
734 strncmp ((char *) data + i, "ADIF", 4) == 0) {
735 GST_DEBUG_OBJECT (aacparse, "Found ADIF signature at offset %u", i);
739 /* Trick: tell the parent class that we didn't find the frame yet,
740 but make it skip 'i' amount of bytes. Next time we arrive
741 here we have full frame in the beginning of the data. */
754 if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
755 framesize, &need_data_adts)) {
758 GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
760 aacparse->header_type = DSPAAC_HEADER_ADTS;
761 gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
762 &aacparse->object_type, &aacparse->mpegversion);
764 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
765 aacparse->frame_samples, 2, 2);
767 GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
768 rate, channels, aacparse->object_type, aacparse->mpegversion);
770 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
775 if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
776 framesize, &need_data_loas)) {
779 GST_INFO ("LOAS, framesize: %d", *framesize);
781 aacparse->header_type = DSPAAC_HEADER_LOAS;
783 if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
784 &channels, &aacparse->mpegversion)) {
785 GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
789 if (rate && channels) {
790 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
791 aacparse->frame_samples, 2, 2);
793 GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
794 rate, channels, aacparse->object_type, aacparse->mpegversion);
795 aacparse->sample_rate = rate;
796 aacparse->channels = channels;
799 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
804 if (need_data_adts || need_data_loas) {
805 /* This tells the parent class not to skip any data */
810 if (avail < ADIF_MAX_SIZE)
813 if (memcmp (data + i, "ADIF", 4) == 0) {
820 aacparse->header_type = DSPAAC_HEADER_ADIF;
821 aacparse->mpegversion = 4;
823 /* Skip the "ADIF" bytes */
826 /* copyright string */
828 skip_size += 9; /* skip 9 bytes */
830 bitstream_type = adif[0 + skip_size] & 0x10;
832 ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
833 ((unsigned int) adif[1 + skip_size] << 11) |
834 ((unsigned int) adif[2 + skip_size] << 3) |
835 ((unsigned int) adif[3 + skip_size] & 0xe0);
838 if (bitstream_type == 0) {
840 /* Buffer fullness parsing. Currently not needed... */
844 num_elems = (adif[3 + skip_size] & 0x1e);
845 GST_INFO ("ADIF num_config_elems: %d", num_elems);
847 fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
848 ((unsigned int) adif[4 + skip_size] << 11) |
849 ((unsigned int) adif[5 + skip_size] << 3) |
850 ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
852 GST_INFO ("ADIF buffer fullness: %d", fullness);
854 aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
855 ((adif[7 + skip_size] & 0x80) >> 7);
856 sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
860 aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
861 sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
862 ((adif[5 + skip_size] & 0x80) >> 7);
865 /* FIXME: This gives totally wrong results. Duration calculation cannot
867 aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
869 /* baseparse is not given any fps,
870 * so it will give up on timestamps, seeking, etc */
872 /* FIXME: Can we assume this? */
873 aacparse->channels = 2;
875 GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
876 aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
878 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
880 /* arrange for metadata and get out of the way */
881 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
882 gst_aac_parse_set_src_caps (aacparse, sinkcaps);
883 gst_caps_unref (sinkcaps);
885 /* not syncable, not easily seekable (unless we push data from start */
886 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
887 gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
888 gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
894 /* This should never happen */
900 * gst_aac_parse_check_valid_frame:
901 * @parse: #GstBaseParse.
902 * @buffer: #GstBuffer.
903 * @framesize: If the buffer contains a valid frame, its size will be put here
904 * @skipsize: How much data parent class should skip in order to find the
907 * Implementation of "check_valid_frame" vmethod in #GstBaseParse class.
909 * Returns: TRUE if buffer contains a valid frame.
912 gst_aac_parse_check_valid_frame (GstBaseParse * parse,
913 GstBaseParseFrame * frame, guint * framesize, gint * skipsize)
916 GstAacParse *aacparse;
917 gboolean ret = FALSE;
921 aacparse = GST_AAC_PARSE (parse);
922 buffer = frame->buffer;
924 gst_buffer_map (buffer, &map, GST_MAP_READ);
926 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
928 if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
929 aacparse->header_type == DSPAAC_HEADER_NONE) {
930 /* There is nothing to parse */
931 *framesize = map.size;
934 } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
936 ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
937 GST_BASE_PARSE_DRAINING (parse), framesize, skipsize);
939 } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
940 guint needed_data = 1024;
942 ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
943 GST_BASE_PARSE_DRAINING (parse), framesize, &needed_data);
946 GST_DEBUG ("buffer didn't contain valid frame");
947 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
951 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
952 guint needed_data = 1024;
954 ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
955 map.size, GST_BASE_PARSE_DRAINING (parse), framesize, &needed_data);
958 GST_DEBUG ("buffer didn't contain valid frame");
959 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
964 GST_DEBUG ("buffer didn't contain valid frame");
965 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
968 gst_buffer_unmap (buffer, &map);
975 * gst_aac_parse_parse_frame:
976 * @parse: #GstBaseParse.
977 * @buffer: #GstBuffer.
979 * Implementation of "parse_frame" vmethod in #GstBaseParse class.
981 * Also determines frame overhead.
982 * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
983 * a per-frame header. LOAS has 3 bytes.
985 * We're making a couple of simplifying assumptions:
987 * 1. We count Program Configuration Elements rather than searching for them
988 * in the streams to discount them - the overhead is negligible.
990 * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
991 * bits, which should still not be significant enough to warrant the
992 * additional parsing through the headers
994 * Returns: GST_FLOW_OK if frame was successfully parsed and can be pushed
995 * forward. Otherwise appropriate error is returned.
998 gst_aac_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1000 GstAacParse *aacparse;
1002 GstFlowReturn ret = GST_FLOW_OK;
1003 gint rate, channels;
1006 aacparse = GST_AAC_PARSE (parse);
1007 buffer = frame->buffer;
1009 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1011 frame->overhead = 7;
1013 gst_buffer_map (buffer, &map, GST_MAP_READ);
1014 gst_aac_parse_parse_adts_header (aacparse, map.data,
1015 &rate, &channels, NULL, NULL);
1016 gst_buffer_unmap (buffer, &map);
1018 GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1020 if (G_UNLIKELY (rate != aacparse->sample_rate
1021 || channels != aacparse->channels)) {
1024 aacparse->sample_rate = rate;
1025 aacparse->channels = channels;
1027 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE (aacparse)->sinkpad);
1028 if (!gst_aac_parse_set_src_caps (aacparse, sinkcaps)) {
1029 /* If linking fails, we need to return appropriate error */
1030 ret = GST_FLOW_NOT_LINKED;
1032 gst_caps_unref (sinkcaps);
1034 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1035 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1037 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1038 gboolean setcaps = FALSE;
1041 frame->overhead = 3;
1043 gst_buffer_map (buffer, &map, GST_MAP_READ);
1044 if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1046 GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
1047 } else if (G_UNLIKELY (rate != aacparse->sample_rate
1048 || channels != aacparse->channels)) {
1049 aacparse->sample_rate = rate;
1050 aacparse->channels = channels;
1052 GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1055 gst_buffer_unmap (buffer, &map);
1057 /* We want to set caps both at start, and when rate/channels change.
1058 Since only some LOAS frames have that info, we may receive frames
1059 before knowing about rate/channels. */
1061 || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1063 gst_pad_get_current_caps (GST_BASE_PARSE (aacparse)->sinkpad);
1064 if (!gst_aac_parse_set_src_caps (aacparse, sinkcaps)) {
1065 /* If linking fails, we need to return appropriate error */
1066 ret = GST_FLOW_NOT_LINKED;
1068 gst_caps_unref (sinkcaps);
1070 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1071 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1080 * gst_aac_parse_start:
1081 * @parse: #GstBaseParse.
1083 * Implementation of "start" vmethod in #GstBaseParse class.
1085 * Returns: TRUE if startup succeeded.
1088 gst_aac_parse_start (GstBaseParse * parse)
1090 GstAacParse *aacparse;
1092 aacparse = GST_AAC_PARSE (parse);
1093 GST_DEBUG ("start");
1094 aacparse->frame_samples = 1024;
1095 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1101 * gst_aac_parse_stop:
1102 * @parse: #GstBaseParse.
1104 * Implementation of "stop" vmethod in #GstBaseParse class.
1106 * Returns: TRUE is stopping succeeded.
1109 gst_aac_parse_stop (GstBaseParse * parse)
1116 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1121 /* FIXME: handle filter caps */
1123 peercaps = gst_pad_get_allowed_caps (GST_BASE_PARSE_SRC_PAD (parse));
1127 /* Remove the framed field */
1128 peercaps = gst_caps_make_writable (peercaps);
1129 n = gst_caps_get_size (peercaps);
1130 for (i = 0; i < n; i++) {
1131 GstStructure *s = gst_caps_get_structure (peercaps, i);
1133 gst_structure_remove_field (s, "framed");
1137 gst_caps_intersect_full (peercaps,
1138 gst_pad_get_pad_template_caps (GST_BASE_PARSE_SRC_PAD (parse)),
1139 GST_CAPS_INTERSECT_FIRST);
1140 gst_caps_unref (peercaps);
1143 gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD