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., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
23 * SECTION:element-aacparse
25 * @short_description: AAC parser
26 * @see_also: #GstAmrParse
28 * This is an AAC parser which handles both ADIF and ADTS stream formats.
30 * As ADIF format is not framed, it is not seekable and stream duration cannot
31 * be determined either. However, ADTS format AAC clips can be seeked, and parser
32 * can also estimate playback position and clip duration.
34 * ## Example launch line
36 * gst-launch-1.0 filesrc location=abc.aac ! aacparse ! faad ! audioresample ! audioconvert ! alsasink
47 #include <gst/base/gstbitreader.h>
48 #include <gst/pbutils/pbutils.h>
49 #include "gstaacparse.h"
52 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
55 GST_STATIC_CAPS ("audio/mpeg, "
56 "framed = (boolean) true, " "mpegversion = (int) { 2, 4 }, "
57 "stream-format = (string) { raw, adts, adif, loas };"));
59 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
62 GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) { 2, 4 };"));
64 GST_DEBUG_CATEGORY_STATIC (aacparse_debug);
65 #define GST_CAT_DEFAULT aacparse_debug
68 #define ADIF_MAX_SIZE 40 /* Should be enough */
69 #define ADTS_MAX_SIZE 10 /* Should be enough */
70 #define LOAS_MAX_SIZE 3 /* Should be enough */
71 #define RAW_MAX_SIZE 1 /* Correct framing is required */
73 #define ADTS_HEADERS_LENGTH 7UL /* Total byte-length of fixed and variable
74 headers prepended during raw to ADTS
77 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
79 static const gint loas_sample_rate_table[16] = {
80 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
81 16000, 12000, 11025, 8000, 7350, 0, 0, 0
84 static const gint loas_channels_table[16] = {
85 0, 1, 2, 3, 4, 5, 6, 8,
86 0, 0, 0, 7, 8, 0, 8, 0
89 static gboolean gst_aac_parse_start (GstBaseParse * parse);
90 static gboolean gst_aac_parse_stop (GstBaseParse * parse);
92 static gboolean gst_aac_parse_sink_setcaps (GstBaseParse * parse,
94 static GstCaps *gst_aac_parse_sink_getcaps (GstBaseParse * parse,
97 static GstFlowReturn gst_aac_parse_handle_frame (GstBaseParse * parse,
98 GstBaseParseFrame * frame, gint * skipsize);
99 static GstFlowReturn gst_aac_parse_pre_push_frame (GstBaseParse * parse,
100 GstBaseParseFrame * frame);
101 static gboolean gst_aac_parse_src_event (GstBaseParse * parse,
104 static gboolean gst_aac_parse_read_audio_specific_config (GstAacParse *
105 aacparse, GstBitReader * br, gint * object_type, gint * sample_rate,
106 gint * channels, gint * frame_samples);
109 #define gst_aac_parse_parent_class parent_class
110 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
113 * gst_aac_parse_class_init:
114 * @klass: #GstAacParseClass.
118 gst_aac_parse_class_init (GstAacParseClass * klass)
120 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
121 GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
123 GST_DEBUG_CATEGORY_INIT (aacparse_debug, "aacparse", 0,
124 "AAC audio stream parser");
126 gst_element_class_add_static_pad_template (element_class, &sink_template);
127 gst_element_class_add_static_pad_template (element_class, &src_template);
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>");
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 parse_class->pre_push_frame =
139 GST_DEBUG_FUNCPTR (gst_aac_parse_pre_push_frame);
140 parse_class->src_event = GST_DEBUG_FUNCPTR (gst_aac_parse_src_event);
145 * gst_aac_parse_init:
146 * @aacparse: #GstAacParse.
147 * @klass: #GstAacParseClass.
151 gst_aac_parse_init (GstAacParse * aacparse)
153 GST_DEBUG ("initialized");
154 GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (aacparse));
155 GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (aacparse));
157 aacparse->last_parsed_sample_rate = 0;
158 aacparse->last_parsed_channels = 0;
163 * gst_aac_parse_set_src_caps:
164 * @aacparse: #GstAacParse.
165 * @sink_caps: (proposed) caps of sink pad
167 * Set source pad caps according to current knowledge about the
170 * Returns: TRUE if caps were successfully set.
173 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
176 GstCaps *src_caps = NULL, *allowed;
177 gboolean res = FALSE;
178 const gchar *stream_format;
179 guint8 codec_data[2];
180 guint16 codec_data_data;
181 gint sample_rate_idx;
183 GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
185 src_caps = gst_caps_copy (sink_caps);
187 src_caps = gst_caps_new_empty_simple ("audio/mpeg");
189 gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
190 "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
192 aacparse->output_header_type = aacparse->header_type;
193 switch (aacparse->header_type) {
194 case DSPAAC_HEADER_NONE:
195 stream_format = "raw";
197 case DSPAAC_HEADER_ADTS:
198 stream_format = "adts";
200 case DSPAAC_HEADER_ADIF:
201 stream_format = "adif";
203 case DSPAAC_HEADER_LOAS:
204 stream_format = "loas";
207 stream_format = NULL;
210 /* Generate codec data to be able to set profile/level on the caps */
212 gst_codec_utils_aac_get_index_from_sample_rate (aacparse->sample_rate);
213 if (sample_rate_idx < 0)
214 goto not_a_known_rate;
216 (aacparse->object_type << 11) |
217 (sample_rate_idx << 7) | (aacparse->channels << 3);
218 GST_WRITE_UINT16_BE (codec_data, codec_data_data);
219 gst_codec_utils_aac_caps_set_level_and_profile (src_caps, codec_data, 2);
221 s = gst_caps_get_structure (src_caps, 0);
222 if (aacparse->sample_rate > 0)
223 gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
224 if (aacparse->channels > 0)
225 gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
227 gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
229 allowed = gst_pad_get_allowed_caps (GST_BASE_PARSE (aacparse)->srcpad);
230 if (allowed && !gst_caps_can_intersect (src_caps, allowed)) {
231 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
232 "Caps can not intersect");
233 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
234 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
235 "Input is ADTS, trying raw");
236 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "raw",
238 if (gst_caps_can_intersect (src_caps, allowed)) {
239 GstBuffer *codec_data_buffer;
241 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
242 "Caps can intersect, we will drop the ADTS layer");
243 aacparse->output_header_type = DSPAAC_HEADER_NONE;
245 /* The codec_data data is according to AudioSpecificConfig,
246 ISO/IEC 14496-3, 1.6.2.1 */
247 codec_data_buffer = gst_buffer_new_and_alloc (2);
248 gst_buffer_fill (codec_data_buffer, 0, codec_data, 2);
249 gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER,
250 codec_data_buffer, NULL);
251 gst_buffer_unref (codec_data_buffer);
253 } else if (aacparse->header_type == DSPAAC_HEADER_NONE) {
254 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
255 "Input is raw, trying ADTS");
256 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adts",
258 if (gst_caps_can_intersect (src_caps, allowed)) {
259 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
260 "Caps can intersect, we will prepend ADTS headers");
261 aacparse->output_header_type = DSPAAC_HEADER_ADTS;
266 gst_caps_unref (allowed);
268 aacparse->last_parsed_channels = 0;
269 aacparse->last_parsed_sample_rate = 0;
271 GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
273 res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
274 gst_caps_unref (src_caps);
278 GST_ERROR_OBJECT (aacparse, "Not a known sample rate: %d",
279 aacparse->sample_rate);
280 gst_caps_unref (src_caps);
286 * gst_aac_parse_sink_setcaps:
290 * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
292 * Returns: TRUE on success.
295 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
297 GstAacParse *aacparse;
298 GstStructure *structure;
302 aacparse = GST_AAC_PARSE (parse);
303 structure = gst_caps_get_structure (caps, 0);
304 caps_str = gst_caps_to_string (caps);
306 GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
309 /* This is needed at least in case of RTP
310 * Parses the codec_data information to get ObjectType,
311 * number of channels and samplerate */
312 value = gst_structure_get_value (structure, "codec_data");
314 GstBuffer *buf = gst_value_get_buffer (value);
316 if (buf && gst_buffer_get_size (buf) >= 2) {
320 if (!gst_buffer_map (buf, &map, GST_MAP_READ))
322 gst_bit_reader_init (&br, map.data, map.size);
323 gst_aac_parse_read_audio_specific_config (aacparse, &br,
324 &aacparse->object_type, &aacparse->sample_rate, &aacparse->channels,
325 &aacparse->frame_samples);
327 aacparse->header_type = DSPAAC_HEADER_NONE;
328 aacparse->mpegversion = 4;
329 gst_buffer_unmap (buf, &map);
331 GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
332 "samples=%d", aacparse->object_type, aacparse->sample_rate,
333 aacparse->channels, aacparse->frame_samples);
335 /* arrange for metadata and get out of the way */
336 gst_aac_parse_set_src_caps (aacparse, caps);
337 if (aacparse->header_type == aacparse->output_header_type)
338 gst_base_parse_set_passthrough (parse, TRUE);
340 /* input is already correctly framed */
341 gst_base_parse_set_min_frame_size (parse, RAW_MAX_SIZE);
346 /* caps info overrides */
347 gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
348 gst_structure_get_int (structure, "channels", &aacparse->channels);
350 const gchar *stream_format =
351 gst_structure_get_string (structure, "stream-format");
353 if (g_strcmp0 (stream_format, "raw") == 0) {
354 GST_ERROR_OBJECT (parse, "Need codec_data for raw AAC");
357 aacparse->sample_rate = 0;
358 aacparse->channels = 0;
359 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
360 gst_base_parse_set_passthrough (parse, FALSE);
368 * gst_aac_parse_adts_get_frame_len:
369 * @data: block of data containing an ADTS header.
371 * This function calculates ADTS frame length from the given header.
373 * Returns: size of the ADTS frame.
376 gst_aac_parse_adts_get_frame_len (const guint8 * data)
378 return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
383 * gst_aac_parse_check_adts_frame:
384 * @aacparse: #GstAacParse.
385 * @data: Data to be checked.
386 * @avail: Amount of data passed.
387 * @framesize: If valid ADTS frame was found, this will be set to tell the
388 * found frame size in bytes.
389 * @needed_data: If frame was not found, this may be set to tell how much
390 * more data is needed in the next round to detect the frame
391 * reliably. This may happen when a frame header candidate
392 * is found but it cannot be guaranteed to be the header without
393 * peeking the following data.
395 * Check if the given data contains contains ADTS frame. The algorithm
396 * will examine ADTS frame header and calculate the frame size. Also, another
397 * consecutive ADTS frame header need to be present after the found frame.
398 * Otherwise the data is not considered as a valid ADTS frame. However, this
399 * "extra check" is omitted when EOS has been received. In this case it is
400 * enough when data[0] contains a valid ADTS header.
402 * This function may set the #needed_data to indicate that a possible frame
403 * candidate has been found, but more data (#needed_data bytes) is needed to
404 * be absolutely sure. When this situation occurs, FALSE will be returned.
406 * When a valid frame is detected, this function will use
407 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
408 * to set the needed bytes for next frame.This way next data chunk is already
411 * Returns: TRUE if the given data contains a valid ADTS header.
414 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
415 const guint8 * data, const guint avail, gboolean drain,
416 guint * framesize, guint * needed_data)
422 /* Absolute minimum to perform the ADTS syncword,
423 layer and sampling frequency tests */
424 if (G_UNLIKELY (avail < 3)) {
429 /* Syncword and layer tests */
430 if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
432 /* Sampling frequency test */
433 if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
436 /* This looks like an ADTS frame header but
437 we need at least 6 bytes to proceed */
438 if (G_UNLIKELY (avail < 6)) {
443 *framesize = gst_aac_parse_adts_get_frame_len (data);
445 /* If frame has CRC, it needs 2 bytes
446 for it at the end of the header */
447 crc_size = (data[1] & 0x01) ? 0 : 2;
450 if (*framesize < 7 + crc_size) {
451 *needed_data = 7 + crc_size;
455 /* In EOS mode this is enough. No need to examine the data further.
456 We also relax the check when we have sync, on the assumption that
457 if we're not looking at random data, we have a much higher chance
458 to get the correct sync, and this avoids losing two frames when
459 a single bit corruption happens. */
460 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
464 if (*framesize + ADTS_MAX_SIZE > avail) {
465 /* We have found a possible frame header candidate, but can't be
466 sure since we don't have enough data to check the next frame */
467 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
468 *framesize + ADTS_MAX_SIZE, avail);
469 *needed_data = *framesize + ADTS_MAX_SIZE;
470 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
471 *framesize + ADTS_MAX_SIZE);
475 if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
476 guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
478 GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
479 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
480 nextlen + ADTS_MAX_SIZE);
488 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
491 guint8 bytes, i, byte;
494 if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
496 for (i = 0; i <= bytes; ++i) {
498 if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
506 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
507 guint8 * audio_object_type)
509 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
511 if (*audio_object_type == 31) {
512 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
514 *audio_object_type += 32;
516 GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
521 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
524 guint8 sampling_frequency_index;
525 if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
527 GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
528 sampling_frequency_index);
529 if (sampling_frequency_index == 0xf) {
530 guint32 sampling_rate;
531 if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
533 *sample_rate = sampling_rate;
535 *sample_rate = loas_sample_rate_table[sampling_frequency_index];
539 aacparse->last_parsed_sample_rate = *sample_rate;
543 /* See table 1.13 in ISO/IEC 14496-3 */
545 gst_aac_parse_read_audio_specific_config (GstAacParse * aacparse,
546 GstBitReader * br, gint * object_type, gint * sample_rate, gint * channels,
547 gint * frame_samples)
549 guint8 audio_object_type;
550 guint8 G_GNUC_UNUSED extension_audio_object_type;
551 guint8 channel_configuration, extension_channel_configuration;
552 gboolean G_GNUC_UNUSED sbr = FALSE, ps = FALSE;
554 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
557 *object_type = audio_object_type;
559 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
562 if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
564 *channels = loas_channels_table[channel_configuration];
565 GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
569 if (audio_object_type == 5 || audio_object_type == 29) {
570 extension_audio_object_type = 5;
572 if (audio_object_type == 29) {
574 /* Parametric stereo. If we have a one-channel configuration, we can
575 * override it to stereo */
580 GST_LOG_OBJECT (aacparse,
581 "Audio object type 5 or 29, so rereading sampling rate (was %d)...",
583 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
586 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
589 if (audio_object_type == 22) {
590 /* extension channel configuration */
591 if (!gst_bit_reader_get_bits_uint8 (br, &extension_channel_configuration,
594 GST_LOG_OBJECT (aacparse, "extension channel_configuration: %d",
595 extension_channel_configuration);
596 *channels = loas_channels_table[extension_channel_configuration];
601 extension_audio_object_type = 0;
604 GST_INFO_OBJECT (aacparse, "Parsed AudioSpecificConfig: %d Hz, %d channels",
605 *sample_rate, *channels);
607 if (frame_samples && audio_object_type == 23) {
609 /* Read the Decoder Configuration (GASpecificConfig) if present */
610 /* We only care about the first bit to know what the number of samples
612 if (!gst_bit_reader_get_bits_uint8 (br, &frame_flag, 1))
614 *frame_samples = frame_flag ? 960 : 1024;
617 /* There's LOTS of stuff next, but we ignore it for now as we have
618 what we want (sample rate and number of channels */
619 GST_DEBUG_OBJECT (aacparse,
620 "Need more code to parse humongous LOAS data, currently ignored");
621 aacparse->last_parsed_channels = *channels;
627 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
628 guint avail, gint * sample_rate, gint * channels, gint * version)
633 /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
637 gst_bit_reader_init (&br, data, avail);
639 /* skip sync word (11 bits) and size (13 bits) */
640 if (!gst_bit_reader_skip (&br, 11 + 13))
643 /* First bit is "use last config" */
644 if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
647 GST_LOG_OBJECT (aacparse, "Frame uses previous config");
648 if (!aacparse->last_parsed_sample_rate || !aacparse->last_parsed_channels) {
649 GST_DEBUG_OBJECT (aacparse,
650 "No previous config to use. We'll look for more data.");
653 *sample_rate = aacparse->last_parsed_sample_rate;
654 *channels = aacparse->last_parsed_channels;
658 GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
660 /* audioMuxVersion */
661 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
664 /* audioMuxVersionA */
665 if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
670 GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
672 guint8 same_time, subframes, num_program, prog;
675 /* taraBufferFullness */
676 if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
679 if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
681 if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
683 if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
685 GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
686 same_time, subframes, num_program);
688 for (prog = 0; prog <= num_program; ++prog) {
689 guint8 num_layer, layer;
690 if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
692 GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
694 for (layer = 0; layer <= num_layer; ++layer) {
695 guint8 use_same_config;
696 if (prog == 0 && layer == 0) {
699 if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
702 if (!use_same_config) {
704 if (!gst_aac_parse_read_audio_specific_config (aacparse, &br, NULL,
705 sample_rate, channels, NULL))
709 if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
711 if (!gst_aac_parse_read_audio_specific_config (aacparse, &br, NULL,
712 sample_rate, channels, NULL))
714 if (!gst_bit_reader_skip (&br, asc_len))
720 GST_LOG_OBJECT (aacparse, "More data ignored");
722 GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
729 * gst_aac_parse_loas_get_frame_len:
730 * @data: block of data containing a LOAS header.
732 * This function calculates LOAS frame length from the given header.
734 * Returns: size of the LOAS frame.
737 gst_aac_parse_loas_get_frame_len (const guint8 * data)
739 return (((data[1] & 0x1f) << 8) | data[2]) + 3;
744 * gst_aac_parse_check_loas_frame:
745 * @aacparse: #GstAacParse.
746 * @data: Data to be checked.
747 * @avail: Amount of data passed.
748 * @framesize: If valid LOAS frame was found, this will be set to tell the
749 * found frame size in bytes.
750 * @needed_data: If frame was not found, this may be set to tell how much
751 * more data is needed in the next round to detect the frame
752 * reliably. This may happen when a frame header candidate
753 * is found but it cannot be guaranteed to be the header without
754 * peeking the following data.
756 * Check if the given data contains contains LOAS frame. The algorithm
757 * will examine LOAS frame header and calculate the frame size. Also, another
758 * consecutive LOAS frame header need to be present after the found frame.
759 * Otherwise the data is not considered as a valid LOAS frame. However, this
760 * "extra check" is omitted when EOS has been received. In this case it is
761 * enough when data[0] contains a valid LOAS header.
763 * This function may set the #needed_data to indicate that a possible frame
764 * candidate has been found, but more data (#needed_data bytes) is needed to
765 * be absolutely sure. When this situation occurs, FALSE will be returned.
767 * When a valid frame is detected, this function will use
768 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
769 * to set the needed bytes for next frame.This way next data chunk is already
772 * LOAS can have three different formats, if I read the spec correctly. Only
773 * one of them is supported here, as the two samples I have use this one.
775 * Returns: TRUE if the given data contains a valid LOAS header.
778 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
779 const guint8 * data, const guint avail, gboolean drain,
780 guint * framesize, guint * needed_data)
785 if (G_UNLIKELY (avail < 3)) {
790 if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
791 *framesize = gst_aac_parse_loas_get_frame_len (data);
792 GST_DEBUG_OBJECT (aacparse, "Found possible %u byte LOAS frame",
795 /* In EOS mode this is enough. No need to examine the data further.
796 We also relax the check when we have sync, on the assumption that
797 if we're not looking at random data, we have a much higher chance
798 to get the correct sync, and this avoids losing two frames when
799 a single bit corruption happens. */
800 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
804 if (*framesize + LOAS_MAX_SIZE > avail) {
805 /* We have found a possible frame header candidate, but can't be
806 sure since we don't have enough data to check the next frame */
807 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
808 *framesize + LOAS_MAX_SIZE, avail);
809 *needed_data = *framesize + LOAS_MAX_SIZE;
810 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
811 *framesize + LOAS_MAX_SIZE);
815 if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
816 guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
818 GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
819 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
820 nextlen + LOAS_MAX_SIZE);
823 GST_DEBUG_OBJECT (aacparse, "That was a false positive");
829 /* caller ensure sufficient data */
831 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
832 gint * rate, gint * channels, gint * object, gint * version)
836 gint sr_idx = (data[2] & 0x3c) >> 2;
838 *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
841 *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
847 *version = (data[1] & 0x08) ? 2 : 4;
849 *object = ((data[2] & 0xc0) >> 6) + 1;
853 * gst_aac_parse_detect_stream:
854 * @aacparse: #GstAacParse.
855 * @data: A block of data that needs to be examined for stream characteristics.
856 * @avail: Size of the given datablock.
857 * @framesize: If valid stream was found, this will be set to tell the
858 * first frame size in bytes.
859 * @skipsize: If valid stream was found, this will be set to tell the first
860 * audio frame position within the given data.
862 * Examines the given piece of data and try to detect the format of it. It
863 * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
864 * header. If the stream is detected, TRUE will be returned and #framesize
865 * is set to indicate the found frame size. Additionally, #skipsize might
866 * be set to indicate the number of bytes that need to be skipped, a.k.a. the
867 * position of the frame inside given data chunk.
869 * Returns: TRUE on success.
872 gst_aac_parse_detect_stream (GstAacParse * aacparse,
873 const guint8 * data, const guint avail, gboolean drain,
874 guint * framesize, gint * skipsize)
876 gboolean found = FALSE;
877 guint need_data_adts = 0, need_data_loas;
880 GST_DEBUG_OBJECT (aacparse, "Parsing header data");
882 /* FIXME: No need to check for ADIF if we are not in the beginning of the
885 /* Can we even parse the header? */
886 if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
887 GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
891 for (i = 0; i < avail - 4; i++) {
892 if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
893 ((data[i] == 0x56) && ((data[i + 1] & 0xe0) == 0xe0)) ||
894 strncmp ((char *) data + i, "ADIF", 4) == 0) {
895 GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
899 /* Trick: tell the parent class that we didn't find the frame yet,
900 but make it skip 'i' amount of bytes. Next time we arrive
901 here we have full frame in the beginning of the data. */
914 if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
915 framesize, &need_data_adts)) {
918 GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
920 gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
921 &aacparse->object_type, &aacparse->mpegversion);
923 if (!channels || !framesize) {
924 GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
928 aacparse->header_type = DSPAAC_HEADER_ADTS;
929 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
930 aacparse->frame_samples, 2, 2);
932 GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
933 rate, channels, aacparse->object_type, aacparse->mpegversion);
935 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
940 if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
941 framesize, &need_data_loas)) {
942 gint rate = 0, channels = 0;
944 GST_INFO ("LOAS, framesize: %d", *framesize);
946 aacparse->header_type = DSPAAC_HEADER_LOAS;
948 if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
949 &channels, &aacparse->mpegversion)) {
950 /* This is pretty normal when skipping data at the start of
951 * random stream (MPEG-TS capture for example) */
952 GST_LOG_OBJECT (aacparse, "Error reading LOAS config");
956 if (rate && channels) {
957 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
958 aacparse->frame_samples, 2, 2);
960 /* Don't store the sample rate and channels yet -
961 * this is just format detection. */
962 GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
963 rate, channels, aacparse->object_type, aacparse->mpegversion);
966 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
971 if (need_data_adts || need_data_loas) {
972 /* This tells the parent class not to skip any data */
977 if (avail < ADIF_MAX_SIZE)
980 if (memcmp (data + i, "ADIF", 4) == 0) {
987 aacparse->header_type = DSPAAC_HEADER_ADIF;
988 aacparse->mpegversion = 4;
990 /* Skip the "ADIF" bytes */
993 /* copyright string */
995 skip_size += 9; /* skip 9 bytes */
997 bitstream_type = adif[0 + skip_size] & 0x10;
999 ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
1000 ((unsigned int) adif[1 + skip_size] << 11) |
1001 ((unsigned int) adif[2 + skip_size] << 3) |
1002 ((unsigned int) adif[3 + skip_size] & 0xe0);
1005 if (bitstream_type == 0) {
1007 /* Buffer fullness parsing. Currently not needed... */
1008 guint num_elems = 0;
1011 num_elems = (adif[3 + skip_size] & 0x1e);
1012 GST_INFO ("ADIF num_config_elems: %d", num_elems);
1014 fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
1015 ((unsigned int) adif[4 + skip_size] << 11) |
1016 ((unsigned int) adif[5 + skip_size] << 3) |
1017 ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
1019 GST_INFO ("ADIF buffer fullness: %d", fullness);
1021 aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
1022 ((adif[7 + skip_size] & 0x80) >> 7);
1023 sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
1027 aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
1028 sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
1029 ((adif[5 + skip_size] & 0x80) >> 7);
1032 /* FIXME: This gives totally wrong results. Duration calculation cannot
1034 aacparse->sample_rate =
1035 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
1037 /* baseparse is not given any fps,
1038 * so it will give up on timestamps, seeking, etc */
1040 /* FIXME: Can we assume this? */
1041 aacparse->channels = 2;
1043 GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
1044 aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
1046 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
1048 /* arrange for metadata and get out of the way */
1049 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
1050 gst_aac_parse_set_src_caps (aacparse, sinkcaps);
1052 gst_caps_unref (sinkcaps);
1054 /* not syncable, not easily seekable (unless we push data from start */
1055 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
1056 gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
1057 gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
1063 /* This should never happen */
1068 * gst_aac_parse_get_audio_profile_object_type
1069 * @aacparse: #GstAacParse.
1071 * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
1072 * mpegversion and profile of @aacparse's src pad caps, according to the
1073 * values defined by table 1.A.11 in ISO/IEC 14496-3.
1075 * Returns: the profile or object type value corresponding to @aacparse's src
1076 * pad caps, if such a value exists; otherwise G_MAXUINT8.
1079 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
1082 GstStructure *srcstruct;
1083 const gchar *profile;
1086 srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1087 if (G_UNLIKELY (srccaps == NULL)) {
1091 srcstruct = gst_caps_get_structure (srccaps, 0);
1092 profile = gst_structure_get_string (srcstruct, "profile");
1093 if (G_UNLIKELY (profile == NULL)) {
1094 gst_caps_unref (srccaps);
1098 if (g_strcmp0 (profile, "main") == 0) {
1100 } else if (g_strcmp0 (profile, "lc") == 0) {
1102 } else if (g_strcmp0 (profile, "ssr") == 0) {
1104 } else if (g_strcmp0 (profile, "ltp") == 0) {
1105 if (G_LIKELY (aacparse->mpegversion == 4))
1108 ret = G_MAXUINT8; /* LTP Object Type allowed only for MPEG-4 */
1113 gst_caps_unref (srccaps);
1118 * gst_aac_parse_get_audio_channel_configuration
1119 * @num_channels: number of audio channels.
1121 * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1122 * 14496-3, for a given number of audio channels.
1124 * Returns: the Channel Configuration value corresponding to @num_channels, if
1125 * such a value exists; otherwise G_MAXUINT8.
1128 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1130 if (num_channels >= 1 && num_channels <= 6) /* Mono up to & including 5.1 */
1131 return (guint8) num_channels;
1132 else if (num_channels == 8) /* 7.1 */
1137 /* FIXME: Add support for configurations 11, 12 and 14 from
1138 * ISO/IEC 14496-3:2009/PDAM 4 based on the actual channel layout
1143 * gst_aac_parse_get_audio_sampling_frequency_index:
1144 * @sample_rate: audio sampling rate.
1146 * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1147 * 14496-3, for a given sampling rate.
1149 * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1150 * if such a value exists; otherwise G_MAXUINT8.
1153 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1155 switch (sample_rate) {
1188 * gst_aac_parse_prepend_adts_headers:
1189 * @aacparse: #GstAacParse.
1190 * @frame: raw AAC frame to which ADTS headers shall be prepended.
1192 * Prepends ADTS headers to a raw AAC audio frame.
1194 * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1197 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1198 GstBaseParseFrame * frame)
1201 guint8 *adts_headers;
1204 guint8 id, profile, channel_configuration, sampling_frequency_index;
1206 id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1207 profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1208 if (profile == G_MAXUINT8) {
1209 GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1212 channel_configuration =
1213 gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1214 if (channel_configuration == G_MAXUINT8) {
1215 GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1218 sampling_frequency_index =
1219 gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1220 if (sampling_frequency_index == G_MAXUINT8) {
1221 GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1225 frame->out_buffer = gst_buffer_copy (frame->buffer);
1226 buf_size = gst_buffer_get_size (frame->out_buffer);
1227 frame_size = buf_size + ADTS_HEADERS_LENGTH;
1229 if (G_UNLIKELY (frame_size >= 0x4000)) {
1230 GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1234 adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1236 /* Note: no error correction bits are added to the resulting ADTS frames */
1237 adts_headers[0] = 0xFFU;
1238 adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1239 adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1240 (channel_configuration & 0x4U);
1241 adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1242 (guint8) (frame_size >> 11);
1243 adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1244 adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1245 adts_headers[6] = 0xFCU;
1247 mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1248 ADTS_HEADERS_LENGTH, adts_headers, g_free);
1249 gst_buffer_prepend_memory (frame->out_buffer, mem);
1255 * gst_aac_parse_check_valid_frame:
1256 * @parse: #GstBaseParse.
1257 * @frame: #GstBaseParseFrame.
1258 * @skipsize: How much data parent class should skip in order to find the
1261 * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1263 * Also determines frame overhead.
1264 * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1265 * a per-frame header. LOAS has 3 bytes.
1267 * We're making a couple of simplifying assumptions:
1269 * 1. We count Program Configuration Elements rather than searching for them
1270 * in the streams to discount them - the overhead is negligible.
1272 * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1273 * bits, which should still not be significant enough to warrant the
1274 * additional parsing through the headers
1276 * Returns: a #GstFlowReturn.
1278 static GstFlowReturn
1279 gst_aac_parse_handle_frame (GstBaseParse * parse,
1280 GstBaseParseFrame * frame, gint * skipsize)
1283 GstAacParse *aacparse;
1284 gboolean ret = FALSE;
1288 gint rate = 0, channels = 0;
1290 aacparse = GST_AAC_PARSE (parse);
1291 buffer = frame->buffer;
1293 gst_buffer_map (buffer, &map, GST_MAP_READ);
1296 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1298 if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1299 aacparse->header_type == DSPAAC_HEADER_NONE) {
1300 /* There is nothing to parse */
1301 framesize = map.size;
1304 } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1306 ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1307 GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1309 } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1310 guint needed_data = 1024;
1312 ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1313 GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1315 if (!ret && needed_data) {
1316 GST_DEBUG ("buffer didn't contain valid frame");
1318 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1322 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1323 guint needed_data = 1024;
1325 ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1326 map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1328 if (!ret && needed_data) {
1329 GST_DEBUG ("buffer didn't contain valid frame");
1331 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1336 GST_DEBUG ("buffer didn't contain valid frame");
1337 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1341 if (G_UNLIKELY (!ret))
1344 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1346 frame->overhead = 7;
1348 gst_aac_parse_parse_adts_header (aacparse, map.data,
1349 &rate, &channels, NULL, NULL);
1351 GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1353 if (G_UNLIKELY (rate != aacparse->sample_rate
1354 || channels != aacparse->channels)) {
1355 aacparse->sample_rate = rate;
1356 aacparse->channels = channels;
1358 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1359 /* If linking fails, we need to return appropriate error */
1360 ret = GST_FLOW_NOT_LINKED;
1363 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1364 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1366 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1367 gboolean setcaps = FALSE;
1370 frame->overhead = 3;
1372 if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1373 &channels, NULL) || !rate || !channels) {
1374 /* This is pretty normal when skipping data at the start of
1375 * random stream (MPEG-TS capture for example) */
1376 GST_DEBUG_OBJECT (aacparse, "Error reading LOAS config. Skipping.");
1377 /* Since we don't fully parse the LOAS config, we don't know for sure
1378 * how much to skip. Just skip 1 to end up to the next marker and
1379 * resume parsing from there */
1384 if (G_UNLIKELY (rate != aacparse->sample_rate
1385 || channels != aacparse->channels)) {
1386 aacparse->sample_rate = rate;
1387 aacparse->channels = channels;
1389 GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1393 /* We want to set caps both at start, and when rate/channels change.
1394 Since only some LOAS frames have that info, we may receive frames
1395 before knowing about rate/channels. */
1397 || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1398 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1399 /* If linking fails, we need to return appropriate error */
1400 ret = GST_FLOW_NOT_LINKED;
1403 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1404 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1408 if (aacparse->header_type == DSPAAC_HEADER_NONE
1409 && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1410 if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1411 GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1412 ret = GST_FLOW_ERROR;
1417 gst_buffer_unmap (buffer, &map);
1420 /* found, skip if needed */
1429 if (ret && framesize <= map.size) {
1430 return gst_base_parse_finish_frame (parse, frame, framesize);
1436 static GstFlowReturn
1437 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1439 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1441 if (!aacparse->sent_codec_tag) {
1442 GstTagList *taglist;
1446 caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1448 if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
1449 GST_INFO_OBJECT (parse, "Src pad is flushing");
1450 return GST_FLOW_FLUSHING;
1452 GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
1453 return GST_FLOW_NOT_NEGOTIATED;
1457 taglist = gst_tag_list_new_empty ();
1458 gst_pb_utils_add_codec_description_to_tag_list (taglist,
1459 GST_TAG_AUDIO_CODEC, caps);
1460 gst_caps_unref (caps);
1462 gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
1463 gst_tag_list_unref (taglist);
1465 /* also signals the end of first-frame processing */
1466 aacparse->sent_codec_tag = TRUE;
1469 /* As a special case, we can remove the ADTS framing and output raw AAC. */
1470 if (aacparse->header_type == DSPAAC_HEADER_ADTS
1471 && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1474 frame->out_buffer = gst_buffer_make_writable (frame->buffer);
1475 frame->buffer = NULL;
1476 gst_buffer_map (frame->out_buffer, &map, GST_MAP_READ);
1477 header_size = (map.data[1] & 1) ? 7 : 9; /* optional CRC */
1478 gst_buffer_unmap (frame->out_buffer, &map);
1479 gst_buffer_resize (frame->out_buffer, header_size,
1480 gst_buffer_get_size (frame->out_buffer) - header_size);
1483 frame->flags |= GST_BASE_PARSE_FRAME_FLAG_CLIP;
1490 * gst_aac_parse_start:
1491 * @parse: #GstBaseParse.
1493 * Implementation of "start" vmethod in #GstBaseParse class.
1495 * Returns: TRUE if startup succeeded.
1498 gst_aac_parse_start (GstBaseParse * parse)
1500 GstAacParse *aacparse;
1502 aacparse = GST_AAC_PARSE (parse);
1503 GST_DEBUG ("start");
1504 aacparse->frame_samples = 1024;
1505 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1506 aacparse->sent_codec_tag = FALSE;
1507 aacparse->last_parsed_channels = 0;
1508 aacparse->last_parsed_sample_rate = 0;
1509 aacparse->object_type = 0;
1510 aacparse->bitrate = 0;
1511 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
1512 aacparse->output_header_type = DSPAAC_HEADER_NOT_PARSED;
1513 aacparse->channels = 0;
1514 aacparse->sample_rate = 0;
1520 * gst_aac_parse_stop:
1521 * @parse: #GstBaseParse.
1523 * Implementation of "stop" vmethod in #GstBaseParse class.
1525 * Returns: TRUE is stopping succeeded.
1528 gst_aac_parse_stop (GstBaseParse * parse)
1535 remove_fields (GstCaps * caps)
1539 n = gst_caps_get_size (caps);
1540 for (i = 0; i < n; i++) {
1541 GstStructure *s = gst_caps_get_structure (caps, i);
1543 gst_structure_remove_field (s, "framed");
1548 add_conversion_fields (GstCaps * caps)
1552 n = gst_caps_get_size (caps);
1553 for (i = 0; i < n; i++) {
1554 GstStructure *s = gst_caps_get_structure (caps, i);
1556 if (gst_structure_has_field (s, "stream-format")) {
1557 const GValue *v = gst_structure_get_value (s, "stream-format");
1559 if (G_VALUE_HOLDS_STRING (v)) {
1560 const gchar *str = g_value_get_string (v);
1562 if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1563 GValue va = G_VALUE_INIT;
1564 GValue vs = G_VALUE_INIT;
1566 g_value_init (&va, GST_TYPE_LIST);
1567 g_value_init (&vs, G_TYPE_STRING);
1568 g_value_set_string (&vs, "adts");
1569 gst_value_list_append_value (&va, &vs);
1570 g_value_set_string (&vs, "raw");
1571 gst_value_list_append_value (&va, &vs);
1572 gst_structure_set_value (s, "stream-format", &va);
1573 g_value_unset (&va);
1574 g_value_unset (&vs);
1576 } else if (GST_VALUE_HOLDS_LIST (v)) {
1577 gboolean contains_raw = FALSE;
1578 gboolean contains_adts = FALSE;
1579 guint m = gst_value_list_get_size (v), j;
1581 for (j = 0; j < m; j++) {
1582 const GValue *ve = gst_value_list_get_value (v, j);
1585 if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1586 if (strcmp (str, "adts") == 0)
1587 contains_adts = TRUE;
1588 else if (strcmp (str, "raw") == 0)
1589 contains_raw = TRUE;
1593 if (contains_adts || contains_raw) {
1594 GValue va = G_VALUE_INIT;
1595 GValue vs = G_VALUE_INIT;
1597 g_value_init (&va, GST_TYPE_LIST);
1598 g_value_init (&vs, G_TYPE_STRING);
1599 g_value_copy (v, &va);
1601 if (!contains_raw) {
1602 g_value_set_string (&vs, "raw");
1603 gst_value_list_append_value (&va, &vs);
1605 if (!contains_adts) {
1606 g_value_set_string (&vs, "adts");
1607 gst_value_list_append_value (&va, &vs);
1610 gst_structure_set_value (s, "stream-format", &va);
1612 g_value_unset (&vs);
1613 g_value_unset (&va);
1621 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1623 GstCaps *peercaps, *templ;
1626 templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1629 GstCaps *fcopy = gst_caps_copy (filter);
1630 /* Remove the fields we convert */
1631 remove_fields (fcopy);
1632 add_conversion_fields (fcopy);
1633 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1634 gst_caps_unref (fcopy);
1636 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1639 peercaps = gst_caps_make_writable (peercaps);
1640 /* Remove the fields we convert */
1641 remove_fields (peercaps);
1642 add_conversion_fields (peercaps);
1644 res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1645 gst_caps_unref (peercaps);
1646 gst_caps_unref (templ);
1652 GstCaps *intersection;
1655 gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1656 gst_caps_unref (res);
1664 gst_aac_parse_src_event (GstBaseParse * parse, GstEvent * event)
1666 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1668 if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
1669 aacparse->last_parsed_channels = 0;
1670 aacparse->last_parsed_sample_rate = 0;
1673 return GST_BASE_PARSE_CLASS (parent_class)->src_event (parse, event);