Merge branch 'master' into 0.11
[platform/upstream/gst-plugins-good.git] / gst / audioparsers / gstaacparse.c
1 /* GStreamer AAC parser plugin
2  * Copyright (C) 2008 Nokia Corporation. All rights reserved.
3  *
4  * Contact: Stefan Kost <stefan.kost@nokia.com>
5  *
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.
10  *
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.
15  *
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., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 /**
23  * SECTION:element-aacparse
24  * @short_description: AAC parser
25  * @see_also: #GstAmrParse
26  *
27  * This is an AAC parser which handles both ADIF and ADTS stream formats.
28  *
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.
32  *
33  * <refsect2>
34  * <title>Example launch line</title>
35  * |[
36  * gst-launch filesrc location=abc.aac ! aacparse ! faad ! audioresample ! audioconvert ! alsasink
37  * ]|
38  * </refsect2>
39  */
40
41 #ifdef HAVE_CONFIG_H
42 #include "config.h"
43 #endif
44
45 #include <string.h>
46
47 #include "gstaacparse.h"
48
49
50 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
51     GST_PAD_SRC,
52     GST_PAD_ALWAYS,
53     GST_STATIC_CAPS ("audio/mpeg, "
54         "framed = (boolean) true, " "mpegversion = (int) { 2, 4 }, "
55         "stream-format = (string) { raw, adts, adif };"));
56
57 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
58     GST_PAD_SINK,
59     GST_PAD_ALWAYS,
60     GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) { 2, 4 };"));
61
62 GST_DEBUG_CATEGORY_STATIC (aacparse_debug);
63 #define GST_CAT_DEFAULT aacparse_debug
64
65
66 #define ADIF_MAX_SIZE 40        /* Should be enough */
67 #define ADTS_MAX_SIZE 10        /* Should be enough */
68
69
70 #define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
71
72 gboolean gst_aac_parse_start (GstBaseParse * parse);
73 gboolean gst_aac_parse_stop (GstBaseParse * parse);
74
75 static gboolean gst_aac_parse_sink_setcaps (GstBaseParse * parse,
76     GstCaps * caps);
77
78 gboolean gst_aac_parse_check_valid_frame (GstBaseParse * parse,
79     GstBaseParseFrame * frame, guint * size, gint * skipsize);
80
81 GstFlowReturn gst_aac_parse_parse_frame (GstBaseParse * parse,
82     GstBaseParseFrame * frame);
83
84 gboolean gst_aac_parse_convert (GstBaseParse * parse,
85     GstFormat src_format,
86     gint64 src_value, GstFormat dest_format, gint64 * dest_value);
87
88 gint gst_aac_parse_get_frame_overhead (GstBaseParse * parse,
89     GstBuffer * buffer);
90
91 gboolean gst_aac_parse_event (GstBaseParse * parse, GstEvent * event);
92
93 G_DEFINE_TYPE (GstAacParse, gst_aac_parse, GST_TYPE_BASE_PARSE);
94
95 static inline gint
96 gst_aac_parse_get_sample_rate_from_index (guint sr_idx)
97 {
98   static const guint aac_sample_rates[] = { 96000, 88200, 64000, 48000, 44100,
99     32000, 24000, 22050, 16000, 12000, 11025, 8000
100   };
101
102   if (sr_idx < G_N_ELEMENTS (aac_sample_rates))
103     return aac_sample_rates[sr_idx];
104   GST_WARNING ("Invalid sample rate index %u", sr_idx);
105   return 0;
106 }
107
108 /**
109  * gst_aac_parse_class_init:
110  * @klass: #GstAacParseClass.
111  *
112  */
113 static void
114 gst_aac_parse_class_init (GstAacParseClass * klass)
115 {
116   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
117   GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
118
119   GST_DEBUG_CATEGORY_INIT (aacparse_debug, "aacparse", 0,
120       "AAC audio stream parser");
121
122   gst_element_class_add_pad_template (element_class,
123       gst_static_pad_template_get (&sink_template));
124   gst_element_class_add_pad_template (element_class,
125       gst_static_pad_template_get (&src_template));
126
127   gst_element_class_set_details_simple (element_class,
128       "AAC audio stream parser", "Codec/Parser/Audio",
129       "Advanced Audio Coding parser", "Stefan Kost <stefan.kost@nokia.com>");
130
131   parse_class->start = GST_DEBUG_FUNCPTR (gst_aac_parse_start);
132   parse_class->stop = GST_DEBUG_FUNCPTR (gst_aac_parse_stop);
133   parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_aac_parse_sink_setcaps);
134   parse_class->parse_frame = GST_DEBUG_FUNCPTR (gst_aac_parse_parse_frame);
135   parse_class->check_valid_frame =
136       GST_DEBUG_FUNCPTR (gst_aac_parse_check_valid_frame);
137 }
138
139
140 /**
141  * gst_aac_parse_init:
142  * @aacparse: #GstAacParse.
143  * @klass: #GstAacParseClass.
144  *
145  */
146 static void
147 gst_aac_parse_init (GstAacParse * aacparse)
148 {
149   GST_DEBUG ("initialized");
150 }
151
152
153 /**
154  * gst_aac_parse_set_src_caps:
155  * @aacparse: #GstAacParse.
156  * @sink_caps: (proposed) caps of sink pad
157  *
158  * Set source pad caps according to current knowledge about the
159  * audio stream.
160  *
161  * Returns: TRUE if caps were successfully set.
162  */
163 static gboolean
164 gst_aac_parse_set_src_caps (GstAacParse * aacparse, GstCaps * sink_caps)
165 {
166   GstStructure *s;
167   GstCaps *src_caps = NULL;
168   gboolean res = FALSE;
169   const gchar *stream_format;
170
171   GST_DEBUG_OBJECT (aacparse, "sink caps: %" GST_PTR_FORMAT, sink_caps);
172   if (sink_caps)
173     src_caps = gst_caps_copy (sink_caps);
174   else
175     src_caps = gst_caps_new_empty_simple ("audio/mpeg");
176
177   gst_caps_set_simple (src_caps, "framed", G_TYPE_BOOLEAN, TRUE,
178       "mpegversion", G_TYPE_INT, aacparse->mpegversion, NULL);
179
180   switch (aacparse->header_type) {
181     case DSPAAC_HEADER_NONE:
182       stream_format = "raw";
183       break;
184     case DSPAAC_HEADER_ADTS:
185       stream_format = "adts";
186       break;
187     case DSPAAC_HEADER_ADIF:
188       stream_format = "adif";
189       break;
190     default:
191       stream_format = NULL;
192   }
193
194   s = gst_caps_get_structure (src_caps, 0);
195   if (aacparse->sample_rate > 0)
196     gst_structure_set (s, "rate", G_TYPE_INT, aacparse->sample_rate, NULL);
197   if (aacparse->channels > 0)
198     gst_structure_set (s, "channels", G_TYPE_INT, aacparse->channels, NULL);
199   if (stream_format)
200     gst_structure_set (s, "stream-format", G_TYPE_STRING, stream_format, NULL);
201
202   GST_DEBUG_OBJECT (aacparse, "setting src caps: %" GST_PTR_FORMAT, src_caps);
203
204   res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
205   gst_caps_unref (src_caps);
206   return res;
207 }
208
209
210 /**
211  * gst_aac_parse_sink_setcaps:
212  * @sinkpad: GstPad
213  * @caps: GstCaps
214  *
215  * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
216  *
217  * Returns: TRUE on success.
218  */
219 static gboolean
220 gst_aac_parse_sink_setcaps (GstBaseParse * parse, GstCaps * caps)
221 {
222   GstAacParse *aacparse;
223   GstStructure *structure;
224   gchar *caps_str;
225   const GValue *value;
226
227   aacparse = GST_AAC_PARSE (parse);
228   structure = gst_caps_get_structure (caps, 0);
229   caps_str = gst_caps_to_string (caps);
230
231   GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
232   g_free (caps_str);
233
234   /* This is needed at least in case of RTP
235    * Parses the codec_data information to get ObjectType,
236    * number of channels and samplerate */
237   value = gst_structure_get_value (structure, "codec_data");
238   if (value) {
239     GstBuffer *buf = gst_value_get_buffer (value);
240
241     if (buf) {
242       guint8 *data;
243       gsize size;
244       guint sr_idx;
245
246       data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
247
248       sr_idx = ((data[0] & 0x07) << 1) | ((data[1] & 0x80) >> 7);
249       aacparse->object_type = (data[0] & 0xf8) >> 3;
250       aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
251       aacparse->channels = (data[1] & 0x78) >> 3;
252       aacparse->header_type = DSPAAC_HEADER_NONE;
253       aacparse->mpegversion = 4;
254       aacparse->frame_samples = (data[1] & 4) ? 960 : 1024;
255       gst_buffer_unmap (buf, data, size);
256
257       GST_DEBUG ("codec_data: object_type=%d, sample_rate=%d, channels=%d, "
258           "samples=%d", aacparse->object_type, aacparse->sample_rate,
259           aacparse->channels, aacparse->frame_samples);
260
261       /* arrange for metadata and get out of the way */
262       gst_aac_parse_set_src_caps (aacparse, caps);
263       gst_base_parse_set_passthrough (parse, TRUE);
264     } else
265       return FALSE;
266
267     /* caps info overrides */
268     gst_structure_get_int (structure, "rate", &aacparse->sample_rate);
269     gst_structure_get_int (structure, "channels", &aacparse->channels);
270   } else {
271     gst_base_parse_set_passthrough (parse, FALSE);
272   }
273
274   return TRUE;
275 }
276
277
278 /**
279  * gst_aac_parse_adts_get_frame_len:
280  * @data: block of data containing an ADTS header.
281  *
282  * This function calculates ADTS frame length from the given header.
283  *
284  * Returns: size of the ADTS frame.
285  */
286 static inline guint
287 gst_aac_parse_adts_get_frame_len (const guint8 * data)
288 {
289   return ((data[3] & 0x03) << 11) | (data[4] << 3) | ((data[5] & 0xe0) >> 5);
290 }
291
292
293 /**
294  * gst_aac_parse_check_adts_frame:
295  * @aacparse: #GstAacParse.
296  * @data: Data to be checked.
297  * @avail: Amount of data passed.
298  * @framesize: If valid ADTS frame was found, this will be set to tell the
299  *             found frame size in bytes.
300  * @needed_data: If frame was not found, this may be set to tell how much
301  *               more data is needed in the next round to detect the frame
302  *               reliably. This may happen when a frame header candidate
303  *               is found but it cannot be guaranteed to be the header without
304  *               peeking the following data.
305  *
306  * Check if the given data contains contains ADTS frame. The algorithm
307  * will examine ADTS frame header and calculate the frame size. Also, another
308  * consecutive ADTS frame header need to be present after the found frame.
309  * Otherwise the data is not considered as a valid ADTS frame. However, this
310  * "extra check" is omitted when EOS has been received. In this case it is
311  * enough when data[0] contains a valid ADTS header.
312  *
313  * This function may set the #needed_data to indicate that a possible frame
314  * candidate has been found, but more data (#needed_data bytes) is needed to
315  * be absolutely sure. When this situation occurs, FALSE will be returned.
316  *
317  * When a valid frame is detected, this function will use
318  * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
319  * to set the needed bytes for next frame.This way next data chunk is already
320  * of correct size.
321  *
322  * Returns: TRUE if the given data contains a valid ADTS header.
323  */
324 static gboolean
325 gst_aac_parse_check_adts_frame (GstAacParse * aacparse,
326     const guint8 * data, const guint avail, gboolean drain,
327     guint * framesize, guint * needed_data)
328 {
329   if (G_UNLIKELY (avail < 2))
330     return FALSE;
331
332   if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
333     *framesize = gst_aac_parse_adts_get_frame_len (data);
334
335     /* In EOS mode this is enough. No need to examine the data further.
336        We also relax the check when we have sync, on the assumption that
337        if we're not looking at random data, we have a much higher chance
338        to get the correct sync, and this avoids losing two frames when
339        a single bit corruption happens. */
340     if (drain || !GST_BASE_PARSE_LOST_SYNC (aacparse)) {
341       return TRUE;
342     }
343
344     if (*framesize + ADTS_MAX_SIZE > avail) {
345       /* We have found a possible frame header candidate, but can't be
346          sure since we don't have enough data to check the next frame */
347       GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
348           *framesize + ADTS_MAX_SIZE, avail);
349       *needed_data = *framesize + ADTS_MAX_SIZE;
350       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
351           *framesize + ADTS_MAX_SIZE);
352       return FALSE;
353     }
354
355     if ((data[*framesize] == 0xff) && ((data[*framesize + 1] & 0xf6) == 0xf0)) {
356       guint nextlen = gst_aac_parse_adts_get_frame_len (data + (*framesize));
357
358       GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
359       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
360           nextlen + ADTS_MAX_SIZE);
361       return TRUE;
362     }
363   }
364   return FALSE;
365 }
366
367 /* caller ensure sufficient data */
368 static inline void
369 gst_aac_parse_parse_adts_header (GstAacParse * aacparse, const guint8 * data,
370     gint * rate, gint * channels, gint * object, gint * version)
371 {
372
373   if (rate) {
374     gint sr_idx = (data[2] & 0x3c) >> 2;
375
376     *rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
377   }
378   if (channels)
379     *channels = ((data[2] & 0x01) << 2) | ((data[3] & 0xc0) >> 6);
380
381   if (version)
382     *version = (data[1] & 0x08) ? 2 : 4;
383   if (object)
384     *object = (data[2] & 0xc0) >> 6;
385 }
386
387 /**
388  * gst_aac_parse_detect_stream:
389  * @aacparse: #GstAacParse.
390  * @data: A block of data that needs to be examined for stream characteristics.
391  * @avail: Size of the given datablock.
392  * @framesize: If valid stream was found, this will be set to tell the
393  *             first frame size in bytes.
394  * @skipsize: If valid stream was found, this will be set to tell the first
395  *            audio frame position within the given data.
396  *
397  * Examines the given piece of data and try to detect the format of it. It
398  * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
399  * header. If the stream is detected, TRUE will be returned and #framesize
400  * is set to indicate the found frame size. Additionally, #skipsize might
401  * be set to indicate the number of bytes that need to be skipped, a.k.a. the
402  * position of the frame inside given data chunk.
403  *
404  * Returns: TRUE on success.
405  */
406 static gboolean
407 gst_aac_parse_detect_stream (GstAacParse * aacparse,
408     const guint8 * data, const guint avail, gboolean drain,
409     guint * framesize, gint * skipsize)
410 {
411   gboolean found = FALSE;
412   guint need_data = 0;
413   guint i = 0;
414
415   GST_DEBUG_OBJECT (aacparse, "Parsing header data");
416
417   /* FIXME: No need to check for ADIF if we are not in the beginning of the
418      stream */
419
420   /* Can we even parse the header? */
421   if (avail < ADTS_MAX_SIZE)
422     return FALSE;
423
424   for (i = 0; i < avail - 4; i++) {
425     if (((data[i] == 0xff) && ((data[i + 1] & 0xf6) == 0xf0)) ||
426         strncmp ((char *) data + i, "ADIF", 4) == 0) {
427       found = TRUE;
428
429       if (i) {
430         /* Trick: tell the parent class that we didn't find the frame yet,
431            but make it skip 'i' amount of bytes. Next time we arrive
432            here we have full frame in the beginning of the data. */
433         *skipsize = i;
434         return FALSE;
435       }
436       break;
437     }
438   }
439   if (!found) {
440     if (i)
441       *skipsize = i;
442     return FALSE;
443   }
444
445   if (gst_aac_parse_check_adts_frame (aacparse, data, avail, drain,
446           framesize, &need_data)) {
447     gint rate, channels;
448
449     GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08) >> 3, *framesize);
450
451     aacparse->header_type = DSPAAC_HEADER_ADTS;
452     gst_aac_parse_parse_adts_header (aacparse, data, &rate, &channels,
453         &aacparse->object_type, &aacparse->mpegversion);
454
455     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse), rate,
456         aacparse->frame_samples, 2, 2);
457
458     GST_DEBUG ("ADTS: samplerate %d, channels %d, objtype %d, version %d",
459         rate, channels, aacparse->object_type, aacparse->mpegversion);
460
461     gst_base_parse_set_syncable (GST_BASE_PARSE (aacparse), TRUE);
462
463     return TRUE;
464   } else if (need_data) {
465     /* This tells the parent class not to skip any data */
466     *skipsize = 0;
467     return FALSE;
468   }
469
470   if (avail < ADIF_MAX_SIZE)
471     return FALSE;
472
473   if (memcmp (data + i, "ADIF", 4) == 0) {
474     const guint8 *adif;
475     int skip_size = 0;
476     int bitstream_type;
477     int sr_idx;
478     GstCaps *sinkcaps;
479
480     aacparse->header_type = DSPAAC_HEADER_ADIF;
481     aacparse->mpegversion = 4;
482
483     /* Skip the "ADIF" bytes */
484     adif = data + i + 4;
485
486     /* copyright string */
487     if (adif[0] & 0x80)
488       skip_size += 9;           /* skip 9 bytes */
489
490     bitstream_type = adif[0 + skip_size] & 0x10;
491     aacparse->bitrate =
492         ((unsigned int) (adif[0 + skip_size] & 0x0f) << 19) |
493         ((unsigned int) adif[1 + skip_size] << 11) |
494         ((unsigned int) adif[2 + skip_size] << 3) |
495         ((unsigned int) adif[3 + skip_size] & 0xe0);
496
497     /* CBR */
498     if (bitstream_type == 0) {
499 #if 0
500       /* Buffer fullness parsing. Currently not needed... */
501       guint num_elems = 0;
502       guint fullness = 0;
503
504       num_elems = (adif[3 + skip_size] & 0x1e);
505       GST_INFO ("ADIF num_config_elems: %d", num_elems);
506
507       fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
508           ((unsigned int) adif[4 + skip_size] << 11) |
509           ((unsigned int) adif[5 + skip_size] << 3) |
510           ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
511
512       GST_INFO ("ADIF buffer fullness: %d", fullness);
513 #endif
514       aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
515           ((adif[7 + skip_size] & 0x80) >> 7);
516       sr_idx = (adif[7 + skip_size] & 0x78) >> 3;
517     }
518     /* VBR */
519     else {
520       aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
521       sr_idx = ((adif[4 + skip_size] & 0x07) << 1) |
522           ((adif[5 + skip_size] & 0x80) >> 7);
523     }
524
525     /* FIXME: This gives totally wrong results. Duration calculation cannot
526        be based on this */
527     aacparse->sample_rate = gst_aac_parse_get_sample_rate_from_index (sr_idx);
528
529     /* baseparse is not given any fps,
530      * so it will give up on timestamps, seeking, etc */
531
532     /* FIXME: Can we assume this? */
533     aacparse->channels = 2;
534
535     GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
536         aacparse->bitrate, aacparse->sample_rate, aacparse->object_type);
537
538     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
539
540     /* arrange for metadata and get out of the way */
541     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE_SINK_PAD (aacparse));
542     gst_aac_parse_set_src_caps (aacparse, sinkcaps);
543     gst_caps_unref (sinkcaps);
544
545     /* not syncable, not easily seekable (unless we push data from start */
546     gst_base_parse_set_syncable (GST_BASE_PARSE_CAST (aacparse), FALSE);
547     gst_base_parse_set_passthrough (GST_BASE_PARSE_CAST (aacparse), TRUE);
548     gst_base_parse_set_average_bitrate (GST_BASE_PARSE_CAST (aacparse), 0);
549
550     *framesize = avail;
551     return TRUE;
552   }
553
554   /* This should never happen */
555   return FALSE;
556 }
557
558
559 /**
560  * gst_aac_parse_check_valid_frame:
561  * @parse: #GstBaseParse.
562  * @buffer: #GstBuffer.
563  * @framesize: If the buffer contains a valid frame, its size will be put here
564  * @skipsize: How much data parent class should skip in order to find the
565  *            frame header.
566  *
567  * Implementation of "check_valid_frame" vmethod in #GstBaseParse class.
568  *
569  * Returns: TRUE if buffer contains a valid frame.
570  */
571 gboolean
572 gst_aac_parse_check_valid_frame (GstBaseParse * parse,
573     GstBaseParseFrame * frame, guint * framesize, gint * skipsize)
574 {
575   guint8 *data;
576   gsize size;
577   GstAacParse *aacparse;
578   gboolean ret = FALSE;
579   gboolean lost_sync;
580   GstBuffer *buffer;
581
582   aacparse = GST_AAC_PARSE (parse);
583   buffer = frame->buffer;
584
585   data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
586
587   lost_sync = GST_BASE_PARSE_LOST_SYNC (parse);
588
589   if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
590       aacparse->header_type == DSPAAC_HEADER_NONE) {
591     /* There is nothing to parse */
592     *framesize = size;
593     ret = TRUE;
594
595   } else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED || lost_sync) {
596
597     ret = gst_aac_parse_detect_stream (aacparse, data, size,
598         GST_BASE_PARSE_DRAINING (parse), framesize, skipsize);
599
600   } else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
601     guint needed_data = 1024;
602
603     ret = gst_aac_parse_check_adts_frame (aacparse, data, size,
604         GST_BASE_PARSE_DRAINING (parse), framesize, &needed_data);
605
606     if (!ret) {
607       GST_DEBUG ("buffer didn't contain valid frame");
608       gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
609           needed_data);
610     }
611
612   } else {
613     GST_DEBUG ("buffer didn't contain valid frame");
614     gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
615         ADTS_MAX_SIZE);
616   }
617   gst_buffer_unmap (buffer, data, size);
618
619   return ret;
620 }
621
622
623 /**
624  * gst_aac_parse_parse_frame:
625  * @parse: #GstBaseParse.
626  * @buffer: #GstBuffer.
627  *
628  * Implementation of "parse_frame" vmethod in #GstBaseParse class.
629  *
630  * Also determines frame overhead.
631  * ADTS streams have a 7 byte header in each frame. MP4 and ADIF streams don't have
632  * a per-frame header.
633  *
634  * We're making a couple of simplifying assumptions:
635  *
636  * 1. We count Program Configuration Elements rather than searching for them
637  *    in the streams to discount them - the overhead is negligible.
638  *
639  * 2. We ignore CRC. This has a worst-case impact of (num_raw_blocks + 1)*16
640  *    bits, which should still not be significant enough to warrant the
641  *    additional parsing through the headers
642  *
643  * Returns: GST_FLOW_OK if frame was successfully parsed and can be pushed
644  *          forward. Otherwise appropriate error is returned.
645  */
646 GstFlowReturn
647 gst_aac_parse_parse_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
648 {
649   GstAacParse *aacparse;
650   GstBuffer *buffer;
651   GstFlowReturn ret = GST_FLOW_OK;
652   gint rate, channels;
653   guint8 *data;
654   gsize size;
655
656   aacparse = GST_AAC_PARSE (parse);
657   buffer = frame->buffer;
658
659   if (G_UNLIKELY (aacparse->header_type != DSPAAC_HEADER_ADTS))
660     return ret;
661
662   /* see above */
663   frame->overhead = 7;
664
665   data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
666   gst_aac_parse_parse_adts_header (aacparse, data,
667       &rate, &channels, NULL, NULL);
668   gst_buffer_unmap (buffer, data, size);
669
670   GST_LOG_OBJECT (aacparse, "rate: %d, chans: %d", rate, channels);
671
672   if (G_UNLIKELY (rate != aacparse->sample_rate
673           || channels != aacparse->channels)) {
674     GstCaps *sinkcaps;
675
676     aacparse->sample_rate = rate;
677     aacparse->channels = channels;
678
679     sinkcaps = gst_pad_get_current_caps (GST_BASE_PARSE (aacparse)->sinkpad);
680     if (!gst_aac_parse_set_src_caps (aacparse, sinkcaps)) {
681       /* If linking fails, we need to return appropriate error */
682       gst_caps_unref (sinkcaps);
683       ret = GST_FLOW_NOT_LINKED;
684     }
685     gst_caps_unref (sinkcaps);
686
687     gst_base_parse_set_frame_rate (GST_BASE_PARSE (aacparse),
688         aacparse->sample_rate, aacparse->frame_samples, 2, 2);
689   }
690
691   return ret;
692 }
693
694
695 /**
696  * gst_aac_parse_start:
697  * @parse: #GstBaseParse.
698  *
699  * Implementation of "start" vmethod in #GstBaseParse class.
700  *
701  * Returns: TRUE if startup succeeded.
702  */
703 gboolean
704 gst_aac_parse_start (GstBaseParse * parse)
705 {
706   GstAacParse *aacparse;
707
708   aacparse = GST_AAC_PARSE (parse);
709   GST_DEBUG ("start");
710   aacparse->frame_samples = 1024;
711   gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), ADTS_MAX_SIZE);
712   return TRUE;
713 }
714
715
716 /**
717  * gst_aac_parse_stop:
718  * @parse: #GstBaseParse.
719  *
720  * Implementation of "stop" vmethod in #GstBaseParse class.
721  *
722  * Returns: TRUE is stopping succeeded.
723  */
724 gboolean
725 gst_aac_parse_stop (GstBaseParse * parse)
726 {
727   GST_DEBUG ("stop");
728   return TRUE;
729 }