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 guint8 codec_data[2];
168 guint16 codec_data_data;
169 gint sample_rate_idx;
171 GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
173 src_caps = gst_caps_copy (sink_caps);
175 src_caps = gst_caps_new_empty_simple ("audio/mpeg");
177 gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
178 "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
180 aacparse->output_header_type = aacparse->header_type;
181 switch (aacparse->header_type) {
182 case DSPAAC_HEADER_NONE:
183 stream_format = "raw";
185 case DSPAAC_HEADER_ADTS:
186 stream_format = "adts";
188 case DSPAAC_HEADER_ADIF:
189 stream_format = "adif";
191 case DSPAAC_HEADER_LOAS:
192 stream_format = "loas";
195 stream_format = NULL;
198 /* Generate codec data to be able to set profile/level on the caps */
200 gst_codec_utils_aac_get_index_from_sample_rate (aacparse->sample_rate);
201 if (sample_rate_idx < 0)
202 goto not_a_known_rate;
204 (aacparse->object_type << 11) |
205 (sample_rate_idx << 7) | (aacparse->channels << 3);
206 GST_WRITE_UINT16_BE (codec_data, codec_data_data);
207 gst_codec_utils_aac_caps_set_level_and_profile (src_caps, codec_data, 2);
209 s = gst_caps_get_structure (src_caps, 0);
210 if (aacparse->sample_rate > 0)
211 gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
212 if (aacparse->channels > 0)
213 gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
215 gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
217 allowed = gst_pad_get_allowed_caps (GST_BASE_PARSE (aacparse)->srcpad);
218 if (!gst_caps_can_intersect (src_caps, allowed)) {
219 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
220 "Caps can not intersect");
221 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
222 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
223 "Input is ADTS, trying raw");
224 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "raw",
226 if (gst_caps_can_intersect (src_caps, allowed)) {
227 GstBuffer *codec_data_buffer;
229 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
230 "Caps can intersect, we will drop the ADTS layer");
231 aacparse->output_header_type = DSPAAC_HEADER_NONE;
233 /* The codec_data data is according to AudioSpecificConfig,
234 ISO/IEC 14496-3, 1.6.2.1 */
235 codec_data_buffer = gst_buffer_new_and_alloc (2);
236 gst_buffer_fill (codec_data_buffer, 0, codec_data, 2);
237 gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER,
238 codec_data_buffer, NULL);
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_ERROR_OBJECT (aacparse, "Not a known sample rate: %d",
262 aacparse->sample_rate);
263 gst_caps_unref (src_caps);
269 * gst_aac_parse_sink_setcaps:
273 * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
275 * Returns: TRUE on success.
278 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
280 GstAacParse *aacparse;
281 GstStructure *structure;
285 aacparse = GST_AAC_PARSE (parse);
286 structure = gst_caps_get_structure (caps, 0);
287 caps_str = gst_caps_to_string (caps);
289 GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
292 /* This is needed at least in case of RTP
293 * Parses the codec_data information to get ObjectType,
294 * number of channels and samplerate */
295 value = gst_structure_get_value (structure, "codec_data");
297 GstBuffer *buf = gst_value_get_buffer (value);
303 gst_buffer_map (buf, &map, GST_MAP_READ);
305 sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
306 aacparse->object_type = (map.data[0] & 0xf8) >> 3;
307 aacparse->sample_rate =
308 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
309 aacparse->channels = (map.data[1] & 0x78) >> 3;
310 aacparse->header_type = DSPAAC_HEADER_NONE;
311 aacparse->mpegversion = 4;
312 aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
313 gst_buffer_unmap (buf, &map);
315 GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
316 "samples=%d", aacparse->object_type, aacparse->sample_rate,
317 aacparse->channels, aacparse->frame_samples);
319 /* arrange for metadata and get out of the way */
320 gst_aac_parse_set_src_caps (aacparse, caps);
321 if (aacparse->header_type == aacparse->output_header_type)
322 gst_base_parse_set_passthrough (parse, TRUE);
326 /* caps info overrides */
327 gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
328 gst_structure_get_int (structure, "channels", &aacparse->channels);
330 aacparse->sample_rate = 0;
331 aacparse->channels = 0;
332 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
333 gst_base_parse_set_passthrough (parse, FALSE);
341 * gst_aac_parse_adts_get_frame_len:
342 * @data: block of data containing an ADTS header.
344 * This function calculates ADTS frame length from the given header.
346 * Returns: size of the ADTS frame.
349 gst_aac_parse_adts_get_frame_len (const guint8 * data)
351 return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
356 * gst_aac_parse_check_adts_frame:
357 * @aacparse: #GstAacParse.
358 * @data: Data to be checked.
359 * @avail: Amount of data passed.
360 * @framesize: If valid ADTS frame was found, this will be set to tell the
361 * found frame size in bytes.
362 * @needed_data: If frame was not found, this may be set to tell how much
363 * more data is needed in the next round to detect the frame
364 * reliably. This may happen when a frame header candidate
365 * is found but it cannot be guaranteed to be the header without
366 * peeking the following data.
368 * Check if the given data contains contains ADTS frame. The algorithm
369 * will examine ADTS frame header and calculate the frame size. Also, another
370 * consecutive ADTS frame header need to be present after the found frame.
371 * Otherwise the data is not considered as a valid ADTS frame. However, this
372 * "extra check" is omitted when EOS has been received. In this case it is
373 * enough when data[0] contains a valid ADTS header.
375 * This function may set the #needed_data to indicate that a possible frame
376 * candidate has been found, but more data (#needed_data bytes) is needed to
377 * be absolutely sure. When this situation occurs, FALSE will be returned.
379 * When a valid frame is detected, this function will use
380 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
381 * to set the needed bytes for next frame.This way next data chunk is already
384 * Returns: TRUE if the given data contains a valid ADTS header.
387 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
388 const guint8 * data, const guint avail, gboolean drain,
389 guint * framesize, guint * needed_data)
395 /* Absolute minimum to perform the ADTS syncword,
396 layer and sampling frequency tests */
397 if (G_UNLIKELY (avail < 3)) {
402 /* Syncword and layer tests */
403 if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
405 /* Sampling frequency test */
406 if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
409 /* This looks like an ADTS frame header but
410 we need at least 6 bytes to proceed */
411 if (G_UNLIKELY (avail < 6)) {
416 *framesize = gst_aac_parse_adts_get_frame_len (data);
418 /* If frame has CRC, it needs 2 bytes
419 for it at the end of the header */
420 crc_size = (data[1] & 0x01) ? 0 : 2;
423 if (*framesize < 7 + crc_size) {
424 *needed_data = 7 + crc_size;
428 /* In EOS mode this is enough. No need to examine the data further.
429 We also relax the check when we have sync, on the assumption that
430 if we're not looking at random data, we have a much higher chance
431 to get the correct sync, and this avoids losing two frames when
432 a single bit corruption happens. */
433 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
437 if (*framesize + ADTS_MAX_SIZE > avail) {
438 /* We have found a possible frame header candidate, but can't be
439 sure since we don't have enough data to check the next frame */
440 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
441 *framesize + ADTS_MAX_SIZE, avail);
442 *needed_data = *framesize + ADTS_MAX_SIZE;
443 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
444 *framesize + ADTS_MAX_SIZE);
448 if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
449 guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
451 GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
452 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
453 nextlen + ADTS_MAX_SIZE);
461 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
464 guint8 bytes, i, byte;
467 if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
469 for (i = 0; i < bytes; ++i) {
471 if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
479 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
480 guint8 * audio_object_type)
482 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
484 if (*audio_object_type == 31) {
485 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
487 *audio_object_type += 32;
489 GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
494 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
497 guint8 sampling_frequency_index;
498 if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
500 GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
501 sampling_frequency_index);
502 if (sampling_frequency_index == 0xf) {
503 guint32 sampling_rate;
504 if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
506 *sample_rate = sampling_rate;
508 *sample_rate = loas_sample_rate_table[sampling_frequency_index];
515 /* See table 1.13 in ISO/IEC 14496-3 */
517 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
518 GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
520 guint8 audio_object_type, channel_configuration;
522 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
525 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
528 if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
530 GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
531 *channels = loas_channels_table[channel_configuration];
535 if (audio_object_type == 5) {
536 GST_LOG_OBJECT (aacparse,
537 "Audio object type 5, so rereading sampling rate...");
538 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
542 GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
543 *sample_rate, *channels);
545 /* There's LOTS of stuff next, but we ignore it for now as we have
546 what we want (sample rate and number of channels */
547 GST_DEBUG_OBJECT (aacparse,
548 "Need more code to parse humongous LOAS data, currently ignored");
556 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
557 guint avail, gint * sample_rate, gint * channels, gint * version)
562 /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
566 gst_bit_reader_init (&br, data, avail);
568 /* skip sync word (11 bits) and size (13 bits) */
569 if (!gst_bit_reader_skip (&br, 11 + 13))
572 /* First bit is "use last config" */
573 if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
576 GST_DEBUG_OBJECT (aacparse, "Frame uses previous config");
577 if (!aacparse->sample_rate || !aacparse->channels) {
578 GST_WARNING_OBJECT (aacparse, "No previous config to use");
580 *sample_rate = aacparse->sample_rate;
581 *channels = aacparse->channels;
585 GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
587 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
590 if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
595 GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
597 guint8 same_time, subframes, num_program, prog;
600 if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
603 if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
605 if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
607 if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
609 GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
610 same_time, subframes, num_program);
612 for (prog = 0; prog <= num_program; ++prog) {
613 guint8 num_layer, layer;
614 if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
616 GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
618 for (layer = 0; layer <= num_layer; ++layer) {
619 guint8 use_same_config;
620 if (prog == 0 && layer == 0) {
623 if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
626 if (!use_same_config) {
628 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
629 sample_rate, channels, NULL))
632 guint32 bits, asc_len;
633 if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
635 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
636 sample_rate, channels, &bits))
639 if (!gst_bit_reader_skip (&br, asc_len))
645 GST_LOG_OBJECT (aacparse, "More data ignored");
647 GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
653 * gst_aac_parse_loas_get_frame_len:
654 * @data: block of data containing a LOAS header.
656 * This function calculates LOAS frame length from the given header.
658 * Returns: size of the LOAS frame.
661 gst_aac_parse_loas_get_frame_len (const guint8 * data)
663 return (((data[1] & 0x1f) << 8) | data[2]) + 3;
668 * gst_aac_parse_check_loas_frame:
669 * @aacparse: #GstAacParse.
670 * @data: Data to be checked.
671 * @avail: Amount of data passed.
672 * @framesize: If valid LOAS frame was found, this will be set to tell the
673 * found frame size in bytes.
674 * @needed_data: If frame was not found, this may be set to tell how much
675 * more data is needed in the next round to detect the frame
676 * reliably. This may happen when a frame header candidate
677 * is found but it cannot be guaranteed to be the header without
678 * peeking the following data.
680 * Check if the given data contains contains LOAS frame. The algorithm
681 * will examine LOAS frame header and calculate the frame size. Also, another
682 * consecutive LOAS frame header need to be present after the found frame.
683 * Otherwise the data is not considered as a valid LOAS frame. However, this
684 * "extra check" is omitted when EOS has been received. In this case it is
685 * enough when data[0] contains a valid LOAS header.
687 * This function may set the #needed_data to indicate that a possible frame
688 * candidate has been found, but more data (#needed_data bytes) is needed to
689 * be absolutely sure. When this situation occurs, FALSE will be returned.
691 * When a valid frame is detected, this function will use
692 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
693 * to set the needed bytes for next frame.This way next data chunk is already
696 * LOAS can have three different formats, if I read the spec correctly. Only
697 * one of them is supported here, as the two samples I have use this one.
699 * Returns: TRUE if the given data contains a valid LOAS header.
702 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
703 const guint8 * data, const guint avail, gboolean drain,
704 guint * framesize, guint * needed_data)
709 if (G_UNLIKELY (avail < 3)) {
714 if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
715 *framesize = gst_aac_parse_loas_get_frame_len (data);
716 GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
718 /* In EOS mode this is enough. No need to examine the data further.
719 We also relax the check when we have sync, on the assumption that
720 if we're not looking at random data, we have a much higher chance
721 to get the correct sync, and this avoids losing two frames when
722 a single bit corruption happens. */
723 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
727 if (*framesize + LOAS_MAX_SIZE > avail) {
728 /* We have found a possible frame header candidate, but can't be
729 sure since we don't have enough data to check the next frame */
730 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
731 *framesize + LOAS_MAX_SIZE, avail);
732 *needed_data = *framesize + LOAS_MAX_SIZE;
733 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
734 *framesize + LOAS_MAX_SIZE);
738 if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
739 guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
741 GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
742 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
743 nextlen + LOAS_MAX_SIZE);
750 /* caller ensure sufficient data */
752 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
753 gint * rate, gint * channels, gint * object, gint * version)
757 gint sr_idx = (data[2] & 0x3c) >> 2;
759 *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
762 *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
765 *version = (data[1] & 0x08) ? 2 : 4;
767 *object = ((data[2] & 0xc0) >> 6) + 1;
771 * gst_aac_parse_detect_stream:
772 * @aacparse: #GstAacParse.
773 * @data: A block of data that needs to be examined for stream characteristics.
774 * @avail: Size of the given datablock.
775 * @framesize: If valid stream was found, this will be set to tell the
776 * first frame size in bytes.
777 * @skipsize: If valid stream was found, this will be set to tell the first
778 * audio frame position within the given data.
780 * Examines the given piece of data and try to detect the format of it. It
781 * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
782 * header. If the stream is detected, TRUE will be returned and #framesize
783 * is set to indicate the found frame size. Additionally, #skipsize might
784 * be set to indicate the number of bytes that need to be skipped, a.k.a. the
785 * position of the frame inside given data chunk.
787 * Returns: TRUE on success.
790 gst_aac_parse_detect_stream (GstAacParse * aacparse,
791 const guint8 * data, const guint avail, gboolean drain,
792 guint * framesize, gint * skipsize)
794 gboolean found = FALSE;
795 guint need_data_adts = 0, need_data_loas;
798 GST_DEBUG_OBJECT (aacparse, "Parsing header data");
800 /* FIXME: No need to check for ADIF if we are not in the beginning of the
803 /* Can we even parse the header? */
804 if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
805 GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
809 for (i = 0; i < avail - 4; i++) {
810 if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
811 ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) ||
812 strncmp ((char *) data + i, "ADIF", 4) == 0) {
813 GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
817 /* Trick: tell the parent class that we didn't find the frame yet,
818 but make it skip 'i' amount of bytes. Next time we arrive
819 here we have full frame in the beginning of the data. */
832 if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
833 framesize, &need_data_adts)) {
836 GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
838 gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
839 &aacparse->object_type, &aacparse->mpegversion);
841 if (!channels || !framesize) {
842 GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
846 aacparse->header_type = DSPAAC_HEADER_ADTS;
847 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
848 aacparse->frame_samples, 2, 2);
850 GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
851 rate, channels, aacparse->object_type, aacparse->mpegversion);
853 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
858 if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
859 framesize, &need_data_loas)) {
862 GST_INFO ("LOAS, framesize: %d", *framesize);
864 aacparse->header_type = DSPAAC_HEADER_LOAS;
866 if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
867 &channels, &aacparse->mpegversion)) {
868 GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
872 if (rate && channels) {
873 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
874 aacparse->frame_samples, 2, 2);
876 GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
877 rate, channels, aacparse->object_type, aacparse->mpegversion);
878 aacparse->sample_rate = rate;
879 aacparse->channels = channels;
882 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
887 if (need_data_adts || need_data_loas) {
888 /* This tells the parent class not to skip any data */
893 if (avail < ADIF_MAX_SIZE)
896 if (memcmp (data + i, "ADIF", 4) == 0) {
903 aacparse->header_type = DSPAAC_HEADER_ADIF;
904 aacparse->mpegversion = 4;
906 /* Skip the "ADIF" bytes */
909 /* copyright string */
911 skip_size += 9; /* skip 9 bytes */
913 bitstream_type = adif[0 + skip_size] & 0x10;
915 ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
916 ((unsigned int) adif[1 + skip_size] << 11) |
917 ((unsigned int) adif[2 + skip_size] << 3) |
918 ((unsigned int) adif[3 + skip_size] & 0xe0);
921 if (bitstream_type == 0) {
923 /* Buffer fullness parsing. Currently not needed... */
927 num_elems = (adif[3 + skip_size] & 0x1e);
928 GST_INFO ("ADIF num_config_elems: %d", num_elems);
930 fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
931 ((unsigned int) adif[4 + skip_size] << 11) |
932 ((unsigned int) adif[5 + skip_size] << 3) |
933 ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
935 GST_INFO ("ADIF buffer fullness: %d", fullness);
937 aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
938 ((adif[7 + skip_size] & 0x80) >> 7);
939 sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
943 aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
944 sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
945 ((adif[5 + skip_size] & 0x80) >> 7);
948 /* FIXME: This gives totally wrong results. Duration calculation cannot
950 aacparse->sample_rate =
951 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
953 /* baseparse is not given any fps,
954 * so it will give up on timestamps, seeking, etc */
956 /* FIXME: Can we assume this? */
957 aacparse->channels = 2;
959 GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
960 aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
962 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
964 /* arrange for metadata and get out of the way */
965 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
966 gst_aac_parse_set_src_caps (aacparse, sinkcaps);
968 gst_caps_unref (sinkcaps);
970 /* not syncable, not easily seekable (unless we push data from start */
971 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
972 gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
973 gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
979 /* This should never happen */
984 * gst_aac_parse_get_audio_profile_object_type
985 * @aacparse: #GstAacParse.
987 * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
988 * mpegversion and profile of @aacparse's src pad caps, according to the
989 * values defined by table 1.A.11 in ISO/IEC 14496-3.
991 * Returns: the profile or object type value corresponding to @aacparse's src
992 * pad caps, if such a value exists; otherwise G_MAXUINT8.
995 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
998 GstStructure *srcstruct;
999 const gchar *profile;
1002 srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1003 srcstruct = gst_caps_get_structure (srccaps, 0);
1004 profile = gst_structure_get_string (srcstruct, "profile");
1005 if (G_UNLIKELY (profile == NULL)) {
1006 gst_caps_unref (srccaps);
1010 if (g_strcmp0 (profile, "main") == 0) {
1012 } else if (g_strcmp0 (profile, "lc") == 0) {
1014 } else if (g_strcmp0 (profile, "ssr") == 0) {
1016 } else if (g_strcmp0 (profile, "ltp") == 0) {
1017 if (G_LIKELY (aacparse->mpegversion == 4))
1020 ret = G_MAXUINT8; /* LTP Object Type allowed only for MPEG-4 */
1025 gst_caps_unref (srccaps);
1030 * gst_aac_parse_get_audio_channel_configuration
1031 * @num_channels: number of audio channels.
1033 * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1034 * 14496-3, for a given number of audio channels.
1036 * Returns: the Channel Configuration value corresponding to @num_channels, if
1037 * such a value exists; otherwise G_MAXUINT8.
1040 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1042 if (num_channels >= 1 && num_channels <= 6) /* Mono up to & including 5.1 */
1043 return (guint8) num_channels;
1044 else if (num_channels == 8) /* 7.1 */
1051 * gst_aac_parse_get_audio_sampling_frequency_index:
1052 * @sample_rate: audio sampling rate.
1054 * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1055 * 14496-3, for a given sampling rate.
1057 * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1058 * if such a value exists; otherwise G_MAXUINT8.
1061 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1063 switch (sample_rate) {
1096 * gst_aac_parse_prepend_adts_headers:
1097 * @aacparse: #GstAacParse.
1098 * @frame: raw AAC frame to which ADTS headers shall be prepended.
1100 * Prepends ADTS headers to a raw AAC audio frame.
1102 * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1105 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1106 GstBaseParseFrame * frame)
1109 guint8 *adts_headers;
1112 guint8 id, profile, channel_configuration, sampling_frequency_index;
1114 id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1115 profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1116 if (profile == G_MAXUINT8) {
1117 GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1120 channel_configuration =
1121 gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1122 if (channel_configuration == G_MAXUINT8) {
1123 GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1126 sampling_frequency_index =
1127 gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1128 if (sampling_frequency_index == G_MAXUINT8) {
1129 GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1133 frame->out_buffer = gst_buffer_copy (frame->buffer);
1134 buf_size = gst_buffer_get_size (frame->out_buffer);
1135 frame_size = buf_size + ADTS_HEADERS_LENGTH;
1137 if (G_UNLIKELY (frame_size >= 0x4000)) {
1138 GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1142 adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1144 /* Note: no error correction bits are added to the resulting ADTS frames */
1145 adts_headers[0] = 0xFFU;
1146 adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1147 adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1148 (channel_configuration & 0x4U);
1149 adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1150 (guint8) (frame_size >> 11);
1151 adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1152 adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1153 adts_headers[6] = 0xFCU;
1155 mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1156 ADTS_HEADERS_LENGTH, adts_headers, g_free);
1157 gst_buffer_prepend_memory (frame->out_buffer, mem);
1163 * gst_aac_parse_check_valid_frame:
1164 * @parse: #GstBaseParse.
1165 * @frame: #GstBaseParseFrame.
1166 * @skipsize: How much data parent class should skip in order to find the
1169 * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1171 * Also determines frame overhead.
1172 * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1173 * a per-frame header. LOAS has 3 bytes.
1175 * We're making a couple of simplifying assumptions:
1177 * 1. We count Program Configuration Elements rather than searching for them
1178 * in the streams to discount them - the overhead is negligible.
1180 * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1181 * bits, which should still not be significant enough to warrant the
1182 * additional parsing through the headers
1184 * Returns: a #GstFlowReturn.
1186 static GstFlowReturn
1187 gst_aac_parse_handle_frame (GstBaseParse * parse,
1188 GstBaseParseFrame * frame, gint * skipsize)
1191 GstAacParse *aacparse;
1192 gboolean ret = FALSE;
1196 gint rate, channels;
1198 aacparse = GST_AAC_PARSE (parse);
1199 buffer = frame->buffer;
1201 gst_buffer_map (buffer, &map, GST_MAP_READ);
1204 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1206 if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1207 aacparse->header_type == DSPAAC_HEADER_NONE) {
1208 /* There is nothing to parse */
1209 framesize = map.size;
1212 } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1214 ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1215 GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1217 } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1218 guint needed_data = 1024;
1220 ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1221 GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1223 if (!ret && needed_data) {
1224 GST_DEBUG ("buffer didn't contain valid frame");
1226 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1230 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1231 guint needed_data = 1024;
1233 ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1234 map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1236 if (!ret && needed_data) {
1237 GST_DEBUG ("buffer didn't contain valid frame");
1239 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1244 GST_DEBUG ("buffer didn't contain valid frame");
1245 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1249 if (G_UNLIKELY (!ret))
1252 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1254 frame->overhead = 7;
1256 gst_aac_parse_parse_adts_header (aacparse, map.data,
1257 &rate, &channels, NULL, NULL);
1259 GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1261 if (G_UNLIKELY (rate != aacparse->sample_rate
1262 || channels != aacparse->channels)) {
1263 aacparse->sample_rate = rate;
1264 aacparse->channels = channels;
1266 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1267 /* If linking fails, we need to return appropriate error */
1268 ret = GST_FLOW_NOT_LINKED;
1271 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1272 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1274 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1275 gboolean setcaps = FALSE;
1278 frame->overhead = 3;
1280 if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1282 GST_WARNING_OBJECT (aacparse, "Error reading LOAS config");
1283 } else if (G_UNLIKELY (rate != aacparse->sample_rate
1284 || channels != aacparse->channels)) {
1285 aacparse->sample_rate = rate;
1286 aacparse->channels = channels;
1288 GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1292 /* We want to set caps both at start, and when rate/channels change.
1293 Since only some LOAS frames have that info, we may receive frames
1294 before knowing about rate/channels. */
1296 || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1297 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1298 /* If linking fails, we need to return appropriate error */
1299 ret = GST_FLOW_NOT_LINKED;
1302 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1303 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1307 if (aacparse->header_type == DSPAAC_HEADER_NONE
1308 && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1309 if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1310 GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1311 ret = GST_FLOW_ERROR;
1316 gst_buffer_unmap (buffer, &map);
1319 /* found, skip if needed */
1328 if (ret && framesize <= map.size) {
1329 return gst_base_parse_finish_frame (parse, frame, framesize);
1335 static GstFlowReturn
1336 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1338 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1340 if (!aacparse->sent_codec_tag) {
1341 GstTagList *taglist;
1344 taglist = gst_tag_list_new_empty ();
1347 caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1348 gst_pb_utils_add_codec_description_to_tag_list (taglist,
1349 GST_TAG_AUDIO_CODEC, caps);
1350 gst_caps_unref (caps);
1352 gst_pad_push_event (GST_BASE_PARSE_SRC_PAD (aacparse),
1353 gst_event_new_tag (taglist));
1355 /* also signals the end of first-frame processing */
1356 aacparse->sent_codec_tag = TRUE;
1359 /* As a special case, we can remove the ADTS framing and output raw AAC. */
1360 if (aacparse->header_type == DSPAAC_HEADER_ADTS
1361 && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1364 gst_buffer_map (frame->buffer, &map, GST_MAP_READ);
1365 header_size = (map.data[1] & 1) ? 7 : 9; /* optional CRC */
1366 gst_buffer_unmap (frame->buffer, &map);
1367 gst_buffer_resize (frame->buffer, header_size,
1368 gst_buffer_get_size (frame->buffer) - header_size);
1376 * gst_aac_parse_start:
1377 * @parse: #GstBaseParse.
1379 * Implementation of "start" vmethod in #GstBaseParse class.
1381 * Returns: TRUE if startup succeeded.
1384 gst_aac_parse_start (GstBaseParse * parse)
1386 GstAacParse *aacparse;
1388 aacparse = GST_AAC_PARSE (parse);
1389 GST_DEBUG ("start");
1390 aacparse->frame_samples = 1024;
1391 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1392 aacparse->sent_codec_tag = FALSE;
1398 * gst_aac_parse_stop:
1399 * @parse: #GstBaseParse.
1401 * Implementation of "stop" vmethod in #GstBaseParse class.
1403 * Returns: TRUE is stopping succeeded.
1406 gst_aac_parse_stop (GstBaseParse * parse)
1413 remove_fields (GstCaps * caps)
1417 n = gst_caps_get_size (caps);
1418 for (i = 0; i < n; i++) {
1419 GstStructure *s = gst_caps_get_structure (caps, i);
1421 gst_structure_remove_field (s, "framed");
1426 add_conversion_fields (GstCaps * caps)
1430 n = gst_caps_get_size (caps);
1431 for (i = 0; i < n; i++) {
1432 GstStructure *s = gst_caps_get_structure (caps, i);
1434 if (gst_structure_has_field (s, "stream-format")) {
1435 const GValue *v = gst_structure_get_value (s, "stream-format");
1437 if (G_VALUE_HOLDS_STRING (v)) {
1438 const gchar *str = g_value_get_string (v);
1440 if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1441 GValue va = G_VALUE_INIT;
1442 GValue vs = G_VALUE_INIT;
1444 g_value_init (&va, GST_TYPE_LIST);
1445 g_value_init (&vs, G_TYPE_STRING);
1446 g_value_set_string (&vs, "adts");
1447 gst_value_list_append_value (&va, &vs);
1448 g_value_set_string (&vs, "raw");
1449 gst_value_list_append_value (&va, &vs);
1450 gst_structure_set_value (s, "stream-format", &va);
1451 g_value_unset (&va);
1452 g_value_unset (&vs);
1454 } else if (GST_VALUE_HOLDS_LIST (v)) {
1455 gboolean contains_raw = FALSE;
1456 gboolean contains_adts = FALSE;
1457 guint m = gst_value_list_get_size (v), j;
1459 for (j = 0; j < m; j++) {
1460 const GValue *ve = gst_value_list_get_value (v, j);
1463 if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1464 if (strcmp (str, "adts") == 0)
1465 contains_adts = TRUE;
1466 else if (strcmp (str, "raw") == 0)
1467 contains_raw = TRUE;
1471 if (contains_adts || contains_raw) {
1472 GValue va = G_VALUE_INIT;
1473 GValue vs = G_VALUE_INIT;
1475 g_value_init (&va, GST_TYPE_LIST);
1476 g_value_init (&vs, G_TYPE_STRING);
1477 g_value_copy (v, &va);
1479 if (!contains_raw) {
1480 g_value_set_string (&vs, "raw");
1481 gst_value_list_append_value (&va, &vs);
1483 if (!contains_adts) {
1484 g_value_set_string (&vs, "adts");
1485 gst_value_list_append_value (&va, &vs);
1488 gst_structure_set_value (s, "stream-format", &va);
1490 g_value_unset (&vs);
1491 g_value_unset (&va);
1499 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1501 GstCaps *peercaps, *templ;
1504 templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1507 GstCaps *fcopy = gst_caps_copy (filter);
1508 /* Remove the fields we convert */
1509 remove_fields (fcopy);
1510 add_conversion_fields (fcopy);
1511 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1512 gst_caps_unref (fcopy);
1514 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1517 peercaps = gst_caps_make_writable (peercaps);
1518 /* Remove the fields we convert */
1519 remove_fields (peercaps);
1520 add_conversion_fields (peercaps);
1522 res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1523 gst_caps_unref (peercaps);
1524 gst_caps_unref (templ);
1530 GstCaps *intersection;
1533 gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1534 gst_caps_unref (res);