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
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-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);
252 } else if (aacparse->header_type == DSPAAC_HEADER_NONE) {
253 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
254 "Input is raw, trying ADTS");
255 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adts",
257 if (gst_caps_can_intersect (src_caps, allowed)) {
258 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
259 "Caps can intersect, we will prepend ADTS headers");
260 aacparse->output_header_type = DSPAAC_HEADER_ADTS;
265 gst_caps_unref (allowed);
267 aacparse->last_parsed_channels = 0;
268 aacparse->last_parsed_sample_rate = 0;
270 GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
272 res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
273 gst_caps_unref (src_caps);
277 GST_ERROR_OBJECT (aacparse, "Not a known sample rate: %d",
278 aacparse->sample_rate);
279 gst_caps_unref (src_caps);
285 * gst_aac_parse_sink_setcaps:
289 * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
291 * Returns: TRUE on success.
294 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
296 GstAacParse *aacparse;
297 GstStructure *structure;
301 aacparse = GST_AAC_PARSE (parse);
302 structure = gst_caps_get_structure (caps, 0);
303 caps_str = gst_caps_to_string (caps);
305 GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
308 /* This is needed at least in case of RTP
309 * Parses the codec_data information to get ObjectType,
310 * number of channels and samplerate */
311 value = gst_structure_get_value (structure, "codec_data");
313 GstBuffer *buf = gst_value_get_buffer (value);
315 if (buf && gst_buffer_get_size (buf) >= 2) {
319 if (!gst_buffer_map (buf, &map, GST_MAP_READ))
321 gst_bit_reader_init (&br, map.data, map.size);
322 gst_aac_parse_read_audio_specific_config (aacparse, &br,
323 &aacparse->object_type, &aacparse->sample_rate, &aacparse->channels,
324 &aacparse->frame_samples);
326 aacparse->header_type = DSPAAC_HEADER_NONE;
327 aacparse->mpegversion = 4;
328 gst_buffer_unmap (buf, &map);
330 GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
331 "samples=%d", aacparse->object_type, aacparse->sample_rate,
332 aacparse->channels, aacparse->frame_samples);
334 /* arrange for metadata and get out of the way */
335 gst_aac_parse_set_src_caps (aacparse, caps);
336 if (aacparse->header_type == aacparse->output_header_type)
337 gst_base_parse_set_passthrough (parse, TRUE);
339 /* input is already correctly framed */
340 gst_base_parse_set_min_frame_size (parse, RAW_MAX_SIZE);
345 /* caps info overrides */
346 gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
347 gst_structure_get_int (structure, "channels", &aacparse->channels);
349 const gchar *stream_format =
350 gst_structure_get_string (structure, "stream-format");
352 if (g_strcmp0 (stream_format, "raw") == 0) {
353 GST_ERROR_OBJECT (parse, "Need codec_data for raw AAC");
356 aacparse->sample_rate = 0;
357 aacparse->channels = 0;
358 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
359 gst_base_parse_set_passthrough (parse, FALSE);
367 * gst_aac_parse_adts_get_frame_len:
368 * @data: block of data containing an ADTS header.
370 * This function calculates ADTS frame length from the given header.
372 * Returns: size of the ADTS frame.
375 gst_aac_parse_adts_get_frame_len (const guint8 * data)
377 return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
382 * gst_aac_parse_check_adts_frame:
383 * @aacparse: #GstAacParse.
384 * @data: Data to be checked.
385 * @avail: Amount of data passed.
386 * @framesize: If valid ADTS frame was found, this will be set to tell the
387 * found frame size in bytes.
388 * @needed_data: If frame was not found, this may be set to tell how much
389 * more data is needed in the next round to detect the frame
390 * reliably. This may happen when a frame header candidate
391 * is found but it cannot be guaranteed to be the header without
392 * peeking the following data.
394 * Check if the given data contains contains ADTS frame. The algorithm
395 * will examine ADTS frame header and calculate the frame size. Also, another
396 * consecutive ADTS frame header need to be present after the found frame.
397 * Otherwise the data is not considered as a valid ADTS frame. However, this
398 * "extra check" is omitted when EOS has been received. In this case it is
399 * enough when data[0] contains a valid ADTS header.
401 * This function may set the #needed_data to indicate that a possible frame
402 * candidate has been found, but more data (#needed_data bytes) is needed to
403 * be absolutely sure. When this situation occurs, FALSE will be returned.
405 * When a valid frame is detected, this function will use
406 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
407 * to set the needed bytes for next frame.This way next data chunk is already
410 * Returns: TRUE if the given data contains a valid ADTS header.
413 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
414 const guint8 * data, const guint avail, gboolean drain,
415 guint * framesize, guint * needed_data)
421 /* Absolute minimum to perform the ADTS syncword,
422 layer and sampling frequency tests */
423 if (G_UNLIKELY (avail < 3)) {
428 /* Syncword and layer tests */
429 if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
431 /* Sampling frequency test */
432 if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
435 /* This looks like an ADTS frame header but
436 we need at least 6 bytes to proceed */
437 if (G_UNLIKELY (avail < 6)) {
442 *framesize = gst_aac_parse_adts_get_frame_len (data);
444 /* If frame has CRC, it needs 2 bytes
445 for it at the end of the header */
446 crc_size = (data[1] & 0x01) ? 0 : 2;
449 if (*framesize < 7 + crc_size) {
450 *needed_data = 7 + crc_size;
454 /* In EOS mode this is enough. No need to examine the data further.
455 We also relax the check when we have sync, on the assumption that
456 if we're not looking at random data, we have a much higher chance
457 to get the correct sync, and this avoids losing two frames when
458 a single bit corruption happens. */
459 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
463 if (*framesize + ADTS_MAX_SIZE > avail) {
464 /* We have found a possible frame header candidate, but can't be
465 sure since we don't have enough data to check the next frame */
466 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
467 *framesize + ADTS_MAX_SIZE, avail);
468 *needed_data = *framesize + ADTS_MAX_SIZE;
469 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
470 *framesize + ADTS_MAX_SIZE);
474 if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
475 guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
477 GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
478 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
479 nextlen + ADTS_MAX_SIZE);
487 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
490 guint8 bytes, i, byte;
493 if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
495 for (i = 0; i <= bytes; ++i) {
497 if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
505 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
506 guint8 * audio_object_type)
508 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
510 if (*audio_object_type == 31) {
511 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
513 *audio_object_type += 32;
515 GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
520 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
523 guint8 sampling_frequency_index;
524 if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
526 GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
527 sampling_frequency_index);
528 if (sampling_frequency_index == 0xf) {
529 guint32 sampling_rate;
530 if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
532 *sample_rate = sampling_rate;
534 *sample_rate = loas_sample_rate_table[sampling_frequency_index];
538 aacparse->last_parsed_sample_rate = *sample_rate;
542 /* See table 1.13 in ISO/IEC 14496-3 */
544 gst_aac_parse_read_audio_specific_config (GstAacParse * aacparse,
545 GstBitReader * br, gint * object_type, gint * sample_rate, gint * channels,
546 gint * frame_samples)
548 guint8 audio_object_type;
549 guint8 G_GNUC_UNUSED extension_audio_object_type;
550 guint8 channel_configuration, extension_channel_configuration;
551 gboolean G_GNUC_UNUSED sbr = FALSE, ps = FALSE;
553 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
556 *object_type = audio_object_type;
558 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
561 if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
563 *channels = loas_channels_table[channel_configuration];
564 GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
568 if (audio_object_type == 5 || audio_object_type == 29) {
569 extension_audio_object_type = 5;
571 if (audio_object_type == 29) {
573 /* Parametric stereo. If we have a one-channel configuration, we can
574 * override it to stereo */
579 GST_LOG_OBJECT (aacparse,
580 "Audio object type 5 or 29, so rereading sampling rate (was %d)...",
582 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
585 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
588 if (audio_object_type == 22) {
589 /* extension channel configuration */
590 if (!gst_bit_reader_get_bits_uint8 (br, &extension_channel_configuration,
593 GST_LOG_OBJECT (aacparse, "extension channel_configuration: %d",
594 extension_channel_configuration);
595 *channels = loas_channels_table[extension_channel_configuration];
600 extension_audio_object_type = 0;
603 GST_INFO_OBJECT (aacparse, "Parsed AudioSpecificConfig: %d Hz, %d channels",
604 *sample_rate, *channels);
606 if (frame_samples && audio_object_type == 23) {
608 /* Read the Decoder Configuration (GASpecificConfig) if present */
609 /* We only care about the first bit to know what the number of samples
611 if (!gst_bit_reader_get_bits_uint8 (br, &frame_flag, 1))
613 *frame_samples = frame_flag ? 960 : 1024;
616 /* There's LOTS of stuff next, but we ignore it for now as we have
617 what we want (sample rate and number of channels */
618 GST_DEBUG_OBJECT (aacparse,
619 "Need more code to parse humongous LOAS data, currently ignored");
620 aacparse->last_parsed_channels = *channels;
626 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
627 guint avail, gint * sample_rate, gint * channels, gint * version)
632 /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
636 gst_bit_reader_init (&br, data, avail);
638 /* skip sync word (11 bits) and size (13 bits) */
639 if (!gst_bit_reader_skip (&br, 11 + 13))
642 /* First bit is "use last config" */
643 if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
646 GST_LOG_OBJECT (aacparse, "Frame uses previous config");
647 if (!aacparse->last_parsed_sample_rate || !aacparse->last_parsed_channels) {
648 GST_DEBUG_OBJECT (aacparse,
649 "No previous config to use. We'll look for more data.");
652 *sample_rate = aacparse->last_parsed_sample_rate;
653 *channels = aacparse->last_parsed_channels;
657 GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
659 /* audioMuxVersion */
660 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
663 /* audioMuxVersionA */
664 if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
669 GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
671 guint8 same_time, subframes, num_program, prog;
674 /* taraBufferFullness */
675 if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
678 if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
680 if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
682 if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
684 GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
685 same_time, subframes, num_program);
687 for (prog = 0; prog <= num_program; ++prog) {
688 guint8 num_layer, layer;
689 if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
691 GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
693 for (layer = 0; layer <= num_layer; ++layer) {
694 guint8 use_same_config;
695 if (prog == 0 && layer == 0) {
698 if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
701 if (!use_same_config) {
703 if (!gst_aac_parse_read_audio_specific_config (aacparse, &br, NULL,
704 sample_rate, channels, NULL))
708 if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
710 if (!gst_aac_parse_read_audio_specific_config (aacparse, &br, NULL,
711 sample_rate, channels, NULL))
713 if (!gst_bit_reader_skip (&br, asc_len))
719 GST_LOG_OBJECT (aacparse, "More data ignored");
721 GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
728 * gst_aac_parse_loas_get_frame_len:
729 * @data: block of data containing a LOAS header.
731 * This function calculates LOAS frame length from the given header.
733 * Returns: size of the LOAS frame.
736 gst_aac_parse_loas_get_frame_len (const guint8 * data)
738 return (((data[1] & 0x1f) << 8) | data[2]) + 3;
743 * gst_aac_parse_check_loas_frame:
744 * @aacparse: #GstAacParse.
745 * @data: Data to be checked.
746 * @avail: Amount of data passed.
747 * @framesize: If valid LOAS frame was found, this will be set to tell the
748 * found frame size in bytes.
749 * @needed_data: If frame was not found, this may be set to tell how much
750 * more data is needed in the next round to detect the frame
751 * reliably. This may happen when a frame header candidate
752 * is found but it cannot be guaranteed to be the header without
753 * peeking the following data.
755 * Check if the given data contains contains LOAS frame. The algorithm
756 * will examine LOAS frame header and calculate the frame size. Also, another
757 * consecutive LOAS frame header need to be present after the found frame.
758 * Otherwise the data is not considered as a valid LOAS frame. However, this
759 * "extra check" is omitted when EOS has been received. In this case it is
760 * enough when data[0] contains a valid LOAS header.
762 * This function may set the #needed_data to indicate that a possible frame
763 * candidate has been found, but more data (#needed_data bytes) is needed to
764 * be absolutely sure. When this situation occurs, FALSE will be returned.
766 * When a valid frame is detected, this function will use
767 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
768 * to set the needed bytes for next frame.This way next data chunk is already
771 * LOAS can have three different formats, if I read the spec correctly. Only
772 * one of them is supported here, as the two samples I have use this one.
774 * Returns: TRUE if the given data contains a valid LOAS header.
777 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
778 const guint8 * data, const guint avail, gboolean drain,
779 guint * framesize, guint * needed_data)
784 if (G_UNLIKELY (avail < 3)) {
789 if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
790 *framesize = gst_aac_parse_loas_get_frame_len (data);
791 GST_DEBUG_OBJECT (aacparse, "Found possible %u byte LOAS frame",
794 /* In EOS mode this is enough. No need to examine the data further.
795 We also relax the check when we have sync, on the assumption that
796 if we're not looking at random data, we have a much higher chance
797 to get the correct sync, and this avoids losing two frames when
798 a single bit corruption happens. */
799 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
803 if (*framesize + LOAS_MAX_SIZE > avail) {
804 /* We have found a possible frame header candidate, but can't be
805 sure since we don't have enough data to check the next frame */
806 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
807 *framesize + LOAS_MAX_SIZE, avail);
808 *needed_data = *framesize + LOAS_MAX_SIZE;
809 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
810 *framesize + LOAS_MAX_SIZE);
814 if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
815 guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
817 GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
818 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
819 nextlen + LOAS_MAX_SIZE);
822 GST_DEBUG_OBJECT (aacparse, "That was a false positive");
828 /* caller ensure sufficient data */
830 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
831 gint * rate, gint * channels, gint * object, gint * version)
835 gint sr_idx = (data[2] & 0x3c) >> 2;
837 *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
840 *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
846 *version = (data[1] & 0x08) ? 2 : 4;
848 *object = ((data[2] & 0xc0) >> 6) + 1;
852 * gst_aac_parse_detect_stream:
853 * @aacparse: #GstAacParse.
854 * @data: A block of data that needs to be examined for stream characteristics.
855 * @avail: Size of the given datablock.
856 * @framesize: If valid stream was found, this will be set to tell the
857 * first frame size in bytes.
858 * @skipsize: If valid stream was found, this will be set to tell the first
859 * audio frame position within the given data.
861 * Examines the given piece of data and try to detect the format of it. It
862 * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
863 * header. If the stream is detected, TRUE will be returned and #framesize
864 * is set to indicate the found frame size. Additionally, #skipsize might
865 * be set to indicate the number of bytes that need to be skipped, a.k.a. the
866 * position of the frame inside given data chunk.
868 * Returns: TRUE on success.
871 gst_aac_parse_detect_stream (GstAacParse * aacparse,
872 const guint8 * data, const guint avail, gboolean drain,
873 guint * framesize, gint * skipsize)
875 gboolean found = FALSE;
876 guint need_data_adts = 0, need_data_loas;
879 GST_DEBUG_OBJECT (aacparse, "Parsing header data");
881 /* FIXME: No need to check for ADIF if we are not in the beginning of the
884 /* Can we even parse the header? */
885 if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
886 GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
890 for (i = 0; i < avail - 4; i++) {
891 if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
892 ((data[i] == 0x56) && ((data[i + 1] & 0xe0) == 0xe0)) ||
893 strncmp ((char *) data + i, "ADIF", 4) == 0) {
894 GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
898 /* Trick: tell the parent class that we didn't find the frame yet,
899 but make it skip 'i' amount of bytes. Next time we arrive
900 here we have full frame in the beginning of the data. */
913 if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
914 framesize, &need_data_adts)) {
917 GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
919 gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
920 &aacparse->object_type, &aacparse->mpegversion);
922 if (!channels || !framesize) {
923 GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
927 aacparse->header_type = DSPAAC_HEADER_ADTS;
928 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
929 aacparse->frame_samples, 2, 2);
931 GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
932 rate, channels, aacparse->object_type, aacparse->mpegversion);
934 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
939 if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
940 framesize, &need_data_loas)) {
941 gint rate = 0, channels = 0;
943 GST_INFO ("LOAS, framesize: %d", *framesize);
945 aacparse->header_type = DSPAAC_HEADER_LOAS;
947 if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
948 &channels, &aacparse->mpegversion)) {
949 /* This is pretty normal when skipping data at the start of
950 * random stream (MPEG-TS capture for example) */
951 GST_LOG_OBJECT (aacparse, "Error reading LOAS config");
955 if (rate && channels) {
956 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
957 aacparse->frame_samples, 2, 2);
959 /* Don't store the sample rate and channels yet -
960 * this is just format detection. */
961 GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
962 rate, channels, aacparse->object_type, aacparse->mpegversion);
965 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
970 if (need_data_adts || need_data_loas) {
971 /* This tells the parent class not to skip any data */
976 if (avail < ADIF_MAX_SIZE)
979 if (memcmp (data + i, "ADIF", 4) == 0) {
986 aacparse->header_type = DSPAAC_HEADER_ADIF;
987 aacparse->mpegversion = 4;
989 /* Skip the "ADIF" bytes */
992 /* copyright string */
994 skip_size += 9; /* skip 9 bytes */
996 bitstream_type = adif[0 + skip_size] & 0x10;
998 ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
999 ((unsigned int) adif[1 + skip_size] << 11) |
1000 ((unsigned int) adif[2 + skip_size] << 3) |
1001 ((unsigned int) adif[3 + skip_size] & 0xe0);
1004 if (bitstream_type == 0) {
1006 /* Buffer fullness parsing. Currently not needed... */
1007 guint num_elems = 0;
1010 num_elems = (adif[3 + skip_size] & 0x1e);
1011 GST_INFO ("ADIF num_config_elems: %d", num_elems);
1013 fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
1014 ((unsigned int) adif[4 + skip_size] << 11) |
1015 ((unsigned int) adif[5 + skip_size] << 3) |
1016 ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
1018 GST_INFO ("ADIF buffer fullness: %d", fullness);
1020 aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
1021 ((adif[7 + skip_size] & 0x80) >> 7);
1022 sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
1026 aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
1027 sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
1028 ((adif[5 + skip_size] & 0x80) >> 7);
1031 /* FIXME: This gives totally wrong results. Duration calculation cannot
1033 aacparse->sample_rate =
1034 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
1036 /* baseparse is not given any fps,
1037 * so it will give up on timestamps, seeking, etc */
1039 /* FIXME: Can we assume this? */
1040 aacparse->channels = 2;
1042 GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
1043 aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
1045 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
1047 /* arrange for metadata and get out of the way */
1048 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
1049 gst_aac_parse_set_src_caps (aacparse, sinkcaps);
1051 gst_caps_unref (sinkcaps);
1053 /* not syncable, not easily seekable (unless we push data from start */
1054 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
1055 gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
1056 gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
1062 /* This should never happen */
1067 * gst_aac_parse_get_audio_profile_object_type
1068 * @aacparse: #GstAacParse.
1070 * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
1071 * mpegversion and profile of @aacparse's src pad caps, according to the
1072 * values defined by table 1.A.11 in ISO/IEC 14496-3.
1074 * Returns: the profile or object type value corresponding to @aacparse's src
1075 * pad caps, if such a value exists; otherwise G_MAXUINT8.
1078 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
1081 GstStructure *srcstruct;
1082 const gchar *profile;
1085 srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1086 if (G_UNLIKELY (srccaps == NULL)) {
1090 srcstruct = gst_caps_get_structure (srccaps, 0);
1091 profile = gst_structure_get_string (srcstruct, "profile");
1092 if (G_UNLIKELY (profile == NULL)) {
1093 gst_caps_unref (srccaps);
1097 if (g_strcmp0 (profile, "main") == 0) {
1099 } else if (g_strcmp0 (profile, "lc") == 0) {
1101 } else if (g_strcmp0 (profile, "ssr") == 0) {
1103 } else if (g_strcmp0 (profile, "ltp") == 0) {
1104 if (G_LIKELY (aacparse->mpegversion == 4))
1107 ret = G_MAXUINT8; /* LTP Object Type allowed only for MPEG-4 */
1112 gst_caps_unref (srccaps);
1117 * gst_aac_parse_get_audio_channel_configuration
1118 * @num_channels: number of audio channels.
1120 * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1121 * 14496-3, for a given number of audio channels.
1123 * Returns: the Channel Configuration value corresponding to @num_channels, if
1124 * such a value exists; otherwise G_MAXUINT8.
1127 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1129 if (num_channels >= 1 && num_channels <= 6) /* Mono up to & including 5.1 */
1130 return (guint8) num_channels;
1131 else if (num_channels == 8) /* 7.1 */
1136 /* FIXME: Add support for configurations 11, 12 and 14 from
1137 * ISO/IEC 14496-3:2009/PDAM 4 based on the actual channel layout
1142 * gst_aac_parse_get_audio_sampling_frequency_index:
1143 * @sample_rate: audio sampling rate.
1145 * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1146 * 14496-3, for a given sampling rate.
1148 * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1149 * if such a value exists; otherwise G_MAXUINT8.
1152 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1154 switch (sample_rate) {
1187 * gst_aac_parse_prepend_adts_headers:
1188 * @aacparse: #GstAacParse.
1189 * @frame: raw AAC frame to which ADTS headers shall be prepended.
1191 * Prepends ADTS headers to a raw AAC audio frame.
1193 * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1196 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1197 GstBaseParseFrame * frame)
1200 guint8 *adts_headers;
1203 guint8 id, profile, channel_configuration, sampling_frequency_index;
1205 id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1206 profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1207 if (profile == G_MAXUINT8) {
1208 GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1211 channel_configuration =
1212 gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1213 if (channel_configuration == G_MAXUINT8) {
1214 GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1217 sampling_frequency_index =
1218 gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1219 if (sampling_frequency_index == G_MAXUINT8) {
1220 GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1224 frame->out_buffer = gst_buffer_copy (frame->buffer);
1225 buf_size = gst_buffer_get_size (frame->out_buffer);
1226 frame_size = buf_size + ADTS_HEADERS_LENGTH;
1228 if (G_UNLIKELY (frame_size >= 0x4000)) {
1229 GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1233 adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1235 /* Note: no error correction bits are added to the resulting ADTS frames */
1236 adts_headers[0] = 0xFFU;
1237 adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1238 adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1239 (channel_configuration & 0x4U);
1240 adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1241 (guint8) (frame_size >> 11);
1242 adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1243 adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1244 adts_headers[6] = 0xFCU;
1246 mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1247 ADTS_HEADERS_LENGTH, adts_headers, g_free);
1248 gst_buffer_prepend_memory (frame->out_buffer, mem);
1254 * gst_aac_parse_check_valid_frame:
1255 * @parse: #GstBaseParse.
1256 * @frame: #GstBaseParseFrame.
1257 * @skipsize: How much data parent class should skip in order to find the
1260 * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1262 * Also determines frame overhead.
1263 * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1264 * a per-frame header. LOAS has 3 bytes.
1266 * We're making a couple of simplifying assumptions:
1268 * 1. We count Program Configuration Elements rather than searching for them
1269 * in the streams to discount them - the overhead is negligible.
1271 * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1272 * bits, which should still not be significant enough to warrant the
1273 * additional parsing through the headers
1275 * Returns: a #GstFlowReturn.
1277 static GstFlowReturn
1278 gst_aac_parse_handle_frame (GstBaseParse * parse,
1279 GstBaseParseFrame * frame, gint * skipsize)
1282 GstAacParse *aacparse;
1283 gboolean ret = FALSE;
1287 gint rate = 0, channels = 0;
1289 aacparse = GST_AAC_PARSE (parse);
1290 buffer = frame->buffer;
1292 gst_buffer_map (buffer, &map, GST_MAP_READ);
1295 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1297 if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1298 aacparse->header_type == DSPAAC_HEADER_NONE) {
1299 /* There is nothing to parse */
1300 framesize = map.size;
1303 } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1305 ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1306 GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1308 } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1309 guint needed_data = 1024;
1311 ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1312 GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1314 if (!ret && needed_data) {
1315 GST_DEBUG ("buffer didn't contain valid frame");
1317 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1321 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1322 guint needed_data = 1024;
1324 ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1325 map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1327 if (!ret && needed_data) {
1328 GST_DEBUG ("buffer didn't contain valid frame");
1330 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1335 GST_DEBUG ("buffer didn't contain valid frame");
1336 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1340 if (G_UNLIKELY (!ret))
1343 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1345 frame->overhead = 7;
1347 gst_aac_parse_parse_adts_header (aacparse, map.data,
1348 &rate, &channels, NULL, NULL);
1350 GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1352 if (G_UNLIKELY (rate != aacparse->sample_rate
1353 || channels != aacparse->channels)) {
1354 aacparse->sample_rate = rate;
1355 aacparse->channels = channels;
1357 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1358 /* If linking fails, we need to return appropriate error */
1359 ret = GST_FLOW_NOT_LINKED;
1362 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1363 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1365 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1366 gboolean setcaps = FALSE;
1369 frame->overhead = 3;
1371 if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1372 &channels, NULL) || !rate || !channels) {
1373 /* This is pretty normal when skipping data at the start of
1374 * random stream (MPEG-TS capture for example) */
1375 GST_DEBUG_OBJECT (aacparse, "Error reading LOAS config. Skipping.");
1376 /* Since we don't fully parse the LOAS config, we don't know for sure
1377 * how much to skip. Just skip 1 to end up to the next marker and
1378 * resume parsing from there */
1383 if (G_UNLIKELY (rate != aacparse->sample_rate
1384 || channels != aacparse->channels)) {
1385 aacparse->sample_rate = rate;
1386 aacparse->channels = channels;
1388 GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1392 /* We want to set caps both at start, and when rate/channels change.
1393 Since only some LOAS frames have that info, we may receive frames
1394 before knowing about rate/channels. */
1396 || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1397 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1398 /* If linking fails, we need to return appropriate error */
1399 ret = GST_FLOW_NOT_LINKED;
1402 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1403 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1407 if (aacparse->header_type == DSPAAC_HEADER_NONE
1408 && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1409 if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1410 GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1411 ret = GST_FLOW_ERROR;
1416 gst_buffer_unmap (buffer, &map);
1419 /* found, skip if needed */
1428 if (ret && framesize <= map.size) {
1429 return gst_base_parse_finish_frame (parse, frame, framesize);
1435 static GstFlowReturn
1436 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1438 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1440 if (!aacparse->sent_codec_tag) {
1441 GstTagList *taglist;
1445 caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1447 if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
1448 GST_INFO_OBJECT (parse, "Src pad is flushing");
1449 return GST_FLOW_FLUSHING;
1451 GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
1452 return GST_FLOW_NOT_NEGOTIATED;
1456 taglist = gst_tag_list_new_empty ();
1457 gst_pb_utils_add_codec_description_to_tag_list (taglist,
1458 GST_TAG_AUDIO_CODEC, caps);
1459 gst_caps_unref (caps);
1461 gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
1462 gst_tag_list_unref (taglist);
1464 /* also signals the end of first-frame processing */
1465 aacparse->sent_codec_tag = TRUE;
1468 /* As a special case, we can remove the ADTS framing and output raw AAC. */
1469 if (aacparse->header_type == DSPAAC_HEADER_ADTS
1470 && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1473 frame->out_buffer = gst_buffer_make_writable (frame->buffer);
1474 frame->buffer = NULL;
1475 gst_buffer_map (frame->out_buffer, &map, GST_MAP_READ);
1476 header_size = (map.data[1] & 1) ? 7 : 9; /* optional CRC */
1477 gst_buffer_unmap (frame->out_buffer, &map);
1478 gst_buffer_resize (frame->out_buffer, header_size,
1479 gst_buffer_get_size (frame->out_buffer) - header_size);
1487 * gst_aac_parse_start:
1488 * @parse: #GstBaseParse.
1490 * Implementation of "start" vmethod in #GstBaseParse class.
1492 * Returns: TRUE if startup succeeded.
1495 gst_aac_parse_start (GstBaseParse * parse)
1497 GstAacParse *aacparse;
1499 aacparse = GST_AAC_PARSE (parse);
1500 GST_DEBUG ("start");
1501 aacparse->frame_samples = 1024;
1502 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1503 aacparse->sent_codec_tag = FALSE;
1504 aacparse->last_parsed_channels = 0;
1505 aacparse->last_parsed_sample_rate = 0;
1506 aacparse->object_type = 0;
1507 aacparse->bitrate = 0;
1508 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
1509 aacparse->output_header_type = DSPAAC_HEADER_NOT_PARSED;
1510 aacparse->channels = 0;
1511 aacparse->sample_rate = 0;
1517 * gst_aac_parse_stop:
1518 * @parse: #GstBaseParse.
1520 * Implementation of "stop" vmethod in #GstBaseParse class.
1522 * Returns: TRUE is stopping succeeded.
1525 gst_aac_parse_stop (GstBaseParse * parse)
1532 remove_fields (GstCaps * caps)
1536 n = gst_caps_get_size (caps);
1537 for (i = 0; i < n; i++) {
1538 GstStructure *s = gst_caps_get_structure (caps, i);
1540 gst_structure_remove_field (s, "framed");
1545 add_conversion_fields (GstCaps * caps)
1549 n = gst_caps_get_size (caps);
1550 for (i = 0; i < n; i++) {
1551 GstStructure *s = gst_caps_get_structure (caps, i);
1553 if (gst_structure_has_field (s, "stream-format")) {
1554 const GValue *v = gst_structure_get_value (s, "stream-format");
1556 if (G_VALUE_HOLDS_STRING (v)) {
1557 const gchar *str = g_value_get_string (v);
1559 if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1560 GValue va = G_VALUE_INIT;
1561 GValue vs = G_VALUE_INIT;
1563 g_value_init (&va, GST_TYPE_LIST);
1564 g_value_init (&vs, G_TYPE_STRING);
1565 g_value_set_string (&vs, "adts");
1566 gst_value_list_append_value (&va, &vs);
1567 g_value_set_string (&vs, "raw");
1568 gst_value_list_append_value (&va, &vs);
1569 gst_structure_set_value (s, "stream-format", &va);
1570 g_value_unset (&va);
1571 g_value_unset (&vs);
1573 } else if (GST_VALUE_HOLDS_LIST (v)) {
1574 gboolean contains_raw = FALSE;
1575 gboolean contains_adts = FALSE;
1576 guint m = gst_value_list_get_size (v), j;
1578 for (j = 0; j < m; j++) {
1579 const GValue *ve = gst_value_list_get_value (v, j);
1582 if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1583 if (strcmp (str, "adts") == 0)
1584 contains_adts = TRUE;
1585 else if (strcmp (str, "raw") == 0)
1586 contains_raw = TRUE;
1590 if (contains_adts || contains_raw) {
1591 GValue va = G_VALUE_INIT;
1592 GValue vs = G_VALUE_INIT;
1594 g_value_init (&va, GST_TYPE_LIST);
1595 g_value_init (&vs, G_TYPE_STRING);
1596 g_value_copy (v, &va);
1598 if (!contains_raw) {
1599 g_value_set_string (&vs, "raw");
1600 gst_value_list_append_value (&va, &vs);
1602 if (!contains_adts) {
1603 g_value_set_string (&vs, "adts");
1604 gst_value_list_append_value (&va, &vs);
1607 gst_structure_set_value (s, "stream-format", &va);
1609 g_value_unset (&vs);
1610 g_value_unset (&va);
1618 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1620 GstCaps *peercaps, *templ;
1623 templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1626 GstCaps *fcopy = gst_caps_copy (filter);
1627 /* Remove the fields we convert */
1628 remove_fields (fcopy);
1629 add_conversion_fields (fcopy);
1630 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1631 gst_caps_unref (fcopy);
1633 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1636 peercaps = gst_caps_make_writable (peercaps);
1637 /* Remove the fields we convert */
1638 remove_fields (peercaps);
1639 add_conversion_fields (peercaps);
1641 res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1642 gst_caps_unref (peercaps);
1643 gst_caps_unref (templ);
1649 GstCaps *intersection;
1652 gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1653 gst_caps_unref (res);
1661 gst_aac_parse_src_event (GstBaseParse * parse, GstEvent * event)
1663 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1665 if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
1666 aacparse->last_parsed_channels = 0;
1667 aacparse->last_parsed_sample_rate = 0;
1670 return GST_BASE_PARSE_CLASS (parent_class)->src_event (parse, event);