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, 7, 8, 0, 8, 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));
147 GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (aacparse));
152 * gst_aac_parse_set_src_caps:
153 * @aacparse: #GstAacParse.
154 * @sink_caps: (proposed) caps of sink pad
156 * Set source pad caps according to current knowledge about the
159 * Returns: TRUE if caps were successfully set.
162 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
165 GstCaps *src_caps = NULL, *allowed;
166 gboolean res = FALSE;
167 const gchar *stream_format;
168 guint8 codec_data[2];
169 guint16 codec_data_data;
170 gint sample_rate_idx;
172 GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
174 src_caps = gst_caps_copy (sink_caps);
176 src_caps = gst_caps_new_empty_simple ("audio/mpeg");
178 gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
179 "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
181 aacparse->output_header_type = aacparse->header_type;
182 switch (aacparse->header_type) {
183 case DSPAAC_HEADER_NONE:
184 stream_format = "raw";
186 case DSPAAC_HEADER_ADTS:
187 stream_format = "adts";
189 case DSPAAC_HEADER_ADIF:
190 stream_format = "adif";
192 case DSPAAC_HEADER_LOAS:
193 stream_format = "loas";
196 stream_format = NULL;
199 /* Generate codec data to be able to set profile/level on the caps */
201 gst_codec_utils_aac_get_index_from_sample_rate (aacparse->sample_rate);
202 if (sample_rate_idx < 0)
203 goto not_a_known_rate;
205 (aacparse->object_type << 11) |
206 (sample_rate_idx << 7) | (aacparse->channels << 3);
207 GST_WRITE_UINT16_BE (codec_data, codec_data_data);
208 gst_codec_utils_aac_caps_set_level_and_profile (src_caps, codec_data, 2);
210 s = gst_caps_get_structure (src_caps, 0);
211 if (aacparse->sample_rate > 0)
212 gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
213 if (aacparse->channels > 0)
214 gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
216 gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
218 allowed = gst_pad_get_allowed_caps (GST_BASE_PARSE (aacparse)->srcpad);
219 if (allowed && !gst_caps_can_intersect (src_caps, allowed)) {
220 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
221 "Caps can not intersect");
222 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
223 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
224 "Input is ADTS, trying raw");
225 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "raw",
227 if (gst_caps_can_intersect (src_caps, allowed)) {
228 GstBuffer *codec_data_buffer;
230 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
231 "Caps can intersect, we will drop the ADTS layer");
232 aacparse->output_header_type = DSPAAC_HEADER_NONE;
234 /* The codec_data data is according to AudioSpecificConfig,
235 ISO/IEC 14496-3, 1.6.2.1 */
236 codec_data_buffer = gst_buffer_new_and_alloc (2);
237 gst_buffer_fill (codec_data_buffer, 0, codec_data, 2);
238 gst_caps_set_simple (src_caps, "codec_data", GST_TYPE_BUFFER,
239 codec_data_buffer, NULL);
241 } else if (aacparse->header_type == DSPAAC_HEADER_NONE) {
242 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
243 "Input is raw, trying ADTS");
244 gst_caps_set_simple (src_caps, "stream-format", G_TYPE_STRING, "adts",
246 if (gst_caps_can_intersect (src_caps, allowed)) {
247 GST_DEBUG_OBJECT (GST_BASE_PARSE (aacparse)->srcpad,
248 "Caps can intersect, we will prepend ADTS headers");
249 aacparse->output_header_type = DSPAAC_HEADER_ADTS;
254 gst_caps_unref (allowed);
256 GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
258 res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
259 gst_caps_unref (src_caps);
263 GST_ERROR_OBJECT (aacparse, "Not a known sample rate: %d",
264 aacparse->sample_rate);
265 gst_caps_unref (src_caps);
271 * gst_aac_parse_sink_setcaps:
275 * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
277 * Returns: TRUE on success.
280 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
282 GstAacParse *aacparse;
283 GstStructure *structure;
287 aacparse = GST_AAC_PARSE (parse);
288 structure = gst_caps_get_structure (caps, 0);
289 caps_str = gst_caps_to_string (caps);
291 GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
294 /* This is needed at least in case of RTP
295 * Parses the codec_data information to get ObjectType,
296 * number of channels and samplerate */
297 value = gst_structure_get_value (structure, "codec_data");
299 GstBuffer *buf = gst_value_get_buffer (value);
305 gst_buffer_map (buf, &map, GST_MAP_READ);
307 sr_idx = ((map.data[0] & 0x07) << 1) | ((map.data[1] & 0x80) >> 7);
308 aacparse->object_type = (map.data[0] & 0xf8) >> 3;
309 aacparse->sample_rate =
310 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
311 aacparse->channels = (map.data[1] & 0x78) >> 3;
312 if (aacparse->channels == 7)
313 aacparse->channels = 8;
314 else if (aacparse->channels == 11)
315 aacparse->channels = 7;
316 else if (aacparse->channels == 12 || aacparse->channels == 14)
317 aacparse->channels = 8;
318 aacparse->header_type = DSPAAC_HEADER_NONE;
319 aacparse->mpegversion = 4;
320 aacparse->frame_samples = (map.data[1] & 4) ? 960 : 1024;
321 gst_buffer_unmap (buf, &map);
323 GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
324 "samples=%d", aacparse->object_type, aacparse->sample_rate,
325 aacparse->channels, aacparse->frame_samples);
327 /* arrange for metadata and get out of the way */
328 gst_aac_parse_set_src_caps (aacparse, caps);
329 if (aacparse->header_type == aacparse->output_header_type)
330 gst_base_parse_set_passthrough (parse, TRUE);
334 /* caps info overrides */
335 gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
336 gst_structure_get_int (structure, "channels", &aacparse->channels);
338 aacparse->sample_rate = 0;
339 aacparse->channels = 0;
340 aacparse->header_type = DSPAAC_HEADER_NOT_PARSED;
341 gst_base_parse_set_passthrough (parse, FALSE);
349 * gst_aac_parse_adts_get_frame_len:
350 * @data: block of data containing an ADTS header.
352 * This function calculates ADTS frame length from the given header.
354 * Returns: size of the ADTS frame.
357 gst_aac_parse_adts_get_frame_len (const guint8 * data)
359 return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
364 * gst_aac_parse_check_adts_frame:
365 * @aacparse: #GstAacParse.
366 * @data: Data to be checked.
367 * @avail: Amount of data passed.
368 * @framesize: If valid ADTS frame was found, this will be set to tell the
369 * found frame size in bytes.
370 * @needed_data: If frame was not found, this may be set to tell how much
371 * more data is needed in the next round to detect the frame
372 * reliably. This may happen when a frame header candidate
373 * is found but it cannot be guaranteed to be the header without
374 * peeking the following data.
376 * Check if the given data contains contains ADTS frame. The algorithm
377 * will examine ADTS frame header and calculate the frame size. Also, another
378 * consecutive ADTS frame header need to be present after the found frame.
379 * Otherwise the data is not considered as a valid ADTS frame. However, this
380 * "extra check" is omitted when EOS has been received. In this case it is
381 * enough when data[0] contains a valid ADTS header.
383 * This function may set the #needed_data to indicate that a possible frame
384 * candidate has been found, but more data (#needed_data bytes) is needed to
385 * be absolutely sure. When this situation occurs, FALSE will be returned.
387 * When a valid frame is detected, this function will use
388 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
389 * to set the needed bytes for next frame.This way next data chunk is already
392 * Returns: TRUE if the given data contains a valid ADTS header.
395 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
396 const guint8 * data, const guint avail, gboolean drain,
397 guint * framesize, guint * needed_data)
403 /* Absolute minimum to perform the ADTS syncword,
404 layer and sampling frequency tests */
405 if (G_UNLIKELY (avail < 3)) {
410 /* Syncword and layer tests */
411 if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
413 /* Sampling frequency test */
414 if (G_UNLIKELY ((data[2] & 0x3C) >> 2 == 15))
417 /* This looks like an ADTS frame header but
418 we need at least 6 bytes to proceed */
419 if (G_UNLIKELY (avail < 6)) {
424 *framesize = gst_aac_parse_adts_get_frame_len (data);
426 /* If frame has CRC, it needs 2 bytes
427 for it at the end of the header */
428 crc_size = (data[1] & 0x01) ? 0 : 2;
431 if (*framesize < 7 + crc_size) {
432 *needed_data = 7 + crc_size;
436 /* In EOS mode this is enough. No need to examine the data further.
437 We also relax the check when we have sync, on the assumption that
438 if we're not looking at random data, we have a much higher chance
439 to get the correct sync, and this avoids losing two frames when
440 a single bit corruption happens. */
441 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
445 if (*framesize + ADTS_MAX_SIZE > avail) {
446 /* We have found a possible frame header candidate, but can't be
447 sure since we don't have enough data to check the next frame */
448 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
449 *framesize + ADTS_MAX_SIZE, avail);
450 *needed_data = *framesize + ADTS_MAX_SIZE;
451 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
452 *framesize + ADTS_MAX_SIZE);
456 if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
457 guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
459 GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
460 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
461 nextlen + ADTS_MAX_SIZE);
469 gst_aac_parse_latm_get_value (GstAacParse * aacparse, GstBitReader * br,
472 guint8 bytes, i, byte;
475 if (!gst_bit_reader_get_bits_uint8 (br, &bytes, 2))
477 for (i = 0; i < bytes; ++i) {
479 if (!gst_bit_reader_get_bits_uint8 (br, &byte, 8))
487 gst_aac_parse_get_audio_object_type (GstAacParse * aacparse, GstBitReader * br,
488 guint8 * audio_object_type)
490 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 5))
492 if (*audio_object_type == 31) {
493 if (!gst_bit_reader_get_bits_uint8 (br, audio_object_type, 6))
495 *audio_object_type += 32;
497 GST_LOG_OBJECT (aacparse, "audio object type %u", *audio_object_type);
502 gst_aac_parse_get_audio_sample_rate (GstAacParse * aacparse, GstBitReader * br,
505 guint8 sampling_frequency_index;
506 if (!gst_bit_reader_get_bits_uint8 (br, &sampling_frequency_index, 4))
508 GST_LOG_OBJECT (aacparse, "sampling_frequency_index: %u",
509 sampling_frequency_index);
510 if (sampling_frequency_index == 0xf) {
511 guint32 sampling_rate;
512 if (!gst_bit_reader_get_bits_uint32 (br, &sampling_rate, 24))
514 *sample_rate = sampling_rate;
516 *sample_rate = loas_sample_rate_table[sampling_frequency_index];
523 /* See table 1.13 in ISO/IEC 14496-3 */
525 gst_aac_parse_read_loas_audio_specific_config (GstAacParse * aacparse,
526 GstBitReader * br, gint * sample_rate, gint * channels, guint32 * bits)
528 guint8 audio_object_type, channel_configuration;
530 if (!gst_aac_parse_get_audio_object_type (aacparse, br, &audio_object_type))
533 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
536 if (!gst_bit_reader_get_bits_uint8 (br, &channel_configuration, 4))
538 GST_LOG_OBJECT (aacparse, "channel_configuration: %d", channel_configuration);
539 *channels = loas_channels_table[channel_configuration];
543 if (audio_object_type == 5) {
544 GST_LOG_OBJECT (aacparse,
545 "Audio object type 5, so rereading sampling rate...");
546 if (!gst_aac_parse_get_audio_sample_rate (aacparse, br, sample_rate))
550 GST_INFO_OBJECT (aacparse, "Found LOAS config: %d Hz, %d channels",
551 *sample_rate, *channels);
553 /* There's LOTS of stuff next, but we ignore it for now as we have
554 what we want (sample rate and number of channels */
555 GST_DEBUG_OBJECT (aacparse,
556 "Need more code to parse humongous LOAS data, currently ignored");
564 gst_aac_parse_read_loas_config (GstAacParse * aacparse, const guint8 * data,
565 guint avail, gint * sample_rate, gint * channels, gint * version)
570 /* No version in the bitstream, but the spec has LOAS in the MPEG-4 section */
574 gst_bit_reader_init (&br, data, avail);
576 /* skip sync word (11 bits) and size (13 bits) */
577 if (!gst_bit_reader_skip (&br, 11 + 13))
580 /* First bit is "use last config" */
581 if (!gst_bit_reader_get_bits_uint8 (&br, &u8, 1))
584 GST_LOG_OBJECT (aacparse, "Frame uses previous config");
585 if (!aacparse->sample_rate || !aacparse->channels) {
586 GST_DEBUG_OBJECT (aacparse,
587 "No previous config to use. We'll look for more data.");
590 *sample_rate = aacparse->sample_rate;
591 *channels = aacparse->channels;
595 GST_DEBUG_OBJECT (aacparse, "Frame contains new config");
597 if (!gst_bit_reader_get_bits_uint8 (&br, &v, 1))
600 if (!gst_bit_reader_get_bits_uint8 (&br, &vA, 1))
605 GST_LOG_OBJECT (aacparse, "v %d, vA %d", v, vA);
607 guint8 same_time, subframes, num_program, prog;
610 if (!gst_aac_parse_latm_get_value (aacparse, &br, &value))
613 if (!gst_bit_reader_get_bits_uint8 (&br, &same_time, 1))
615 if (!gst_bit_reader_get_bits_uint8 (&br, &subframes, 6))
617 if (!gst_bit_reader_get_bits_uint8 (&br, &num_program, 4))
619 GST_LOG_OBJECT (aacparse, "same_time %d, subframes %d, num_program %d",
620 same_time, subframes, num_program);
622 for (prog = 0; prog <= num_program; ++prog) {
623 guint8 num_layer, layer;
624 if (!gst_bit_reader_get_bits_uint8 (&br, &num_layer, 3))
626 GST_LOG_OBJECT (aacparse, "Program %d: %d layers", prog, num_layer);
628 for (layer = 0; layer <= num_layer; ++layer) {
629 guint8 use_same_config;
630 if (prog == 0 && layer == 0) {
633 if (!gst_bit_reader_get_bits_uint8 (&br, &use_same_config, 1))
636 if (!use_same_config) {
638 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
639 sample_rate, channels, NULL))
642 guint32 bits, asc_len;
643 if (!gst_aac_parse_latm_get_value (aacparse, &br, &asc_len))
645 if (!gst_aac_parse_read_loas_audio_specific_config (aacparse, &br,
646 sample_rate, channels, &bits))
649 if (!gst_bit_reader_skip (&br, asc_len))
655 GST_LOG_OBJECT (aacparse, "More data ignored");
657 GST_WARNING_OBJECT (aacparse, "Spec says \"TBD\"...");
664 * gst_aac_parse_loas_get_frame_len:
665 * @data: block of data containing a LOAS header.
667 * This function calculates LOAS frame length from the given header.
669 * Returns: size of the LOAS frame.
672 gst_aac_parse_loas_get_frame_len (const guint8 * data)
674 return (((data[1] & 0x1f) << 8) | data[2]) + 3;
679 * gst_aac_parse_check_loas_frame:
680 * @aacparse: #GstAacParse.
681 * @data: Data to be checked.
682 * @avail: Amount of data passed.
683 * @framesize: If valid LOAS frame was found, this will be set to tell the
684 * found frame size in bytes.
685 * @needed_data: If frame was not found, this may be set to tell how much
686 * more data is needed in the next round to detect the frame
687 * reliably. This may happen when a frame header candidate
688 * is found but it cannot be guaranteed to be the header without
689 * peeking the following data.
691 * Check if the given data contains contains LOAS frame. The algorithm
692 * will examine LOAS frame header and calculate the frame size. Also, another
693 * consecutive LOAS frame header need to be present after the found frame.
694 * Otherwise the data is not considered as a valid LOAS frame. However, this
695 * "extra check" is omitted when EOS has been received. In this case it is
696 * enough when data[0] contains a valid LOAS header.
698 * This function may set the #needed_data to indicate that a possible frame
699 * candidate has been found, but more data (#needed_data bytes) is needed to
700 * be absolutely sure. When this situation occurs, FALSE will be returned.
702 * When a valid frame is detected, this function will use
703 * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
704 * to set the needed bytes for next frame.This way next data chunk is already
707 * LOAS can have three different formats, if I read the spec correctly. Only
708 * one of them is supported here, as the two samples I have use this one.
710 * Returns: TRUE if the given data contains a valid LOAS header.
713 gst_aac_parse_check_loas_frame (GstAacParse * aacparse,
714 const guint8 * data, const guint avail, gboolean drain,
715 guint * framesize, guint * needed_data)
720 if (G_UNLIKELY (avail < 3)) {
725 if ((data[0] == 0x56) && ((data[1] & 0xe0) == 0xe0)) {
726 *framesize = gst_aac_parse_loas_get_frame_len (data);
727 GST_DEBUG_OBJECT (aacparse, "Found %u byte LOAS frame", *framesize);
729 /* In EOS mode this is enough. No need to examine the data further.
730 We also relax the check when we have sync, on the assumption that
731 if we're not looking at random data, we have a much higher chance
732 to get the correct sync, and this avoids losing two frames when
733 a single bit corruption happens. */
734 if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
738 if (*framesize + LOAS_MAX_SIZE > avail) {
739 /* We have found a possible frame header candidate, but can't be
740 sure since we don't have enough data to check the next frame */
741 GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
742 *framesize + LOAS_MAX_SIZE, avail);
743 *needed_data = *framesize + LOAS_MAX_SIZE;
744 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
745 *framesize + LOAS_MAX_SIZE);
749 if ((data[*framesize] == 0x56) && ((data[*framesize + 1] & 0xe0) == 0xe0)) {
750 guint nextlen = gst_aac_parse_loas_get_frame_len (data + (*framesize));
752 GST_LOG ("LOAS frame found, len: %d bytes", *framesize);
753 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
754 nextlen + LOAS_MAX_SIZE);
761 /* caller ensure sufficient data */
763 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
764 gint * rate, gint * channels, gint * object, gint * version)
768 gint sr_idx = (data[2] & 0x3c) >> 2;
770 *rate = gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
773 *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
779 *version = (data[1] & 0x08) ? 2 : 4;
781 *object = ((data[2] & 0xc0) >> 6) + 1;
785 * gst_aac_parse_detect_stream:
786 * @aacparse: #GstAacParse.
787 * @data: A block of data that needs to be examined for stream characteristics.
788 * @avail: Size of the given datablock.
789 * @framesize: If valid stream was found, this will be set to tell the
790 * first frame size in bytes.
791 * @skipsize: If valid stream was found, this will be set to tell the first
792 * audio frame position within the given data.
794 * Examines the given piece of data and try to detect the format of it. It
795 * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
796 * header. If the stream is detected, TRUE will be returned and #framesize
797 * is set to indicate the found frame size. Additionally, #skipsize might
798 * be set to indicate the number of bytes that need to be skipped, a.k.a. the
799 * position of the frame inside given data chunk.
801 * Returns: TRUE on success.
804 gst_aac_parse_detect_stream (GstAacParse * aacparse,
805 const guint8 * data, const guint avail, gboolean drain,
806 guint * framesize, gint * skipsize)
808 gboolean found = FALSE;
809 guint need_data_adts = 0, need_data_loas;
812 GST_DEBUG_OBJECT (aacparse, "Parsing header data");
814 /* FIXME: No need to check for ADIF if we are not in the beginning of the
817 /* Can we even parse the header? */
818 if (avail < MAX (ADTS_MAX_SIZE, LOAS_MAX_SIZE)) {
819 GST_DEBUG_OBJECT (aacparse, "Not enough data to check");
823 for (i = 0; i < avail - 4; i++) {
824 if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
825 ((data[i] == 0x56) && ((data[i + 1] & 0xe0) == 0xe0)) ||
826 strncmp ((char *) data + i, "ADIF", 4) == 0) {
827 GST_DEBUG_OBJECT (aacparse, "Found signature at offset %u", i);
831 /* Trick: tell the parent class that we didn't find the frame yet,
832 but make it skip 'i' amount of bytes. Next time we arrive
833 here we have full frame in the beginning of the data. */
846 if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
847 framesize, &need_data_adts)) {
850 GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
852 gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
853 &aacparse->object_type, &aacparse->mpegversion);
855 if (!channels || !framesize) {
856 GST_DEBUG_OBJECT (aacparse, "impossible ADTS configuration");
860 aacparse->header_type = DSPAAC_HEADER_ADTS;
861 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
862 aacparse->frame_samples, 2, 2);
864 GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
865 rate, channels, aacparse->object_type, aacparse->mpegversion);
867 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
872 if (gst_aac_parse_check_loas_frame (aacparse, data, avail, drain,
873 framesize, &need_data_loas)) {
874 gint rate = 0, channels = 0;
876 GST_INFO ("LOAS, framesize: %d", *framesize);
878 aacparse->header_type = DSPAAC_HEADER_LOAS;
880 if (!gst_aac_parse_read_loas_config (aacparse, data, avail, &rate,
881 &channels, &aacparse->mpegversion)) {
882 /* This is pretty normal when skipping data at the start of
883 * random stream (MPEG-TS capture for example) */
884 GST_LOG_OBJECT (aacparse, "Error reading LOAS config");
888 if (rate && channels) {
889 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
890 aacparse->frame_samples, 2, 2);
892 /* Don't store the sample rate and channels yet -
893 * this is just format detection. */
894 GST_DEBUG ("LOAS: samplerate %d, channels %d, objtype %d, version %d",
895 rate, channels, aacparse->object_type, aacparse->mpegversion);
898 gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
903 if (need_data_adts || need_data_loas) {
904 /* This tells the parent class not to skip any data */
909 if (avail < ADIF_MAX_SIZE)
912 if (memcmp (data + i, "ADIF", 4) == 0) {
919 aacparse->header_type = DSPAAC_HEADER_ADIF;
920 aacparse->mpegversion = 4;
922 /* Skip the "ADIF" bytes */
925 /* copyright string */
927 skip_size += 9; /* skip 9 bytes */
929 bitstream_type = adif[0 + skip_size] & 0x10;
931 ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
932 ((unsigned int) adif[1 + skip_size] << 11) |
933 ((unsigned int) adif[2 + skip_size] << 3) |
934 ((unsigned int) adif[3 + skip_size] & 0xe0);
937 if (bitstream_type == 0) {
939 /* Buffer fullness parsing. Currently not needed... */
943 num_elems = (adif[3 + skip_size] & 0x1e);
944 GST_INFO ("ADIF num_config_elems: %d", num_elems);
946 fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
947 ((unsigned int) adif[4 + skip_size] << 11) |
948 ((unsigned int) adif[5 + skip_size] << 3) |
949 ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
951 GST_INFO ("ADIF buffer fullness: %d", fullness);
953 aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
954 ((adif[7 + skip_size] & 0x80) >> 7);
955 sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
959 aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
960 sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
961 ((adif[5 + skip_size] & 0x80) >> 7);
964 /* FIXME: This gives totally wrong results. Duration calculation cannot
966 aacparse->sample_rate =
967 gst_codec_utils_aac_get_sample_rate_from_index (sr_idx);
969 /* baseparse is not given any fps,
970 * so it will give up on timestamps, seeking, etc */
972 /* FIXME: Can we assume this? */
973 aacparse->channels = 2;
975 GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
976 aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
978 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
980 /* arrange for metadata and get out of the way */
981 sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
982 gst_aac_parse_set_src_caps (aacparse, sinkcaps);
984 gst_caps_unref (sinkcaps);
986 /* not syncable, not easily seekable (unless we push data from start */
987 gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
988 gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
989 gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
995 /* This should never happen */
1000 * gst_aac_parse_get_audio_profile_object_type
1001 * @aacparse: #GstAacParse.
1003 * Gets the MPEG-2 profile or the MPEG-4 object type value corresponding to the
1004 * mpegversion and profile of @aacparse's src pad caps, according to the
1005 * values defined by table 1.A.11 in ISO/IEC 14496-3.
1007 * Returns: the profile or object type value corresponding to @aacparse's src
1008 * pad caps, if such a value exists; otherwise G_MAXUINT8.
1011 gst_aac_parse_get_audio_profile_object_type (GstAacParse * aacparse)
1014 GstStructure *srcstruct;
1015 const gchar *profile;
1018 srccaps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse));
1019 if (G_UNLIKELY (srccaps == NULL)) {
1023 srcstruct = gst_caps_get_structure (srccaps, 0);
1024 profile = gst_structure_get_string (srcstruct, "profile");
1025 if (G_UNLIKELY (profile == NULL)) {
1026 gst_caps_unref (srccaps);
1030 if (g_strcmp0 (profile, "main") == 0) {
1032 } else if (g_strcmp0 (profile, "lc") == 0) {
1034 } else if (g_strcmp0 (profile, "ssr") == 0) {
1036 } else if (g_strcmp0 (profile, "ltp") == 0) {
1037 if (G_LIKELY (aacparse->mpegversion == 4))
1040 ret = G_MAXUINT8; /* LTP Object Type allowed only for MPEG-4 */
1045 gst_caps_unref (srccaps);
1050 * gst_aac_parse_get_audio_channel_configuration
1051 * @num_channels: number of audio channels.
1053 * Gets the Channel Configuration value, as defined by table 1.19 in ISO/IEC
1054 * 14496-3, for a given number of audio channels.
1056 * Returns: the Channel Configuration value corresponding to @num_channels, if
1057 * such a value exists; otherwise G_MAXUINT8.
1060 gst_aac_parse_get_audio_channel_configuration (gint num_channels)
1062 if (num_channels >= 1 && num_channels <= 6) /* Mono up to & including 5.1 */
1063 return (guint8) num_channels;
1064 else if (num_channels == 8) /* 7.1 */
1069 /* FIXME: Add support for configurations 11, 12 and 14 from
1070 * ISO/IEC 14496-3:2009/PDAM 4 based on the actual channel layout
1075 * gst_aac_parse_get_audio_sampling_frequency_index:
1076 * @sample_rate: audio sampling rate.
1078 * Gets the Sampling Frequency Index value, as defined by table 1.18 in ISO/IEC
1079 * 14496-3, for a given sampling rate.
1081 * Returns: the Sampling Frequency Index value corresponding to @sample_rate,
1082 * if such a value exists; otherwise G_MAXUINT8.
1085 gst_aac_parse_get_audio_sampling_frequency_index (gint sample_rate)
1087 switch (sample_rate) {
1120 * gst_aac_parse_prepend_adts_headers:
1121 * @aacparse: #GstAacParse.
1122 * @frame: raw AAC frame to which ADTS headers shall be prepended.
1124 * Prepends ADTS headers to a raw AAC audio frame.
1126 * Returns: TRUE if ADTS headers were successfully prepended; FALSE otherwise.
1129 gst_aac_parse_prepend_adts_headers (GstAacParse * aacparse,
1130 GstBaseParseFrame * frame)
1133 guint8 *adts_headers;
1136 guint8 id, profile, channel_configuration, sampling_frequency_index;
1138 id = (aacparse->mpegversion == 4) ? 0x0U : 0x1U;
1139 profile = gst_aac_parse_get_audio_profile_object_type (aacparse);
1140 if (profile == G_MAXUINT8) {
1141 GST_ERROR_OBJECT (aacparse, "Unsupported audio profile or object type");
1144 channel_configuration =
1145 gst_aac_parse_get_audio_channel_configuration (aacparse->channels);
1146 if (channel_configuration == G_MAXUINT8) {
1147 GST_ERROR_OBJECT (aacparse, "Unsupported number of channels");
1150 sampling_frequency_index =
1151 gst_aac_parse_get_audio_sampling_frequency_index (aacparse->sample_rate);
1152 if (sampling_frequency_index == G_MAXUINT8) {
1153 GST_ERROR_OBJECT (aacparse, "Unsupported sampling frequency");
1157 frame->out_buffer = gst_buffer_copy (frame->buffer);
1158 buf_size = gst_buffer_get_size (frame->out_buffer);
1159 frame_size = buf_size + ADTS_HEADERS_LENGTH;
1161 if (G_UNLIKELY (frame_size >= 0x4000)) {
1162 GST_ERROR_OBJECT (aacparse, "Frame size is too big for ADTS");
1166 adts_headers = (guint8 *) g_malloc0 (ADTS_HEADERS_LENGTH);
1168 /* Note: no error correction bits are added to the resulting ADTS frames */
1169 adts_headers[0] = 0xFFU;
1170 adts_headers[1] = 0xF0U | (id << 3) | 0x1U;
1171 adts_headers[2] = (profile << 6) | (sampling_frequency_index << 2) | 0x2U |
1172 (channel_configuration & 0x4U);
1173 adts_headers[3] = ((channel_configuration & 0x3U) << 6) | 0x30U |
1174 (guint8) (frame_size >> 11);
1175 adts_headers[4] = (guint8) ((frame_size >> 3) & 0x00FF);
1176 adts_headers[5] = (guint8) (((frame_size & 0x0007) << 5) + 0x1FU);
1177 adts_headers[6] = 0xFCU;
1179 mem = gst_memory_new_wrapped (0, adts_headers, ADTS_HEADERS_LENGTH, 0,
1180 ADTS_HEADERS_LENGTH, adts_headers, g_free);
1181 gst_buffer_prepend_memory (frame->out_buffer, mem);
1187 * gst_aac_parse_check_valid_frame:
1188 * @parse: #GstBaseParse.
1189 * @frame: #GstBaseParseFrame.
1190 * @skipsize: How much data parent class should skip in order to find the
1193 * Implementation of "handle_frame" vmethod in #GstBaseParse class.
1195 * Also determines frame overhead.
1196 * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
1197 * a per-frame header. LOAS has 3 bytes.
1199 * We're making a couple of simplifying assumptions:
1201 * 1. We count Program Configuration Elements rather than searching for them
1202 * in the streams to discount them - the overhead is negligible.
1204 * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
1205 * bits, which should still not be significant enough to warrant the
1206 * additional parsing through the headers
1208 * Returns: a #GstFlowReturn.
1210 static GstFlowReturn
1211 gst_aac_parse_handle_frame (GstBaseParse * parse,
1212 GstBaseParseFrame * frame, gint * skipsize)
1215 GstAacParse *aacparse;
1216 gboolean ret = FALSE;
1220 gint rate = 0, channels = 0;
1222 aacparse = GST_AAC_PARSE (parse);
1223 buffer = frame->buffer;
1225 gst_buffer_map (buffer, &map, GST_MAP_READ);
1228 lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
1230 if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
1231 aacparse->header_type == DSPAAC_HEADER_NONE) {
1232 /* There is nothing to parse */
1233 framesize = map.size;
1236 } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
1238 ret = gst_aac_parse_detect_stream (aacparse, map.data, map.size,
1239 GST_BASE_PARSE_DRAINING (parse), &framesize, skipsize);
1241 } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1242 guint needed_data = 1024;
1244 ret = gst_aac_parse_check_adts_frame (aacparse, map.data, map.size,
1245 GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1247 if (!ret && needed_data) {
1248 GST_DEBUG ("buffer didn't contain valid frame");
1250 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1254 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1255 guint needed_data = 1024;
1257 ret = gst_aac_parse_check_loas_frame (aacparse, map.data,
1258 map.size, GST_BASE_PARSE_DRAINING (parse), &framesize, &needed_data);
1260 if (!ret && needed_data) {
1261 GST_DEBUG ("buffer didn't contain valid frame");
1263 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1268 GST_DEBUG ("buffer didn't contain valid frame");
1269 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
1273 if (G_UNLIKELY (!ret))
1276 if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
1278 frame->overhead = 7;
1280 gst_aac_parse_parse_adts_header (aacparse, map.data,
1281 &rate, &channels, NULL, NULL);
1283 GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
1285 if (G_UNLIKELY (rate != aacparse->sample_rate
1286 || channels != aacparse->channels)) {
1287 aacparse->sample_rate = rate;
1288 aacparse->channels = channels;
1290 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1291 /* If linking fails, we need to return appropriate error */
1292 ret = GST_FLOW_NOT_LINKED;
1295 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1296 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1298 } else if (aacparse->header_type == DSPAAC_HEADER_LOAS) {
1299 gboolean setcaps = FALSE;
1302 frame->overhead = 3;
1304 if (!gst_aac_parse_read_loas_config (aacparse, map.data, map.size, &rate,
1305 &channels, NULL) || !rate || !channels) {
1306 /* This is pretty normal when skipping data at the start of
1307 * random stream (MPEG-TS capture for example) */
1308 GST_DEBUG_OBJECT (aacparse, "Error reading LOAS config. Skipping.");
1309 /* Since we don't fully parse the LOAS config, we don't know for sure
1310 * how much to skip. Just skip 1 to end up to the next marker and
1311 * resume parsing from there */
1316 if (G_UNLIKELY (rate != aacparse->sample_rate
1317 || channels != aacparse->channels)) {
1318 aacparse->sample_rate = rate;
1319 aacparse->channels = channels;
1321 GST_INFO_OBJECT (aacparse, "New LOAS config: %d Hz, %d channels", rate,
1325 /* We want to set caps both at start, and when rate/channels change.
1326 Since only some LOAS frames have that info, we may receive frames
1327 before knowing about rate/channels. */
1329 || !gst_pad_has_current_caps (GST_BASE_PARSE_SRC_PAD (aacparse))) {
1330 if (!gst_aac_parse_set_src_caps (aacparse, NULL)) {
1331 /* If linking fails, we need to return appropriate error */
1332 ret = GST_FLOW_NOT_LINKED;
1335 gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
1336 aacparse->sample_rate, aacparse->frame_samples, 2, 2);
1340 if (aacparse->header_type == DSPAAC_HEADER_NONE
1341 && aacparse->output_header_type == DSPAAC_HEADER_ADTS) {
1342 if (!gst_aac_parse_prepend_adts_headers (aacparse, frame)) {
1343 GST_ERROR_OBJECT (aacparse, "Failed to prepend ADTS headers to frame");
1344 ret = GST_FLOW_ERROR;
1349 gst_buffer_unmap (buffer, &map);
1352 /* found, skip if needed */
1361 if (ret && framesize <= map.size) {
1362 return gst_base_parse_finish_frame (parse, frame, framesize);
1368 static GstFlowReturn
1369 gst_aac_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
1371 GstAacParse *aacparse = GST_AAC_PARSE (parse);
1373 if (!aacparse->sent_codec_tag) {
1374 GstTagList *taglist;
1378 caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
1380 if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
1381 GST_INFO_OBJECT (parse, "Src pad is flushing");
1382 return GST_FLOW_FLUSHING;
1384 GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
1385 return GST_FLOW_NOT_NEGOTIATED;
1389 taglist = gst_tag_list_new_empty ();
1390 gst_pb_utils_add_codec_description_to_tag_list (taglist,
1391 GST_TAG_AUDIO_CODEC, caps);
1392 gst_caps_unref (caps);
1394 gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
1395 gst_tag_list_unref (taglist);
1397 /* also signals the end of first-frame processing */
1398 aacparse->sent_codec_tag = TRUE;
1401 /* As a special case, we can remove the ADTS framing and output raw AAC. */
1402 if (aacparse->header_type == DSPAAC_HEADER_ADTS
1403 && aacparse->output_header_type == DSPAAC_HEADER_NONE) {
1406 gst_buffer_map (frame->buffer, &map, GST_MAP_READ);
1407 header_size = (map.data[1] & 1) ? 7 : 9; /* optional CRC */
1408 gst_buffer_unmap (frame->buffer, &map);
1409 gst_buffer_resize (frame->buffer, header_size,
1410 gst_buffer_get_size (frame->buffer) - header_size);
1418 * gst_aac_parse_start:
1419 * @parse: #GstBaseParse.
1421 * Implementation of "start" vmethod in #GstBaseParse class.
1423 * Returns: TRUE if startup succeeded.
1426 gst_aac_parse_start (GstBaseParse * parse)
1428 GstAacParse *aacparse;
1430 aacparse = GST_AAC_PARSE (parse);
1431 GST_DEBUG ("start");
1432 aacparse->frame_samples = 1024;
1433 gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
1434 aacparse->sent_codec_tag = FALSE;
1440 * gst_aac_parse_stop:
1441 * @parse: #GstBaseParse.
1443 * Implementation of "stop" vmethod in #GstBaseParse class.
1445 * Returns: TRUE is stopping succeeded.
1448 gst_aac_parse_stop (GstBaseParse * parse)
1455 remove_fields (GstCaps * caps)
1459 n = gst_caps_get_size (caps);
1460 for (i = 0; i < n; i++) {
1461 GstStructure *s = gst_caps_get_structure (caps, i);
1463 gst_structure_remove_field (s, "framed");
1468 add_conversion_fields (GstCaps * caps)
1472 n = gst_caps_get_size (caps);
1473 for (i = 0; i < n; i++) {
1474 GstStructure *s = gst_caps_get_structure (caps, i);
1476 if (gst_structure_has_field (s, "stream-format")) {
1477 const GValue *v = gst_structure_get_value (s, "stream-format");
1479 if (G_VALUE_HOLDS_STRING (v)) {
1480 const gchar *str = g_value_get_string (v);
1482 if (strcmp (str, "adts") == 0 || strcmp (str, "raw") == 0) {
1483 GValue va = G_VALUE_INIT;
1484 GValue vs = G_VALUE_INIT;
1486 g_value_init (&va, GST_TYPE_LIST);
1487 g_value_init (&vs, G_TYPE_STRING);
1488 g_value_set_string (&vs, "adts");
1489 gst_value_list_append_value (&va, &vs);
1490 g_value_set_string (&vs, "raw");
1491 gst_value_list_append_value (&va, &vs);
1492 gst_structure_set_value (s, "stream-format", &va);
1493 g_value_unset (&va);
1494 g_value_unset (&vs);
1496 } else if (GST_VALUE_HOLDS_LIST (v)) {
1497 gboolean contains_raw = FALSE;
1498 gboolean contains_adts = FALSE;
1499 guint m = gst_value_list_get_size (v), j;
1501 for (j = 0; j < m; j++) {
1502 const GValue *ve = gst_value_list_get_value (v, j);
1505 if (G_VALUE_HOLDS_STRING (ve) && (str = g_value_get_string (ve))) {
1506 if (strcmp (str, "adts") == 0)
1507 contains_adts = TRUE;
1508 else if (strcmp (str, "raw") == 0)
1509 contains_raw = TRUE;
1513 if (contains_adts || contains_raw) {
1514 GValue va = G_VALUE_INIT;
1515 GValue vs = G_VALUE_INIT;
1517 g_value_init (&va, GST_TYPE_LIST);
1518 g_value_init (&vs, G_TYPE_STRING);
1519 g_value_copy (v, &va);
1521 if (!contains_raw) {
1522 g_value_set_string (&vs, "raw");
1523 gst_value_list_append_value (&va, &vs);
1525 if (!contains_adts) {
1526 g_value_set_string (&vs, "adts");
1527 gst_value_list_append_value (&va, &vs);
1530 gst_structure_set_value (s, "stream-format", &va);
1532 g_value_unset (&vs);
1533 g_value_unset (&va);
1541 gst_aac_parse_sink_getcaps (GstBaseParse * parse, GstCaps * filter)
1543 GstCaps *peercaps, *templ;
1546 templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
1549 GstCaps *fcopy = gst_caps_copy (filter);
1550 /* Remove the fields we convert */
1551 remove_fields (fcopy);
1552 add_conversion_fields (fcopy);
1553 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
1554 gst_caps_unref (fcopy);
1556 peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
1559 peercaps = gst_caps_make_writable (peercaps);
1560 /* Remove the fields we convert */
1561 remove_fields (peercaps);
1562 add_conversion_fields (peercaps);
1564 res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
1565 gst_caps_unref (peercaps);
1566 gst_caps_unref (templ);
1572 GstCaps *intersection;
1575 gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
1576 gst_caps_unref (res);