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 */
72 #define ADTS_HEADERS_LENGTH 7UL /* Total byte-length of fixed and variable
73 headers prepended during raw to ADTS
76 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
78 static const gint loas_sample_rate_table[32] = {
79 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
80 16000, 12000, 11025, 8000, 7350, 0, 0, 0
83 static const gint loas_channels_table[32] = {
84 0, 1, 2, 3, 4, 5, 6, 8,
85 0, 0, 0, 0, 0, 0, 0, 0
88 static gboolean gst_aac_parse_start (GstBaseParse * parse);
89 static gboolean gst_aac_parse_stop (GstBaseParse * parse);
91 static gboolean gst_aac_parse_sink_setcaps (GstBaseParse * parse,
93 static GstCaps *gst_aac_parse_sink_getcaps (GstBaseParse * parse,
96 static GstFlowReturn gst_aac_parse_handle_frame (GstBaseParse * parse,
97 GstBaseParseFrame * frame, gint * skipsize);
98 static GstFlowReturn gst_aac_parse_pre_push_frame (GstBaseParse * parse,
99 GstBaseParseFrame * frame);
101 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
104 * gst_aac_parse_class_init:
105 * @klass: #GstAacParseClass.
109 gst_aac_parse_class_init (GstAacParseClass * klass)
111 GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
112 GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
114 GST_DEBUG_CATEGORY_INIT (aacparse_debug, "aacparse", 0,
115 "AAC audio stream parser");
117 gst_element_class_add_pad_template (element_class,
118 gst_static_pad_template_get (&sink_template));
119 gst_element_class_add_pad_template (element_class,
120 gst_static_pad_template_get (&src_template));
122 gst_element_class_set_static_metadata (element_class,
123 "AAC audio stream parser", "Codec/Parser/Audio",
124 "Advanced Audio Coding parser", "Stefan Kost <stefan.kost@nokia.com>");
126 parse_class->start = GST_DEBUG_FUNCPTR (gst_aac_parse_start);
127 parse_class->stop = GST_DEBUG_FUNCPTR (gst_aac_parse_stop);
128 parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_setcaps);
129 parse_class->get_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_getcaps);
130 parse_class->handle_frame = GST_DEBUG_FUNCPTR (gst_aac_parse_handle_frame);
131 parse_class->pre_push_frame =
132 GST_DEBUG_FUNCPTR (gst_aac_parse_pre_push_frame);
137 * gst_aac_parse_init:
138 * @aacparse: #GstAacParse.
139 * @klass: #GstAacParseClass.
143 gst_aac_parse_init (GstAacParse * aacparse)
145 GST_DEBUG ("initialized");
146 GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (aacparse));
151 * gst_aac_parse_set_src_caps:
152 * @aacparse: #GstAacParse.
153 * @sink_caps: (proposed) caps of sink pad
155 * Set source pad caps according to current knowledge about the
158 * Returns: TRUE if caps were successfully set.
161 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
164 GstCaps *src_caps = NULL, *allowed;
165 gboolean res = FALSE;
166 const gchar *stream_format;
167 GstBuffer *codec_data;
168 guint16 codec_data_data;
170 GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
172 src_caps = gst_caps_copy (sink_caps);
174 src_caps = gst_caps_new_empty_simple ("audio/mpeg");
176 gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
177 "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
179 aacparse->output_header_type = aacparse->header_type;
180 switch (aacparse->header_type) {
181 case DSPAAC_HEADER_NONE:
182 stream_format = "raw";
184 case DSPAAC_HEADER_ADTS:
185 stream_format = "adts";
187 case DSPAAC_HEADER_ADIF:
188 stream_format = "adif";
190 case DSPAAC_HEADER_LOAS:
191 stream_format = "loas";
194 stream_format = NULL;
197 s = gst_caps_get_structure (src_caps, 0);
198 if (aacparse->sample_rate > 0)
199 gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
200 if (aacparse->channels > 0)
201 gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
203 gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
205 allowed = gst_pad_get_allowed_caps (GST_BASE_PARSE (aacparse)->srcpad);
206 if (!gst_caps_can_intersect (src_caps, allowed)) {
207 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
208 "Caps can not intersect");
209 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
210 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
211 "Input is ADTS, trying raw");
212 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "raw",
214 if (gst_caps_can_intersect (src_caps, allowed)) {
219 gst_codec_utils_aac_get_index_from_sample_rate
220 (aacparse->sample_rate);
222 goto not_a_known_rate;
224 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
225 "Caps can intersect, we will drop the ADTS layer");
226 aacparse->output_header_type = DSPAAC_HEADER_NONE;
228 /* The codec_data data is according to AudioSpecificConfig,
229 ISO/IEC 14496-3, 1.6.2.1 */
230 codec_data = gst_buffer_new_and_alloc (2);
231 gst_buffer_map (codec_data, &map, GST_MAP_WRITE);
233 (aacparse->object_type << 11) |
234 (idx << 7) | (aacparse->channels << 3);
235 GST_WRITE_UINT16_BE (map.data, codec_data_data);
236 gst_buffer_unmap (codec_data, &map);
237 gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER,
240 } else if (aacparse->header_type == DSPAAC_HEADER_NONE) {
241 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
242 "Input is raw, trying ADTS");
243 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adts",
245 if (gst_caps_can_intersect (src_caps, allowed)) {
246 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
247 "Caps can intersect, we will prepend ADTS headers");
248 aacparse->output_header_type = DSPAAC_HEADER_ADTS;
252 gst_caps_unref (allowed);
254 GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
256 res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
257 gst_caps_unref (src_caps);
261 gst_caps_unref (allowed);
262 gst_caps_unref (src_caps);
268 * gst_aac_parse_sink_setcaps:
272 * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
274 * Returns: TRUE on success.
277 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
279 GstAacParse *aacparse;
280 GstStructure *structure;
284 aacparse = GST_AAC_PARSE (parse);
285 structure = gst_caps_get_structure (caps, 0);
286 caps_str = gst_caps_to_string (caps);
288 GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
291 /* This is needed at least in case of RTP
292 * Parses the codec_data information to get ObjectType,
293 * number of channels and samplerate */
294 value = gst_structure_get_value (structure, "codec_data");
296 GstBuffer *buf = gst_value_get_buffer (value);
302 gst_buffer_map (buf, &map, GST_MAP_READ);
304 sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
305 aacparse->object_type = (map.data[0] & 0xf8) >> 3;
306 aacparse->sample_rate =
307 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
308 aacparse->channels = (map.data[1] & 0x78) >> 3;
309 aacparse->header_type = DSPAAC_HEADER_NONE;
310 aacparse->mpegversion = 4;
311 aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
312 gst_buffer_unmap (buf, &map);
314 GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
315 "samples=%d", aacparse->object_type, aacparse->sample_rate,
316 aacparse->channels, aacparse->frame_samples);
318 /* arrange for metadata and get out of the way */
319 gst_aac_parse_set_src_caps (aacparse, caps);
320 if (aacparse->header_type == aacparse->output_header_type)
321 gst_base_parse_set_passthrough (parse, TRUE);
325 /* caps info overrides */
326 gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
327 gst_structure_get_int (structure, "channels", &aacparse->channels);
329 aacparse->sample_rate = 0;
330 aacparse->channels = 0;
331 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
332 gst_base_parse_set_passthrough (parse, FALSE);
340 * gst_aac_parse_adts_get_frame_len:
341 * @data: block of data containing an ADTS header.
343 * This function calculates ADTS frame length from the given header.
345 * Returns: size of the ADTS frame.
348 gst_aac_parse_adts_get_frame_len (const guint8 * data)
350 return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
355 * gst_aac_parse_check_adts_frame:
356 * @aacparse: #GstAacParse.
357 * @data: Data to be checked.
358 * @avail: Amount of data passed.
359 * @framesize: If valid ADTS frame was found, this will be set to tell the
360 * found frame size in bytes.
361 * @needed_data: If frame was not found, this may be set to tell how much
362 * more data is needed in the next round to detect the frame
363 * reliably. This may happen when a frame header candidate
364 * is found but it cannot be guaranteed to be the header without
365 * peeking the following data.
367 * Check if the given data contains contains ADTS frame. The algorithm
368 * will examine ADTS frame header and calculate the frame size. Also, another
369 * consecutive ADTS frame header need to be present after the found frame.
370 * Otherwise the data is not considered as a valid ADTS frame. However, this
371 * "extra check" is omitted when EOS has been received. In this case it is
372 * enough when data[0] contains a valid ADTS header.
374 * This function may set the #needed_data to indicate that a possible frame
375 * candidate has been found, but more data (#needed_data bytes) is needed to
376 * be absolutely sure. When this situation occurs, FALSE will be returned.
378 * When a valid frame is detected, this function will use
379 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
380 * to set the needed bytes for next frame.This way next data chunk is already
383 * Returns: TRUE if the given data contains a valid ADTS header.
386 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
387 const guint8 * data, const guint avail, gboolean drain,
388 guint * framesize, guint * needed_data)
394 /* Absolute minimum to perform the ADTS syncword,
395 layer and sampling frequency tests */
396 if (G_UNLIKELY (avail < 3)) {
401 /* Syncword and layer tests */
402 if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
404 /* Sampling frequency test */
405 if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
408 /* This looks like an ADTS frame header but
409 we need at least 6 bytes to proceed */
410 if (G_UNLIKELY (avail < 6)) {
415 *framesize = gst_aac_parse_adts_get_frame_len (data);
417 /* If frame has CRC, it needs 2 bytes
418 for it at the end of the header */
419 crc_size = (data[1] & 0x01) ? 0 : 2;
422 if (*framesize < 7 + crc_size) {
423 *needed_data = 7 + crc_size;
427 /* In EOS mode this is enough. No need to examine the data further.
428 We also relax the check when we have sync, on the assumption that
429 if we're not looking at random data, we have a much higher chance
430 to get the correct sync, and this avoids losing two frames when
431 a single bit corruption happens. */
432 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
436 if (*framesize + ADTS_MAX_SIZE > avail) {
437 /* We have found a possible frame header candidate, but can't be
438 sure since we don't have enough data to check the next frame */
439 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
440 *framesize + ADTS_MAX_SIZE, avail);
441 *needed_data = *framesize + ADTS_MAX_SIZE;
442 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
443 *framesize + ADTS_MAX_SIZE);
447 if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
448 guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
450 GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
451 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
452 nextlen + ADTS_MAX_SIZE);
460 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
463 guint8 bytes, i, byte;
466 if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
468 for (i = 0; i < bytes; ++i) {
470 if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
478 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
479 guint8 * audio_object_type)
481 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
483 if (*audio_object_type == 31) {
484 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
486 *audio_object_type += 32;
488 GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
493 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
496 guint8 sampling_frequency_index;
497 if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
499 GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
500 sampling_frequency_index);
501 if (sampling_frequency_index == 0xf) {
502 guint32 sampling_rate;
503 if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
505 *sample_rate = sampling_rate;
507 *sample_rate = loas_sample_rate_table[sampling_frequency_index];
514 /* See table 1.13 in ISO/IEC 14496-3 */
516 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
517 GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
519 guint8 audio_object_type, channel_configuration;
521 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
524 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
527 if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
529 GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
530 *channels = loas_channels_table[channel_configuration];
534 if (audio_object_type == 5) {
535 GST_LOG_OBJECT (aacparse,
536 "Audio object type 5, so rereading sampling rate...");
537 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
541 GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
542 *sample_rate, *channels);
544 /* There's LOTS of stuff next, but we ignore it for now as we have
545 what we want (sample rate and number of channels */
546 GST_DEBUG_OBJECT (aacparse,
547 "Need more code to parse humongous LOAS data, currently ignored");
555 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
556 guint avail, gint * sample_rate, gint * channels, gint * version)
561 /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
565 gst_bit_reader_init (&br, data, avail);
567 /* skip sync word (11 bits) and size (13 bits) */
568 if (!gst_bit_reader_skip (&br, 11 + 13))
571 /* First bit is "use last config" */
572 if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
575 GST_DEBUG_OBJECT (aacparse, "Frame uses previous config");
576 if (!aacparse->sample_rate || !aacparse->channels) {
577 GST_WARNING_OBJECT (aacparse, "No previous config to use");
579 *sample_rate = aacparse->sample_rate;
580 *channels = aacparse->channels;
584 GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
586 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
589 if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
594 GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
596 guint8 same_time, subframes, num_program, prog;
599 if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
602 if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
604 if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
606 if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
608 GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
609 same_time, subframes, num_program);
611 for (prog = 0; prog <= num_program; ++prog) {
612 guint8 num_layer, layer;
613 if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
615 GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
617 for (layer = 0; layer <= num_layer; ++layer) {
618 guint8 use_same_config;
619 if (prog == 0 && layer == 0) {
622 if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
625 if (!use_same_config) {
627 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
628 sample_rate, channels, NULL))
631 guint32 bits, asc_len;
632 if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
634 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
635 sample_rate, channels, &bits))
638 if (!gst_bit_reader_skip (&br, asc_len))
644 GST_LOG_OBJECT (aacparse, "More data ignored");
646 GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
652 * gst_aac_parse_loas_get_frame_len:
653 * @data: block of data containing a LOAS header.
655 * This function calculates LOAS frame length from the given header.
657 * Returns: size of the LOAS frame.
660 gst_aac_parse_loas_get_frame_len (const guint8 * data)
662 return (((data[1] & 0x1f) << 8) | data[2]) + 3;
667 * gst_aac_parse_check_loas_frame:
668 * @aacparse: #GstAacParse.
669 * @data: Data to be checked.
670 * @avail: Amount of data passed.
671 * @framesize: If valid LOAS frame was found, this will be set to tell the
672 * found frame size in bytes.
673 * @needed_data: If frame was not found, this may be set to tell how much
674 * more data is needed in the next round to detect the frame
675 * reliably. This may happen when a frame header candidate
676 * is found but it cannot be guaranteed to be the header without
677 * peeking the following data.
679 * Check if the given data contains contains LOAS frame. The algorithm
680 * will examine LOAS frame header and calculate the frame size. Also, another
681 * consecutive LOAS frame header need to be present after the found frame.
682 * Otherwise the data is not considered as a valid LOAS frame. However, this
683 * "extra check" is omitted when EOS has been received. In this case it is
684 * enough when data[0] contains a valid LOAS header.
686 * This function may set the #needed_data to indicate that a possible frame
687 * candidate has been found, but more data (#needed_data bytes) is needed to
688 * be absolutely sure. When this situation occurs, FALSE will be returned.
690 * When a valid frame is detected, this function will use
691 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
692 * to set the needed bytes for next frame.This way next data chunk is already
695 * LOAS can have three different formats, if I read the spec correctly. Only
696 * one of them is supported here, as the two samples I have use this one.
698 * Returns: TRUE if the given data contains a valid LOAS header.
701 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
702 const guint8 * data, const guint avail, gboolean drain,
703 guint * framesize, guint * needed_data)
708 if (G_UNLIKELY (avail < 3)) {
713 if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
714 *framesize = gst_aac_parse_loas_get_frame_len (data);
715 GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
717 /* In EOS mode this is enough. No need to examine the data further.
718 We also relax the check when we have sync, on the assumption that
719 if we're not looking at random data, we have a much higher chance
720 to get the correct sync, and this avoids losing two frames when
721 a single bit corruption happens. */
722 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
726 if (*framesize + LOAS_MAX_SIZE > avail) {
727 /* We have found a possible frame header candidate, but can't be
728 sure since we don't have enough data to check the next frame */
729 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
730 *framesize + LOAS_MAX_SIZE, avail);
731 *needed_data = *framesize + LOAS_MAX_SIZE;
732 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
733 *framesize + LOAS_MAX_SIZE);
737 if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
738 guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
740 GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
741 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
742 nextlen + LOAS_MAX_SIZE);
749 /* caller ensure sufficient data */
751 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
752 gint * rate, gint * channels, gint * object, gint * version)
756 gint sr_idx = (data[2] & 0x3c) >> 2;
758 *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
761 *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
764 *version = (data[1] & 0x08) ? 2 : 4;
766 *object = ((data[2] & 0xc0) >> 6) + 1;
770 * gst_aac_parse_detect_stream:
771 * @aacparse: #GstAacParse.
772 * @data: A block of data that needs to be examined for stream characteristics.
773 * @avail: Size of the given datablock.
774 * @framesize: If valid stream was found, this will be set to tell the
775 * first frame size in bytes.
776 * @skipsize: If valid stream was found, this will be set to tell the first
777 * audio frame position within the given data.
779 * Examines the given piece of data and try to detect the format of it. It
780 * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
781 * header. If the stream is detected, TRUE will be returned and #framesize
782 * is set to indicate the found frame size. Additionally, #skipsize might
783 * be set to indicate the number of bytes that need to be skipped, a.k.a. the
784 * position of the frame inside given data chunk.
786 * Returns: TRUE on success.
789 gst_aac_parse_detect_stream (GstAacParse * aacparse,
790 const guint8 * data, const guint avail, gboolean drain,
791 guint * framesize, gint * skipsize)
793 gboolean found = FALSE;
794 guint need_data_adts = 0, need_data_loas;
797 GST_DEBUG_OBJECT (aacparse, "Parsing header data");
799 /* FIXME: No need to check for ADIF if we are not in the beginning of the
802 /* Can we even parse the header? */
803 if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
804 GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
808 for (i = 0; i < avail - 4; i++) {
809 if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
810 ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) ||
811 strncmp ((char *) data + i, "ADIF", 4) == 0) {
812 GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
816 /* Trick: tell the parent class that we didn't find the frame yet,
817 but make it skip 'i' amount of bytes. Next time we arrive
818 here we have full frame in the beginning of the data. */
831 if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
832 framesize, &need_data_adts)) {
835 GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
837 gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
838 &aacparse->object_type, &aacparse->mpegversion);
840 if (!channels || !framesize) {
841 GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
845 aacparse->header_type = DSPAAC_HEADER_ADTS;
846 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
847 aacparse->frame_samples, 2, 2);
849 GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
850 rate, channels, aacparse->object_type, aacparse->mpegversion);
852 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
857 if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
858 framesize, &need_data_loas)) {
861 GST_INFO ("LOAS, framesize: %d", *framesize);
863 aacparse->header_type = DSPAAC_HEADER_LOAS;
865 if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
866 &channels, &aacparse->mpegversion)) {
867 GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
871 if (rate && channels) {
872 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
873 aacparse->frame_samples, 2, 2);
875 GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
876 rate, channels, aacparse->object_type, aacparse->mpegversion);
877 aacparse->sample_rate = rate;
878 aacparse->channels = channels;
881 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
886 if (need_data_adts || need_data_loas) {
887 /* This tells the parent class not to skip any data */
892 if (avail < ADIF_MAX_SIZE)
895 if (memcmp (data + i, "ADIF", 4) == 0) {
902 aacparse->header_type = DSPAAC_HEADER_ADIF;
903 aacparse->mpegversion = 4;
905 /* Skip the "ADIF" bytes */
908 /* copyright string */
910 skip_size += 9; /* skip 9 bytes */
912 bitstream_type = adif[0 + skip_size] & 0x10;
914 ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
915 ((unsigned int) adif[1 + skip_size] << 11) |
916 ((unsigned int) adif[2 + skip_size] << 3) |
917 ((unsigned int) adif[3 + skip_size] & 0xe0);
920 if (bitstream_type == 0) {
922 /* Buffer fullness parsing. Currently not needed... */
926 num_elems = (adif[3 + skip_size] & 0x1e);
927 GST_INFO ("ADIF num_config_elems: %d", num_elems);
929 fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
930 ((unsigned int) adif[4 + skip_size] << 11) |
931 ((unsigned int) adif[5 + skip_size] << 3) |
932 ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
934 GST_INFO ("ADIF buffer fullness: %d", fullness);
936 aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
937 ((adif[7 + skip_size] & 0x80) >> 7);
938 sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
942 aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
943 sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
944 ((adif[5 + skip_size] & 0x80) >> 7);
947 /* FIXME: This gives totally wrong results. Duration calculation cannot
949 aacparse->sample_rate =
950 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
952 /* baseparse is not given any fps,
953 * so it will give up on timestamps, seeking, etc */
955 /* FIXME: Can we assume this? */
956 aacparse->channels = 2;
958 GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
959 aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
961 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
963 /* arrange for metadata and get out of the way */
964 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
965 gst_aac_parse_set_src_caps (aacparse, sinkcaps);
967 gst_caps_unref (sinkcaps);
969 /* not syncable, not easily seekable (unless we push data from start */
970 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
971 gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
972 gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
978 /* This should never happen */
983 * gst_aac_parse_get_audio_profile_object_type
984 * @aacparse: #GstAacParse.
986 * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
987 * mpegversion and profile of @aacparse's src pad caps, according to the
988 * values defined by table 1.A.11 in ISO/IEC 14496-3.
990 * Returns: the profile or object type value corresponding to @aacparse's src
991 * pad caps, if such a value exists; otherwise G_MAXUINT8.
994 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
997 GstStructure *srcstruct;
998 const gchar *profile;
1001 srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1002 srcstruct = gst_caps_get_structure (srccaps, 0);
1003 profile = gst_structure_get_string (srcstruct, "profile");
1004 if (G_UNLIKELY (profile == NULL)) {
1005 gst_caps_unref (srccaps);
1009 if (g_strcmp0 (profile, "main") == 0) {
1011 } else if (g_strcmp0 (profile, "lc") == 0) {
1013 } else if (g_strcmp0 (profile, "ssr") == 0) {
1015 } else if (g_strcmp0 (profile, "ltp") == 0) {
1016 if (G_LIKELY (aacparse->mpegversion == 4))
1019 ret = G_MAXUINT8; /* LTP Object Type allowed only for MPEG-4 */
1024 gst_caps_unref (srccaps);
1029 * gst_aac_parse_get_audio_channel_configuration
1030 * @num_channels: number of audio channels.
1032 * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1033 * 14496-3, for a given number of audio channels.
1035 * Returns: the Channel Configuration value corresponding to @num_channels, if
1036 * such a value exists; otherwise G_MAXUINT8.
1039 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1041 if (num_channels >= 1 && num_channels <= 6) /* Mono up to & including 5.1 */
1042 return (guint8) num_channels;
1043 else if (num_channels == 8) /* 7.1 */
1050 * gst_aac_parse_get_audio_sampling_frequency_index:
1051 * @sample_rate: audio sampling rate.
1053 * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1054 * 14496-3, for a given sampling rate.
1056 * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1057 * if such a value exists; otherwise G_MAXUINT8.
1060 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1062 switch (sample_rate) {
1095 * gst_aac_parse_prepend_adts_headers:
1096 * @aacparse: #GstAacParse.
1097 * @frame: raw AAC frame to which ADTS headers shall be prepended.
1099 * Prepends ADTS headers to a raw AAC audio frame.
1101 * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1104 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1105 GstBaseParseFrame * frame)
1108 guint8 *adts_headers;
1111 guint8 id, profile, channel_configuration, sampling_frequency_index;
1113 id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1114 profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1115 if (profile == G_MAXUINT8) {
1116 GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1119 channel_configuration =
1120 gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1121 if (channel_configuration == G_MAXUINT8) {
1122 GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1125 sampling_frequency_index =
1126 gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1127 if (sampling_frequency_index == G_MAXUINT8) {
1128 GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1132 frame->out_buffer = gst_buffer_copy (frame->buffer);
1133 buf_size = gst_buffer_get_size (frame->out_buffer);
1134 frame_size = buf_size + ADTS_HEADERS_LENGTH;
1136 if (G_UNLIKELY (frame_size >= 0x4000)) {
1137 GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1141 adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1143 /* Note: no error correction bits are added to the resulting ADTS frames */
1144 adts_headers[0] = 0xFFU;
1145 adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1146 adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1147 (channel_configuration & 0x4U);
1148 adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1149 (guint8) (frame_size >> 11);
1150 adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1151 adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1152 adts_headers[6] = 0xFCU;
1154 mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1155 ADTS_HEADERS_LENGTH, adts_headers, g_free);
1156 gst_buffer_prepend_memory (frame->out_buffer, mem);
1162 * gst_aac_parse_check_valid_frame:
1163 * @parse: #GstBaseParse.
1164 * @frame: #GstBaseParseFrame.
1165 * @skipsize: How much data parent class should skip in order to find the
1168 * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1170 * Also determines frame overhead.
1171 * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1172 * a per-frame header. LOAS has 3 bytes.
1174 * We're making a couple of simplifying assumptions:
1176 * 1. We count Program Configuration Elements rather than searching for them
1177 * in the streams to discount them - the overhead is negligible.
1179 * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1180 * bits, which should still not be significant enough to warrant the
1181 * additional parsing through the headers
1183 * Returns: a #GstFlowReturn.
1185 static GstFlowReturn
1186 gst_aac_parse_handle_frame (GstBaseParse * parse,
1187 GstBaseParseFrame * frame, gint * skipsize)
1190 GstAacParse *aacparse;
1191 gboolean ret = FALSE;
1195 gint rate, channels;
1197 aacparse = GST_AAC_PARSE (parse);
1198 buffer = frame->buffer;
1200 gst_buffer_map (buffer, &map, GST_MAP_READ);
1203 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1205 if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1206 aacparse->header_type == DSPAAC_HEADER_NONE) {
1207 /* There is nothing to parse */
1208 framesize = map.size;
1211 } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1213 ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1214 GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1216 } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1217 guint needed_data = 1024;
1219 ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1220 GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1222 if (!ret && needed_data) {
1223 GST_DEBUG ("buffer didn't contain valid frame");
1225 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1229 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1230 guint needed_data = 1024;
1232 ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1233 map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1235 if (!ret && needed_data) {
1236 GST_DEBUG ("buffer didn't contain valid frame");
1238 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1243 GST_DEBUG ("buffer didn't contain valid frame");
1244 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1248 if (G_UNLIKELY (!ret))
1251 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1253 frame->overhead = 7;
1255 gst_aac_parse_parse_adts_header (aacparse, map.data,
1256 &rate, &channels, NULL, NULL);
1258 GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1260 if (G_UNLIKELY (rate != aacparse->sample_rate
1261 || channels != aacparse->channels)) {
1262 aacparse->sample_rate = rate;
1263 aacparse->channels = channels;
1265 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1266 /* If linking fails, we need to return appropriate error */
1267 ret = GST_FLOW_NOT_LINKED;
1270 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1271 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1273 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1274 gboolean setcaps = FALSE;
1277 frame->overhead = 3;
1279 if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1281 GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
1282 } else if (G_UNLIKELY (rate != aacparse->sample_rate
1283 || channels != aacparse->channels)) {
1284 aacparse->sample_rate = rate;
1285 aacparse->channels = channels;
1287 GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1291 /* We want to set caps both at start, and when rate/channels change.
1292 Since only some LOAS frames have that info, we may receive frames
1293 before knowing about rate/channels. */
1295 || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1296 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1297 /* If linking fails, we need to return appropriate error */
1298 ret = GST_FLOW_NOT_LINKED;
1301 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1302 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1306 if (aacparse->header_type == DSPAAC_HEADER_NONE
1307 && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1308 if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1309 GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1310 ret = GST_FLOW_ERROR;
1315 gst_buffer_unmap (buffer, &map);
1318 /* found, skip if needed */
1327 if (ret && framesize <= map.size) {
1328 return gst_base_parse_finish_frame (parse, frame, framesize);
1334 static GstFlowReturn
1335 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1337 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1339 if (!aacparse->sent_codec_tag) {
1340 GstTagList *taglist;
1343 taglist = gst_tag_list_new_empty ();
1346 caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1347 gst_pb_utils_add_codec_description_to_tag_list (taglist,
1348 GST_TAG_AUDIO_CODEC, caps);
1349 gst_caps_unref (caps);
1351 gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (aacparse),
1352 gst_event_new_tag (taglist));
1354 /* also signals the end of first-frame processing */
1355 aacparse->sent_codec_tag = TRUE;
1358 /* As a special case, we can remove the ADTS framing and output raw AAC. */
1359 if (aacparse->header_type == DSPAAC_HEADER_ADTS
1360 && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1363 gst_buffer_map (frame->buffer, &map, GST_MAP_READ);
1364 header_size = (map.data[1] & 1) ? 7 : 9; /* optional CRC */
1365 gst_buffer_unmap (frame->buffer, &map);
1366 gst_buffer_resize (frame->buffer, header_size,
1367 gst_buffer_get_size (frame->buffer) - header_size);
1375 * gst_aac_parse_start:
1376 * @parse: #GstBaseParse.
1378 * Implementation of "start" vmethod in #GstBaseParse class.
1380 * Returns: TRUE if startup succeeded.
1383 gst_aac_parse_start (GstBaseParse * parse)
1385 GstAacParse *aacparse;
1387 aacparse = GST_AAC_PARSE (parse);
1388 GST_DEBUG ("start");
1389 aacparse->frame_samples = 1024;
1390 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1391 aacparse->sent_codec_tag = FALSE;
1397 * gst_aac_parse_stop:
1398 * @parse: #GstBaseParse.
1400 * Implementation of "stop" vmethod in #GstBaseParse class.
1402 * Returns: TRUE is stopping succeeded.
1405 gst_aac_parse_stop (GstBaseParse * parse)
1412 remove_fields (GstCaps * caps)
1416 n = gst_caps_get_size (caps);
1417 for (i = 0; i < n; i++) {
1418 GstStructure *s = gst_caps_get_structure (caps, i);
1420 gst_structure_remove_field (s, "framed");
1425 add_conversion_fields (GstCaps * caps)
1429 n = gst_caps_get_size (caps);
1430 for (i = 0; i < n; i++) {
1431 GstStructure *s = gst_caps_get_structure (caps, i);
1433 if (gst_structure_has_field (s, "stream-format")) {
1434 const GValue *v = gst_structure_get_value (s, "stream-format");
1436 if (G_VALUE_HOLDS_STRING (v)) {
1437 const gchar *str = g_value_get_string (v);
1439 if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1440 GValue va = G_VALUE_INIT;
1441 GValue vs = G_VALUE_INIT;
1443 g_value_init (&va, GST_TYPE_LIST);
1444 g_value_init (&vs, G_TYPE_STRING);
1445 g_value_set_string (&vs, "adts");
1446 gst_value_list_append_value (&va, &vs);
1447 g_value_set_string (&vs, "raw");
1448 gst_value_list_append_value (&va, &vs);
1449 gst_structure_set_value (s, "stream-format", &va);
1450 g_value_unset (&va);
1451 g_value_unset (&vs);
1453 } else if (GST_VALUE_HOLDS_LIST (v)) {
1454 gboolean contains_raw = FALSE;
1455 gboolean contains_adts = FALSE;
1456 guint m = gst_value_list_get_size (v), j;
1458 for (j = 0; j < m; j++) {
1459 const GValue *ve = gst_value_list_get_value (v, j);
1462 if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1463 if (strcmp (str, "adts") == 0)
1464 contains_adts = TRUE;
1465 else if (strcmp (str, "raw") == 0)
1466 contains_raw = TRUE;
1470 if (contains_adts || contains_raw) {
1471 GValue va = G_VALUE_INIT;
1472 GValue vs = G_VALUE_INIT;
1474 g_value_init (&va, GST_TYPE_LIST);
1475 g_value_init (&vs, G_TYPE_STRING);
1476 g_value_copy (v, &va);
1478 if (!contains_raw) {
1479 g_value_set_string (&vs, "raw");
1480 gst_value_list_append_value (&va, &vs);
1482 if (!contains_adts) {
1483 g_value_set_string (&vs, "adts");
1484 gst_value_list_append_value (&va, &vs);
1487 gst_structure_set_value (s, "stream-format", &va);
1489 g_value_unset (&vs);
1490 g_value_unset (&va);
1498 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1500 GstCaps *peercaps, *templ;
1503 templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1506 GstCaps *fcopy = gst_caps_copy (filter);
1507 /* Remove the fields we convert */
1508 remove_fields (fcopy);
1509 add_conversion_fields (fcopy);
1510 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1511 gst_caps_unref (fcopy);
1513 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1516 peercaps = gst_caps_make_writable (peercaps);
1517 /* Remove the fields we convert */
1518 remove_fields (peercaps);
1519 add_conversion_fields (peercaps);
1521 res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1522 gst_caps_unref (peercaps);
1523 gst_caps_unref (templ);
1529 GstCaps *intersection;
1532 gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1533 gst_caps_unref (res);