? gst/aacparse
Index: configure.ac
===================================================================
RCS file: /cvs/gstreamer/gst-plugins-bad/configure.ac,v
retrieving revision 1.892
diff -u -r1.892 configure.ac
--- configure.ac	9 Sep 2008 17:56:09 -0000	1.892
+++ configure.ac	15 Sep 2008 13:02:29 -0000
@@ -241,6 +241,7 @@
 dnl *** plug-ins to include ***
 
 dnl these are all the gst plug-ins, compilable without additional libs
+AG_GST_CHECK_PLUGIN(aacparse)
 AG_GST_CHECK_PLUGIN(aiffparse)
 AG_GST_CHECK_PLUGIN(app)
 AG_GST_CHECK_PLUGIN(bayer)
@@ -1393,6 +1394,7 @@
 Makefile
 gst-plugins-bad.spec
 gst/Makefile
+gst/aacparse/Makefile
 gst/aiffparse/Makefile
 gst/app/Makefile
 gst/bayer/Makefile
Index: tests/check/Makefile.am
===================================================================
RCS file: /cvs/gstreamer/gst-plugins-bad/tests/check/Makefile.am,v
retrieving revision 1.60
diff -u -r1.60 Makefile.am
--- tests/check/Makefile.am	12 Aug 2008 13:08:39 -0000	1.60
+++ tests/check/Makefile.am	15 Sep 2008 13:02:31 -0000
@@ -82,7 +82,8 @@
 	$(check_timidity)  \
 	$(check_x264enc)   \
 	elements/selector \
-	elements/y4menc
+	elements/y4menc   \
+	elements/aacparse
 
 noinst_HEADERS = 
 
Index: tests/check/elements/aacparse.c
===================================================================
RCS file: tests/check/elements/aacparse.c
diff -N tests/check/elements/aacparse.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ tests/check/elements/aacparse.c	15 Sep 2008 13:02:31 -0000
@@ -0,0 +1,510 @@
+/*
+ * GStreamer
+ *
+ * unit test for aacparse
+ *
+ * Copyright (C) 2008 Nokia Corporation. All rights reserved.
+ *
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/check/gstcheck.h>
+#include "aacparse_data.h"
+
+#define SRC_CAPS_CDATA "audio/mpeg, framed=(boolean)false, codec_data=(buffer)1190"
+#define SRC_CAPS_TMPL  "audio/mpeg, framed=(boolean)false, mpegversion=(int){2,4}"
+
+#define SINK_CAPS       "audio/mpeg, framed=(boolean)true"
+#define SINK_CAPS_MPEG2 "audio/mpeg, framed=(boolean)true, mpegversion=2"
+#define SINK_CAPS_MPEG4 "audio/mpeg, framed=(boolean)true, mpegversion=4"
+#define SINK_CAPS_TMPL  "audio/mpeg, framed=(boolean)true, mpegversion=(int){2,4}"
+
+GList *buffers;
+GList *current_buf = NULL;
+
+GstPad *srcpad, *sinkpad;
+guint dataoffset = 0;
+GstClockTime ts_counter = 0;
+gint64 offset_counter = 0;
+guint buffer_counter = 0;
+
+static GstStaticPadTemplate sinktemplate =
+    GST_STATIC_PAD_TEMPLATE ("sink",
+                             GST_PAD_SINK,
+                             GST_PAD_ALWAYS,
+                             GST_STATIC_CAPS (SINK_CAPS_TMPL)
+                            );
+
+static GstStaticPadTemplate srctemplate =
+    GST_STATIC_PAD_TEMPLATE ("src",
+                             GST_PAD_SRC,
+                             GST_PAD_ALWAYS,
+                             GST_STATIC_CAPS (SRC_CAPS_TMPL)
+                            );
+
+typedef struct
+{
+  guint buffers_before_offset_skip;
+  guint offset_skip_amount;
+  const unsigned char *data_to_verify;
+  GstCaps *caps;
+} buffer_verify_data_s;
+
+/**
+ *
+ *
+ */
+
+/* takes a copy of the passed buffer data */
+GstBuffer *
+buffer_new (const unsigned char * buffer_data, guint size)
+{
+  GstBuffer *buffer;
+
+  buffer = gst_buffer_new_and_alloc (size);
+  if (buffer_data) {
+    memcpy (GST_BUFFER_DATA (buffer), buffer_data, size);
+  }
+  else {
+    guint i;
+    /* Create a recognizable pattern (loop 0x00 -> 0xff) in the data block */
+    for (i=0; i<size; i++) {
+      GST_BUFFER_DATA (buffer)[i] = i % 0x100;
+    }
+  }
+
+  gst_buffer_set_caps (buffer, GST_PAD_CAPS (srcpad));
+  GST_BUFFER_OFFSET (buffer) = dataoffset;
+  dataoffset += size;
+  return buffer;
+}
+
+
+/**
+ * Count buffer sizes together.
+ */
+static void
+buffer_count_size (void *buffer, void *user_data)
+{
+  guint *sum = (guint *) user_data;
+  *sum += GST_BUFFER_SIZE (buffer);
+}
+
+
+/**
+ * Verify that given buffer contains predefined ADTS frame.
+ */
+static void
+buffer_verify_adts (void *buffer, void *user_data)
+{
+  buffer_verify_data_s *vdata;
+
+  if (!user_data) {
+    return;
+  }
+
+  vdata = (buffer_verify_data_s *) user_data;
+
+  fail_unless (memcmp (GST_BUFFER_DATA (buffer), vdata->data_to_verify,
+               ADTS_FRAME_LEN) == 0);
+
+  fail_unless (GST_BUFFER_TIMESTAMP (buffer) == ts_counter);
+  fail_unless (GST_BUFFER_DURATION (buffer) != 0);
+
+  if (vdata->buffers_before_offset_skip) {
+    /* This is for skipping the garbage in some test cases */
+    if (buffer_counter == vdata->buffers_before_offset_skip) {
+      offset_counter += vdata->offset_skip_amount;
+    }
+  }
+  fail_unless (GST_BUFFER_OFFSET (buffer) == offset_counter);
+
+  if (vdata->caps) {
+    gchar *bcaps = gst_caps_to_string (GST_BUFFER_CAPS (buffer));
+    g_free (bcaps);
+
+    fail_unless (gst_caps_is_equal (GST_BUFFER_CAPS (buffer), vdata->caps));
+  }
+
+  ts_counter += GST_BUFFER_DURATION (buffer);
+  offset_counter += ADTS_FRAME_LEN;
+  buffer_counter++;
+}
+
+/**
+ *
+ *
+ */
+
+GstElement *
+setup_aacparse (const gchar *src_caps_str)
+{
+  GstElement *aacparse;
+  GstCaps *srccaps = NULL;
+  GstBus *bus;
+
+  if (src_caps_str) {
+    srccaps = gst_caps_from_string (src_caps_str);
+    fail_unless (srccaps != NULL);
+  }
+
+  aacparse = gst_check_setup_element ("aacparse");
+  srcpad = gst_check_setup_src_pad (aacparse, &srctemplate, srccaps);
+  sinkpad = gst_check_setup_sink_pad (aacparse, &sinktemplate, NULL);
+  gst_pad_set_active (srcpad, TRUE);
+  gst_pad_set_active (sinkpad, TRUE);
+
+  bus = gst_bus_new ();
+  gst_element_set_bus (aacparse, bus);
+
+  fail_unless (gst_element_set_state (aacparse,
+          GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
+      "could not set to playing");
+
+  if (srccaps) {
+    gst_caps_unref (srccaps);
+  }
+  ts_counter = offset_counter = buffer_counter = 0;
+  buffers = NULL;
+  return aacparse;
+}
+
+/**
+ *
+ *
+ */
+static void
+cleanup_aacparse (GstElement * aacparse)
+{
+  GstBus *bus;
+
+  /* Free parsed buffers */
+  gst_check_drop_buffers ();
+
+  bus = GST_ELEMENT_BUS (aacparse);
+  gst_bus_set_flushing (bus, TRUE);
+  gst_object_unref (bus);
+
+  gst_pad_set_active (srcpad, FALSE);
+  gst_pad_set_active (sinkpad, FALSE);
+  gst_check_teardown_src_pad (aacparse);
+  gst_check_teardown_sink_pad (aacparse);
+  gst_check_teardown_element (aacparse);
+}
+
+
+/**
+ * Test if the parser pushes data with ADIF header properly and detects the
+ * stream to MPEG4 properly.
+ */
+GST_START_TEST (test_parse_adif_normal)
+{
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  GstCaps *scaps, *sinkcaps;
+  guint datasum = 0;
+  guint i;
+
+  aacparse = setup_aacparse (NULL);
+
+  buffer = buffer_new (adif_header, ADIF_HEADER_LEN);
+  fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+
+  for (i=0; i < 3; i++) {
+    buffer = buffer_new (NULL, 100);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  /* Calculate the outputted buffer sizes */
+  g_list_foreach (buffers, buffer_count_size, &datasum);
+
+  /* ADIF is not a framed format, and therefore we cannot expect the
+     same amount of output buffers as we pushed. However, all data should
+     still come through, including the header bytes */
+  fail_unless_equals_int (datasum, 3 * 100 + ADIF_HEADER_LEN);
+
+  /* Check that the negotiated caps are as expected */
+  /* For ADIF parser assumes that data is always version 4 */
+  scaps = gst_caps_from_string (SINK_CAPS_MPEG4);
+  sinkcaps = gst_pad_get_negotiated_caps (sinkpad);
+  fail_unless (gst_caps_is_equal (sinkcaps, scaps));
+  gst_caps_unref (sinkcaps);
+  gst_caps_unref (scaps);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Test if the parser pushes data with ADTS frames properly.
+ */
+GST_START_TEST (test_parse_adts_normal)
+{
+  buffer_verify_data_s vdata = { 0, 0, adts_frame_mpeg4, NULL };
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  guint i;
+
+  aacparse = setup_aacparse (NULL);
+
+  for (i=0; i < 10; i++) {
+    buffer = buffer_new (adts_frame_mpeg4, ADTS_FRAME_LEN);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  fail_unless_equals_int (g_list_length (buffers), 10);
+  g_list_foreach (buffers, buffer_verify_adts, &vdata);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Test if ADTS parser drains its buffers properly. Even one single frame
+ * should be drained and pushed forward when EOS occurs. This single frame
+ * case is special, since normally the parser needs more data to be sure
+ * about stream format. But it should still push the frame forward in EOS.
+ */
+GST_START_TEST (test_parse_adts_drain_single)
+{
+  buffer_verify_data_s vdata = { 0, 0, adts_frame_mpeg4, NULL };
+  GstElement *aacparse;
+  GstBuffer *buffer;
+
+  aacparse = setup_aacparse (NULL);
+
+  buffer = buffer_new (adts_frame_mpeg4, ADTS_FRAME_LEN);
+  fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  fail_unless_equals_int (g_list_length (buffers), 1);
+  g_list_foreach (buffers, buffer_verify_adts, &vdata);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Make sure that parser does not drain garbage when EOS occurs.
+ */
+GST_START_TEST (test_parse_adts_drain_garbage)
+{
+  buffer_verify_data_s vdata = { 0, 0, adts_frame_mpeg4, NULL };
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  guint i;
+
+  aacparse = setup_aacparse (NULL);
+
+  for (i=0; i < 10; i++) {
+    buffer = buffer_new (adts_frame_mpeg4, ADTS_FRAME_LEN);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+
+  /* Push one garbage frame and then EOS */
+  buffer = buffer_new (garbage_frame, GARBAGE_FRAME_LEN);
+  fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  fail_unless_equals_int (g_list_length (buffers), 10);
+  g_list_foreach (buffers, buffer_verify_adts, &vdata);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Test if ADTS parser splits a buffer that contains two frames into two
+ * separate buffers properly.
+ */
+GST_START_TEST (test_parse_adts_split)
+{
+  buffer_verify_data_s vdata = { 0, 0, adts_frame_mpeg4, NULL };
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  guint i;
+
+  aacparse = setup_aacparse (NULL);
+
+  for (i=0; i < 5; i++) {
+    buffer = buffer_new (adts_frame_mpeg4, ADTS_FRAME_LEN * 2);
+    memcpy (GST_BUFFER_DATA (buffer) + ADTS_FRAME_LEN,
+            adts_frame_mpeg4, ADTS_FRAME_LEN);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  fail_unless_equals_int (g_list_length (buffers), 10);
+  g_list_foreach (buffers, buffer_verify_adts, &vdata);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Test if the ADTS parser skips garbage between frames properly.
+ */
+GST_START_TEST (test_parse_adts_skip_garbage)
+{
+  buffer_verify_data_s vdata = { 10, GARBAGE_FRAME_LEN, adts_frame_mpeg4, NULL };
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  guint i;
+
+  aacparse = setup_aacparse (NULL);
+
+  for (i=0; i < 10; i++) {
+    buffer = buffer_new (adts_frame_mpeg4, ADTS_FRAME_LEN);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+
+  /* push garbage */
+  buffer = buffer_new (garbage_frame, GARBAGE_FRAME_LEN);
+  fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+
+  for (i=0; i < 10; i++) {
+    buffer = buffer_new (adts_frame_mpeg4, ADTS_FRAME_LEN);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  fail_unless_equals_int (g_list_length (buffers), 20);
+  g_list_foreach (buffers, buffer_verify_adts, &vdata);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Test if the src caps are set according to stream format (MPEG version).
+ */
+GST_START_TEST (test_parse_adts_detect_mpeg_version)
+{
+  buffer_verify_data_s vdata = { 0, 0, adts_frame_mpeg2, NULL };
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  GstCaps *sinkcaps;
+  guint i;
+
+  aacparse = setup_aacparse (NULL);
+
+  /* buffer_verify_adts will check if the caps are equal */
+  vdata.caps = gst_caps_from_string (SINK_CAPS_MPEG2);
+
+  for (i=0; i < 10; i++) {
+    /* Push MPEG version 2 frames.*/
+    buffer = buffer_new (adts_frame_mpeg2, ADTS_FRAME_LEN);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  /* Check that the negotiated caps are as expected */
+  sinkcaps = gst_pad_get_negotiated_caps (sinkpad);
+  fail_unless (gst_caps_is_equal (sinkcaps, vdata.caps));
+  gst_caps_unref (sinkcaps);
+
+  fail_unless_equals_int (g_list_length (buffers), 10);
+  g_list_foreach (buffers, buffer_verify_adts, &vdata);
+
+  gst_caps_unref (vdata.caps);
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ * Test if the parser handles raw stream and codec_data info properly.
+ */
+GST_START_TEST (test_parse_handle_codec_data)
+{
+  GstElement *aacparse;
+  GstBuffer *buffer;
+  GstCaps *scaps, *sinkcaps;
+  guint datasum = 0;
+  guint i;
+
+  aacparse = setup_aacparse (SRC_CAPS_CDATA);
+
+  for (i=0; i < 10; i++) {
+    /* Push random data. It should get through since the parser should be
+       initialized because it got codec_data in the caps */
+    buffer = buffer_new (NULL, 100);
+    fail_unless_equals_int (gst_pad_push (srcpad, buffer), GST_FLOW_OK);
+  }
+  gst_pad_push_event (srcpad, gst_event_new_eos ());
+
+  /* Check that the negotiated caps are as expected */
+  /* When codec_data is present, parser assumes that data is version 4 */
+  scaps = gst_caps_from_string (SINK_CAPS_MPEG4);
+  sinkcaps = gst_pad_get_negotiated_caps (sinkpad);
+  fail_unless (gst_caps_is_equal (sinkcaps, scaps));
+  gst_caps_unref (sinkcaps);
+  gst_caps_unref (scaps);
+
+  g_list_foreach (buffers, buffer_count_size, &datasum);
+  fail_unless_equals_int (datasum, 10 * 100);
+
+  cleanup_aacparse (aacparse);
+}
+GST_END_TEST;
+
+
+/**
+ *
+ *
+ */
+static Suite *
+aacparse_suite ()
+{
+  Suite *s = suite_create ("aacparse");
+  TCase *tc_chain = tcase_create ("general");
+
+  suite_add_tcase (s, tc_chain);
+  /* ADIF tests */
+  tcase_add_test (tc_chain, test_parse_adif_normal);
+
+  /* ADTS tests */
+  tcase_add_test (tc_chain, test_parse_adts_normal);
+  tcase_add_test (tc_chain, test_parse_adts_drain_single);
+  tcase_add_test (tc_chain, test_parse_adts_drain_garbage);
+  tcase_add_test (tc_chain, test_parse_adts_split);
+  tcase_add_test (tc_chain, test_parse_adts_skip_garbage);
+  tcase_add_test (tc_chain, test_parse_adts_detect_mpeg_version);
+
+  /* Other tests */
+  tcase_add_test (tc_chain, test_parse_handle_codec_data);
+
+  return s;
+}
+
+
+/**
+ * TODO:
+ *   - Both push- and pull-modes need to be tested
+ *      * Pull-mode & EOS
+ */
+
+GST_CHECK_MAIN (aacparse);
Index: tests/check/elements/aacparse_data.h
===================================================================
RCS file: tests/check/elements/aacparse_data.h
diff -N tests/check/elements/aacparse_data.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ tests/check/elements/aacparse_data.h	15 Sep 2008 13:02:31 -0000
@@ -0,0 +1,52 @@
+/*
+ * GStreamer
+ *
+ * unit test data for aacparse
+ *
+ * Copyright (C) 2008 Nokia Corporation. All rights reserved.
+ *
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#define ADIF_HEADER_LEN 4
+
+static const unsigned char adif_header[]=
+{
+  'A','D','I','F'
+};
+
+#define ADTS_FRAME_LEN 15
+
+static const unsigned char adts_frame_mpeg2[]=
+{
+  0xff, 0xf9, 0x4c, 0x80, 0x01, 0xff, 0xfc, 0x21, 0x10, 0xd3, 0x20, 0x0c,
+  0x32, 0x00, 0xc7
+};
+
+static const unsigned char adts_frame_mpeg4[]=
+{
+  0xff, 0xf1, 0x4c, 0x80, 0x01, 0xff, 0xfc, 0x21, 0x10, 0xd3, 0x20, 0x0c,
+  0x32, 0x00, 0xc7
+};
+
+#define GARBAGE_FRAME_LEN 5
+
+static const unsigned char garbage_frame[]=
+{
+  0xff, 0xff, 0xff, 0xff, 0xff
+};
Index: gst/aacparse/Makefile.am
===================================================================
RCS file: gst/aacparse/Makefile.am
diff -N gst/aacparse/Makefile.am
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gst/aacparse/Makefile.am	15 Sep 2008 13:02:43 -0000
@@ -0,0 +1,10 @@
+plugin_LTLIBRARIES = libgstaacparse.la
+
+libgstaacparse_la_SOURCES = \
+	gstaacparse.c gstbaseparse.c
+
+libgstaacparse_la_CFLAGS = $(GST_CFLAGS) $(PACKAGE_CFLAGS)
+libgstaacparse_la_LIBADD = -lgstbase-0.10
+libgstaacparse_la_LDFLAGS = $(PACKAGE_LIBS)
+
+noinst_HEADERS = gstaacparse.h gstbaseparse.h
Index: gst/aacparse/gstaacparse.c
===================================================================
RCS file: gst/aacparse/gstaacparse.c
diff -N gst/aacparse/gstaacparse.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gst/aacparse/gstaacparse.c	15 Sep 2008 13:02:44 -0000
@@ -0,0 +1,884 @@
+/* GStreamer AAC parser plugin
+ * Copyright (C) 2008 Nokia Corporation. All rights reserved.
+ *
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:gstaacparse
+ * @short_description: AAC parser
+ * @see_also: #GstAmrParse
+ *
+ * <refsect2>
+ * <para>
+ * This is an AAC parser. It can handle both ADIF and ADTS stream formats.
+ * The parser inherits from #GstBaseParse and therefore in only needs to
+ * implement AAC-specific functionality.
+ * </para>
+ * <para>
+ * As ADIF format is not framed, it is not seekable. From the same reason
+ * stream duration cannot be calculated either. Instead, AAC clips that are
+ * in ADTS format can be seeked, and parser also is able to calculate their
+ * playback position and clip duration.
+ * </para>
+ * <title>Example launch line</title>
+ * <para>
+ * <programlisting>
+ * gst-launch filesrc location=abc.aac ! aacparse ! faad ! audioresample ! audioconvert ! alsasink
+ * </programlisting>
+ * </para>
+ * </refsect2>
+ */
+
+#include <string.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gstaacparse.h"
+
+
+static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("audio/mpeg, "
+                     "framed = (boolean) true, "
+                     "mpegversion = (int) { 2, 4 };"));
+
+static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("audio/mpeg, "
+                     "framed = (boolean) false, "
+                     "mpegversion = (int) { 2, 4 };"));
+
+GST_DEBUG_CATEGORY_STATIC (gst_aacparse_debug);
+#define GST_CAT_DEFAULT gst_aacparse_debug
+
+
+static const guint aac_sample_rates[] = {
+  96000,
+  88200,
+  64000,
+  48000,
+  44100,
+  32000,
+  24000,
+  22050,
+  16000,
+  12000,
+  11025,
+  8000
+};
+
+
+#define ADIF_MAX_SIZE 40 /* Should be enough */
+#define ADTS_MAX_SIZE 10 /* Should be enough */
+
+
+#define AAC_FRAME_DURATION(parse) (GST_SECOND/parse->frames_per_sec)
+
+static void gst_aacparse_finalize (GObject * object);
+
+gboolean gst_aacparse_start (GstBaseParse *parse);
+gboolean gst_aacparse_stop (GstBaseParse *parse);
+
+static gboolean gst_aacparse_sink_setcaps (GstBaseParse *parse,
+                                           GstCaps *caps);
+
+gboolean gst_aacparse_check_valid_frame (GstBaseParse *parse,
+                                         GstBuffer *buffer,
+                                         guint *size,
+                                         gint *skipsize);
+
+GstFlowReturn gst_aacparse_parse_frame (GstBaseParse *parse,
+                                        GstBuffer *buffer);
+
+gboolean gst_aacparse_convert (GstBaseParse * parse,
+                               GstFormat src_format,
+                               gint64 src_value,
+                               GstFormat dest_format,
+                               gint64 * dest_value);
+
+gboolean gst_aacparse_is_seekable (GstBaseParse *parse);
+
+gboolean gst_aacparse_event (GstBaseParse *parse,
+                             GstEvent *event);
+
+#define _do_init(bla) \
+    GST_DEBUG_CATEGORY_INIT (gst_aacparse_debug, "aacparse", 0, \
+    "AAC audio stream parser");
+
+GST_BOILERPLATE_FULL (GstAacParse, gst_aacparse, GstBaseParse,
+                      GST_TYPE_BASE_PARSE, _do_init);
+
+
+/**
+ * gst_aacparse_base_init:
+ * @klass: #GstElementClass.
+ *
+ */
+static void
+gst_aacparse_base_init (gpointer klass)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+  GstElementDetails details = GST_ELEMENT_DETAILS ("AAC audio stream parser",
+      "Codec/Parser/Audio",
+      "Advanced Audio Coding parser",
+      "Stefan Kost <stefan.kost@nokia.com>");
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&sink_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&src_template));
+
+  gst_element_class_set_details (element_class, &details);
+}
+
+
+/**
+ * gst_aacparse_class_init:
+ * @klass: #GstAacParseClass.
+ *
+ */
+static void
+gst_aacparse_class_init (GstAacParseClass * klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
+
+  object_class->finalize = gst_aacparse_finalize;
+
+  parse_class->start         = GST_DEBUG_FUNCPTR (gst_aacparse_start);
+  parse_class->stop          = GST_DEBUG_FUNCPTR (gst_aacparse_stop);
+  parse_class->event         = GST_DEBUG_FUNCPTR (gst_aacparse_event);
+  parse_class->convert       = GST_DEBUG_FUNCPTR (gst_aacparse_convert);
+  parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_aacparse_sink_setcaps);
+  parse_class->is_seekable   = GST_DEBUG_FUNCPTR (gst_aacparse_is_seekable);
+  parse_class->parse_frame   = GST_DEBUG_FUNCPTR (gst_aacparse_parse_frame);
+  parse_class->check_valid_frame =
+      GST_DEBUG_FUNCPTR (gst_aacparse_check_valid_frame);
+}
+
+
+/**
+ * gst_aacparse_init:
+ * @aacparse: #GstAacParse.
+ * @klass: #GstAacParseClass.
+ *
+ */
+static void
+gst_aacparse_init (GstAacParse * aacparse, GstAacParseClass * klass)
+{
+  /* init rest */
+  gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 1024);
+  aacparse->ts = 0;
+  GST_DEBUG ("initialized");
+}
+
+
+/**
+ * gst_aacparse_finalize:
+ * @object:
+ *
+ */
+static void
+gst_aacparse_finalize (GObject * object)
+{
+  GstAacParse *aacparse;
+
+  aacparse = GST_AACPARSE (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+/**
+ * gst_aacparse_set_src_caps:
+ * @aacparse: #GstAacParse.
+ *
+ * Set source pad caps according to current knowledge about the
+ * audio stream.
+ *
+ * Returns: TRUE if caps were successfully set.
+ */
+static gboolean
+gst_aacparse_set_src_caps (GstAacParse * aacparse)
+{
+  GstCaps *src_caps = NULL;
+  gchar *caps_str = NULL;
+  gboolean res = FALSE;
+
+  src_caps = gst_caps_new_simple ("audio/mpeg",
+                                  "framed", G_TYPE_BOOLEAN, TRUE,
+                                  "mpegversion", G_TYPE_INT,
+                                      aacparse->mpegversion,
+                                  NULL);
+
+  caps_str = gst_caps_to_string (src_caps);
+  GST_DEBUG_OBJECT (aacparse, "setting srcpad caps: %s", caps_str);
+  g_free (caps_str);
+
+  gst_pad_use_fixed_caps (GST_BASE_PARSE (aacparse)->srcpad);
+  res = gst_pad_set_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
+  gst_pad_fixate_caps (GST_BASE_PARSE (aacparse)->srcpad, src_caps);
+  gst_caps_unref (src_caps);
+  return res;
+}
+
+
+/**
+ * gst_aacparse_sink_setcaps:
+ * @sinkpad: GstPad
+ * @caps: GstCaps
+ *
+ * Implementation of "set_sink_caps" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE on success.
+ */
+static gboolean
+gst_aacparse_sink_setcaps (GstBaseParse *parse,
+                           GstCaps *caps)
+{
+  GstAacParse *aacparse;
+  GstStructure *structure;
+  gchar *caps_str;
+
+  aacparse = GST_AACPARSE (parse);
+  structure = gst_caps_get_structure (caps, 0);
+  caps_str = gst_caps_to_string (caps);
+
+  GST_DEBUG_OBJECT (aacparse, "setcaps: %s", caps_str);
+  g_free (caps_str);
+
+  // This is needed at least in case of RTP
+  // Parses the codec_data information to get ObjectType,
+  // number of channels and samplerate
+  if (gst_structure_has_field (structure, "codec_data")) {
+
+    const GValue *value = gst_structure_get_value (structure, "codec_data");
+
+    if (value) {
+      GstBuffer *buf = gst_value_get_buffer (value);
+      const guint8 *buffer = GST_BUFFER_DATA (buf);
+      aacparse->object_type =  (buffer[0] & 0xf8) >> 3;
+      aacparse->sample_rate = ((buffer[0] & 0x07) << 1) |
+                              ((buffer[1] & 0x80) >> 7);
+      aacparse->channels =     (buffer[1] & 0x78) >> 3;
+      aacparse->header_type = DSPAAC_HEADER_NONE;
+      aacparse->mpegversion = 4;
+    }
+    else return FALSE;
+  }
+
+  return TRUE;
+}
+
+
+/**
+ * gst_aacparse_update_duration:
+ * @aacparse: #GstAacParse.
+ *
+ */
+static void
+gst_aacparse_update_duration (GstAacParse *aacparse)
+{
+  GstPad *peer;
+  GstBaseParse *parse;
+
+  parse = GST_BASE_PARSE (aacparse);
+
+  /* Cannot estimate duration. No data has been passed to us yet */
+  if (!aacparse->framecount || !aacparse->frames_per_sec) {
+    return;
+  }
+
+  // info->length = (int)((filelength_filestream(file)/(((info->bitrate*8)/1024)*16))*1000);
+
+  peer = gst_pad_get_peer (parse->sinkpad);
+  if (peer) {
+    GstFormat pformat = GST_FORMAT_BYTES;
+    guint64 bpf = aacparse->bytecount / aacparse->framecount;
+    gboolean qres = FALSE;
+    gint64 ptot;
+
+    qres = gst_pad_query_duration (peer, &pformat, &ptot);
+    gst_object_unref (GST_OBJECT (peer));
+    if (qres && bpf) {
+      gst_base_parse_set_duration (parse, GST_FORMAT_TIME,
+                                   AAC_FRAME_DURATION(aacparse) * ptot / bpf);
+    }
+  }
+}
+
+
+/**
+ * gst_aacparse_adts_get_frame_len:
+ * @data: block of data containing an ADTS header.
+ *
+ * This function calculates ADTS frame length from the given header.
+ *
+ * Returns: size of the ADTS frame.
+ */
+static inline guint
+gst_aacparse_adts_get_frame_len (const guint8 *data)
+{
+  return ((data[3] & 0x03) << 11) |
+          (data[4]         << 3)  |
+         ((data[5] & 0xe0) >> 5);
+}
+
+
+/**
+ * gst_aacparse_check_adts_frame:
+ * @aacparse: #GstAacParse.
+ * @data: Data to be checked.
+ * @avail: Amount of data passed.
+ * @framesize: If valid ADTS frame was found, this will be set to tell the
+ *             found frame size in bytes.
+ * @needed_data: If frame was not found, this may be set to tell how much
+ *               more data is needed in the next round to detect the frame
+ *               reliably. This may happen when a frame header candidate
+ *               is found but it cannot be guaranteed to be the header without
+ *               peeking the following data.
+ *
+ * Check if the given data contains contains ADTS frame. The algorithm
+ * will examine ADTS frame header and calculate the frame size. Also, another
+ * consecutive ADTS frame header need to be present after the found frame.
+ * Otherwise the data is not considered as a valid ADTS frame. However, this
+ * "extra check" is omitted when EOS has been received. In this case it is
+ * enough when data[0] contains a valid ADTS header.
+ *
+ * This function may set the #needed_data to indicate that a possible frame
+ * candidate has been found, but more data (#needed_data bytes) is needed to
+ * be absolutely sure. When this situation occurs, FALSE will be returned.
+ *
+ * When a valid frame is detected, this function will use
+ * gst_base_parse_set_min_frame_size() function from #GstBaseParse class
+ * to set the needed bytes for next frame.This way next data chunk is already
+ * of correct size.
+ *
+ * Returns: TRUE if the given data contains a valid ADTS header.
+ */
+static gboolean
+gst_aacparse_check_adts_frame (GstAacParse *aacparse,
+                               const guint8 *data,
+                               const guint avail,
+                               guint *framesize,
+                               guint *needed_data)
+{
+  if ((data[0] == 0xff) && ((data[1] & 0xf6) == 0xf0)) {
+    *framesize = gst_aacparse_adts_get_frame_len (data);
+
+    /* In EOS mode this is enough. No need to examine the data further */
+    if (aacparse->eos) {
+      return TRUE;
+    }
+
+    if (*framesize + ADTS_MAX_SIZE > avail) {
+      /* We have found a possible frame header candidate, but can't be
+         sure since we don't have enough data to check the next frame */
+      GST_DEBUG ("NEED MORE DATA: we need %d, available %d",
+                 *framesize + ADTS_MAX_SIZE, avail);
+      *needed_data = *framesize + ADTS_MAX_SIZE;
+      gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
+                                         *framesize + ADTS_MAX_SIZE);
+      return FALSE;
+    }
+
+    if ((data[*framesize] == 0xff) && ((data[*framesize+1] & 0xf6) == 0xf0)) {
+      guint nextlen = gst_aacparse_adts_get_frame_len (data + (*framesize));
+
+      GST_LOG ("ADTS frame found, len: %d bytes", *framesize);
+      gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse),
+                                         nextlen + ADTS_MAX_SIZE);
+      return TRUE;
+    }
+  }
+  aacparse->sync = FALSE;
+  return FALSE;
+}
+
+
+/**
+ * gst_aacparse_detect_stream:
+ * @aacparse: #GstAacParse.
+ * @data: A block of data that needs to be examined for stream characteristics.
+ * @avail: Size of the given datablock.
+ * @framesize: If valid stream was found, this will be set to tell the
+ *             first frame size in bytes.
+ * @skipsize: If valid stream was found, this will be set to tell the first
+ *            audio frame position within the given data.
+ *
+ * Examines the given piece of data and try to detect the format of it. It
+ * checks for "ADIF" header (in the beginning of the clip) and ADTS frame
+ * header. If the stream is detected, TRUE will be returned and #framesize
+ * is set to indicate the found frame size. Additionally, #skipsize might
+ * be set to indicate the number of bytes that need to be skipped, a.k.a. the
+ * position of the frame inside given data chunk.
+ *
+ * Returns: TRUE on success.
+ */
+static gboolean
+gst_aacparse_detect_stream (GstAacParse *aacparse,
+                            const guint8 *data,
+                            const guint avail,
+                            guint *framesize,
+                            gint *skipsize)
+{
+  gboolean found = FALSE;
+  guint need_data = 0;
+  guint i = 0;
+
+  GST_DEBUG_OBJECT (aacparse, "Parsing header data");
+
+  /* FIXME: No need to check for ADIF if we are not in the beginning of the
+            stream */
+
+  /* Can we even parse the header? */
+  if (avail < ADTS_MAX_SIZE) return FALSE;
+
+  for (i=0; i<avail-4; i++) {
+    if (((data[i] == 0xff) && ((data[i+1] & 0xf6) == 0xf0)) ||
+          strncmp ((char *) data+i, "ADIF", 4) == 0)
+    {
+      found = TRUE;
+
+      if (i) {
+        /* Trick: tell the parent class that we didn't find the frame yet,
+                  but make it skip 'i' amount of bytes. Next time we arrive
+                  here we have full frame in the beginning of the data. */
+        *skipsize = i;
+        return FALSE;
+      }
+      break;
+    }
+  }
+  if (!found) {
+    if (i) *skipsize = i;
+    return FALSE;
+  }
+
+  if (gst_aacparse_check_adts_frame (aacparse, data, avail,
+            framesize, &need_data))
+  {
+    gint sr_idx;
+    GST_INFO ("ADTS ID: %d, framesize: %d", (data[1] & 0x08)>>3, *framesize);
+
+    aacparse->header_type = DSPAAC_HEADER_ADTS;
+    sr_idx = (data[2] & 0x3c) >> 2;
+
+    aacparse->sample_rate = aac_sample_rates[sr_idx];
+    aacparse->mpegversion = (data[1] & 0x08) ? 2 : 4;
+    aacparse->object_type = (data[2] & 0xc0) >> 6;
+    aacparse->channels =   ((data[2] & 0x01) << 2) |
+                           ((data[3] & 0xc0) >> 6);
+    aacparse->bitrate =    ((data[5] & 0x1f) << 6) |
+                           ((data[6] & 0xfc) >> 2);
+
+    aacparse->frames_per_sec = aac_sample_rates[sr_idx] / 1024.f;
+
+    GST_DEBUG ("ADTS: samplerate %d, channels %d, bitrate %d, objtype %d, "
+        "fps %f", aacparse->sample_rate, aacparse->channels,
+        aacparse->bitrate, aacparse->object_type,
+        aacparse->frames_per_sec);
+
+    aacparse->sync = TRUE;
+    return TRUE;
+  }
+  else if (need_data) {
+    /* This tells the parent class not to skip any data */
+    *skipsize = 0;
+    return FALSE;
+  }
+
+  if (avail < ADIF_MAX_SIZE) return FALSE;
+
+  if (memcmp (data+i, "ADIF", 4) == 0) {
+    const guint8 *adif;
+    int skip_size = 0;
+    int bitstream_type;
+    int sr_idx;
+
+    aacparse->header_type = DSPAAC_HEADER_ADIF;
+    aacparse->mpegversion = 4;
+
+    // Skip the "ADIF" bytes
+    adif = data+i+4;
+
+    /* copyright string */
+    if(adif[0] & 0x80)
+      skip_size += 9; /* skip 9 bytes */
+
+    bitstream_type = adif[0 + skip_size] & 0x10;
+    aacparse->bitrate =
+        ((unsigned int)(adif[0 + skip_size] & 0x0f) << 19) |
+        ((unsigned int) adif[1 + skip_size]         << 11) |
+        ((unsigned int) adif[2 + skip_size]         << 3)  |
+        ((unsigned int) adif[3 + skip_size] & 0xe0);
+
+    /* CBR */
+    if (bitstream_type == 0) {
+#if 0
+      /* Buffer fullness parsing. Currently not needed... */
+      guint num_elems = 0;
+      guint fullness = 0;
+
+      num_elems = (adif[3 + skip_size] & 0x1e);
+      GST_INFO ("ADIF num_config_elems: %d", num_elems);
+
+      fullness = ((unsigned int) (adif[3 + skip_size] & 0x01) << 19) |
+                  ((unsigned int)  adif[4 + skip_size]         << 11) |
+                  ((unsigned int)  adif[5 + skip_size]         << 3) |
+                  ((unsigned int) (adif[6 + skip_size] & 0xe0) >> 5);
+
+      GST_INFO ("ADIF buffer fullness: %d", fullness);
+#endif
+      aacparse->object_type = ((adif[6 + skip_size] & 0x01) << 1) |
+                              ((adif[7 + skip_size] & 0x80) >> 7);
+      sr_idx =                 (adif[7 + skip_size] & 0x78) >> 3;
+    }
+    /* VBR */
+    else {
+      aacparse->object_type = (adif[4 + skip_size] & 0x18) >> 3;
+      sr_idx =               ((adif[4 + skip_size] & 0x07) << 1) |
+                             ((adif[5 + skip_size] & 0x80) >> 7);
+    }
+
+    /* FIXME: This gives totally wrong results. Duration calculation cannot
+              be based on this */
+    aacparse->sample_rate = aac_sample_rates[sr_idx];
+
+    aacparse->frames_per_sec = aac_sample_rates[sr_idx] / 1024.f;
+    GST_INFO ("ADIF fps: %f", aacparse->frames_per_sec);
+
+    // FIXME: Can we assume this?
+    aacparse->channels = 2;
+
+    GST_INFO ("ADIF: br=%d, samplerate=%d, objtype=%d",
+              aacparse->bitrate, aacparse->sample_rate,
+              aacparse->object_type);
+
+    gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), 512);
+
+    *framesize = avail;
+    aacparse->sync = TRUE;
+    return TRUE;
+  }
+
+  /* This should never happen */
+  return FALSE;
+}
+
+
+/**
+ * gst_aacparse_check_valid_frame:
+ * @parse: #GstBaseParse.
+ * @buffer: #GstBuffer.
+ * @framesize: If the buffer contains a valid frame, its size will be put here
+ * @skipsize: How much data parent class should skip in order to find the
+ *            frame header.
+ *
+ * Implementation of "check_valid_frame" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE if buffer contains a valid frame.
+ */
+gboolean gst_aacparse_check_valid_frame (GstBaseParse *parse,
+                                         GstBuffer *buffer,
+                                         guint *framesize,
+                                         gint *skipsize)
+{
+  const guint8 *data;
+  GstAacParse *aacparse;
+  guint needed_data = 1024;
+  gboolean ret = FALSE;
+
+  aacparse = GST_AACPARSE (parse);
+  data = GST_BUFFER_DATA (buffer);
+
+  if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) {
+    /* Discontinuous stream -> drop the sync */
+    aacparse->sync = FALSE;
+  }
+
+  if (aacparse->header_type == DSPAAC_HEADER_ADIF ||
+      aacparse->header_type == DSPAAC_HEADER_NONE)
+  {
+    /* There is nothing to parse */
+    *framesize = GST_BUFFER_SIZE (buffer);
+    ret = TRUE;
+  }
+
+  else if (aacparse->header_type == DSPAAC_HEADER_NOT_PARSED ||
+      aacparse->sync == FALSE)
+  {
+    ret = gst_aacparse_detect_stream (aacparse, data, GST_BUFFER_SIZE (buffer),
+                                      framesize, skipsize);
+  }
+  else if (aacparse->header_type == DSPAAC_HEADER_ADTS) {
+    ret = gst_aacparse_check_adts_frame (aacparse, data,
+                                         GST_BUFFER_SIZE (buffer),
+                                         framesize, &needed_data);
+  }
+
+  if (!ret) {
+    /* Increase the block size, we want to find the header by ourselves */
+    GST_DEBUG ("buffer didn't contain valid frame, skip = %d", *skipsize);
+    gst_base_parse_set_min_frame_size (GST_BASE_PARSE (aacparse), needed_data);
+  }
+  return ret;
+}
+
+
+/**
+ * gst_aacparse_parse_frame:
+ * @parse: #GstBaseParse.
+ * @buffer: #GstBuffer.
+ *
+ * Implementation of "parse_frame" vmethod in #GstBaseParse class.
+ *
+ * Returns: GST_FLOW_OK if frame was successfully parsed and can be pushed
+ *          forward. Otherwise appropriate error is returned.
+ */
+GstFlowReturn gst_aacparse_parse_frame (GstBaseParse *parse,
+                                        GstBuffer *buffer)
+{
+  GstAacParse *aacparse;
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  aacparse = GST_AACPARSE (parse);
+
+  if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) {
+    gint64 btime;
+    gboolean r = gst_aacparse_convert (parse, GST_FORMAT_BYTES,
+                                       GST_BUFFER_OFFSET (buffer),
+                                       GST_FORMAT_TIME, &btime);
+    if (r) {
+      /* FIXME: What to do if the conversion fails? */
+      aacparse->ts = btime;
+    }
+  }
+
+  GST_BUFFER_DURATION (buffer) = AAC_FRAME_DURATION (aacparse);
+  GST_BUFFER_TIMESTAMP (buffer) = aacparse->ts;
+
+  if (GST_CLOCK_TIME_IS_VALID (aacparse->ts))
+    aacparse->ts += GST_BUFFER_DURATION (buffer);
+
+  if (!(++aacparse->framecount % 50)) {
+    gst_aacparse_update_duration (aacparse);
+  }
+  aacparse->bytecount += GST_BUFFER_SIZE (buffer);
+
+  if (!aacparse->src_caps_set) {
+    if (!gst_aacparse_set_src_caps (aacparse)) {
+      /* If linking fails, we need to return appropriate error */
+      ret = GST_FLOW_NOT_LINKED;
+    }
+    aacparse->src_caps_set = TRUE;
+  }
+
+  gst_buffer_set_caps (buffer, GST_PAD_CAPS (parse->srcpad));
+  return ret;
+}
+
+
+/**
+ * gst_aacparse_start:
+ * @parse: #GstBaseParse.
+ *
+ * Implementation of "start" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE if startup succeeded.
+ */
+gboolean gst_aacparse_start (GstBaseParse *parse)
+{
+  GstAacParse *aacparse;
+
+  aacparse = GST_AACPARSE (parse);
+  GST_DEBUG ("start");
+  aacparse->src_caps_set = FALSE;
+  aacparse->framecount = 0;
+  aacparse->bytecount = 0;
+  aacparse->ts = 0;
+  aacparse->sync = FALSE;
+  aacparse->eos = FALSE;
+  return TRUE;
+}
+
+
+/**
+ * gst_aacparse_stop:
+ * @parse: #GstBaseParse.
+ *
+ * Implementation of "stop" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE is stopping succeeded.
+ */
+gboolean gst_aacparse_stop (GstBaseParse *parse)
+{
+  GstAacParse *aacparse;
+
+  aacparse = GST_AACPARSE (parse);
+  GST_DEBUG ("stop");
+  aacparse->ts = -1;
+  return TRUE;
+}
+
+
+/**
+ * gst_aacparse_event:
+ * @parse: #GstBaseParse.
+ * @event: #GstEvent.
+ *
+ * Implementation of "event" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE if the event was handled and can be dropped.
+ */
+gboolean gst_aacparse_event (GstBaseParse *parse,
+                             GstEvent *event)
+{
+  GstAacParse *aacparse;
+
+  aacparse = GST_AACPARSE (parse);
+  GST_DEBUG ("event");
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_EOS:
+      aacparse->eos = TRUE;
+      GST_DEBUG ("EOS event");
+      break;
+    default:
+      break;
+  }
+
+  return parent_class->event (parse, event);
+}
+
+
+/**
+ * gst_aacparse_convert:
+ * @parse: #GstBaseParse.
+ * @src_format: #GstFormat describing the source format.
+ * @src_value: Source value to be converted.
+ * @dest_format: #GstFormat defining the converted format.
+ * @dest_value: Pointer where the conversion result will be put.
+ *
+ * Implementation of "convert" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE if conversion was successful.
+ */
+gboolean gst_aacparse_convert (GstBaseParse * parse,
+                               GstFormat src_format,
+                               gint64 src_value,
+                               GstFormat dest_format,
+                               gint64 * dest_value)
+{
+  gboolean ret = FALSE;
+  GstAacParse *aacparse;
+  gfloat bpf;
+
+  aacparse = GST_AACPARSE (parse);
+
+  /* We are not able to do any estimations until some data has been passed */
+  if (!aacparse->framecount)
+    return FALSE;
+
+  bpf = (gfloat) aacparse->bytecount / aacparse->framecount;
+
+  if (src_format == GST_FORMAT_BYTES) {
+    if (dest_format == GST_FORMAT_TIME) {
+      /* BYTES -> TIME conversion */
+      GST_DEBUG ("converting bytes -> time");
+
+      if (aacparse->framecount && aacparse->frames_per_sec) {
+        *dest_value = AAC_FRAME_DURATION (aacparse) * src_value / bpf;
+        GST_DEBUG ("conversion result: %lld ms", *dest_value / GST_MSECOND);
+        ret = TRUE;
+      }
+    }
+    else if (dest_format == GST_FORMAT_BYTES) {
+      /* Parent class may ask us to convert from BYTES to BYTES */
+      *dest_value = src_value;
+      ret = TRUE;
+    }
+  }
+  else if (src_format == GST_FORMAT_TIME) {
+    GST_DEBUG ("converting time -> bytes");
+    if (dest_format == GST_FORMAT_BYTES) {
+      if (aacparse->framecount && aacparse->frames_per_sec) {
+        *dest_value = bpf * src_value / AAC_FRAME_DURATION (aacparse);
+        GST_DEBUG ("time %lld ms in bytes = %lld", src_value / GST_MSECOND, *dest_value);
+        ret = TRUE;
+      }
+    }
+  }
+  else if (src_format == GST_FORMAT_DEFAULT) {
+    /* DEFAULT == frame-based */
+    if (dest_format == GST_FORMAT_TIME && aacparse->frames_per_sec) {
+      *dest_value = src_value * AAC_FRAME_DURATION (aacparse);
+      ret = TRUE;
+    }
+    else if (dest_format == GST_FORMAT_BYTES) {
+    }
+  }
+
+  return ret;
+}
+
+
+/**
+ * gst_aacparse_is_seekable:
+ * @parse: #GstBaseParse.
+ *
+ * Implementation of "is_seekable" vmethod in #GstBaseParse class.
+ *
+ * Returns: TRUE if the current stream is seekable.
+ */
+gboolean gst_aacparse_is_seekable (GstBaseParse *parse)
+{
+  GstAacParse *aacparse;
+
+  aacparse = GST_AACPARSE (parse);
+  GST_DEBUG_OBJECT (aacparse, "IS_SEEKABLE: %d", aacparse->header_type != DSPAAC_HEADER_ADIF);
+
+  /* Not seekable if ADIF header is found */
+  return (aacparse->header_type != DSPAAC_HEADER_ADIF);
+}
+
+
+/**
+ * plugin_init:
+ * @plugin: GstPlugin
+ *
+ * Returns: TRUE on success.
+ */
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  return gst_element_register (plugin, "aacparse",
+      GST_RANK_PRIMARY+1, GST_TYPE_AACPARSE);
+}
+
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "aacparse",
+    "Advanced Audio Coding Parser",
+    plugin_init, VERSION, GST_LICENSE_UNKNOWN, GST_PACKAGE_NAME,
+    GST_PACKAGE_ORIGIN);
Index: gst/aacparse/gstaacparse.h
===================================================================
RCS file: gst/aacparse/gstaacparse.h
diff -N gst/aacparse/gstaacparse.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gst/aacparse/gstaacparse.h	15 Sep 2008 13:02:44 -0000
@@ -0,0 +1,119 @@
+/* GStreamer AAC parser
+ * Copyright (C) 2008 Nokia Corporation. All rights reserved.
+ *
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GST_AACPARSE_H__
+#define __GST_AACPARSE_H__
+
+#include <gst/gst.h>
+#include "gstbaseparse.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_AACPARSE \
+  (gst_aacparse_get_type())
+#define GST_AACPARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_AACPARSE, GstAacParse))
+#define GST_AACPARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_AACPARSE, GstAacParseClass))
+#define GST_IS_AACPARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_AACPARSE))
+#define GST_IS_AACPARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_AACPARSE))
+
+
+/**
+ * GstAacHeaderType:
+ * @DSPAAC_HEADER_NOT_PARSED: Header not parsed yet.
+ * @DSPAAC_HEADER_UNKNOWN: Unknown (not recognized) header.
+ * @DSPAAC_HEADER_ADIF: ADIF header found.
+ * @DSPAAC_HEADER_ADTS: ADTS header found.
+ * @DSPAAC_HEADER_NONE: Raw stream, no header.
+ *
+ * Type header enumeration set in #header_type.
+ */
+typedef enum {
+  DSPAAC_HEADER_NOT_PARSED,
+  DSPAAC_HEADER_UNKNOWN,
+  DSPAAC_HEADER_ADIF,
+  DSPAAC_HEADER_ADTS,
+  DSPAAC_HEADER_NONE
+} GstAacHeaderType;
+
+
+typedef struct _GstAacParse GstAacParse;
+typedef struct _GstAacParseClass GstAacParseClass;
+
+/**
+ * GstAacParse:
+ * @element: the parent element.
+ * @object_type: AAC object type of the stream.
+ * @bitrate:  Current media bitrate.
+ * @sample_rate: Current media samplerate.
+ * @channels: Current media channel count.
+ * @frames_per_sec: FPS value of the current stream.
+ * @header_type: #GstAacHeaderType indicating the current stream type.
+ * @framecount: The amount of frames that has been processed this far.
+ * @bytecount: The amount of bytes that has been processed this far.
+ * @sync: Tells whether the parser is in sync (a.k.a. not searching for header)
+ * @eos: End-of-Stream indicator. Set when EOS event arrives.
+ * @duration: Duration of the current stream.
+ * @ts: Current stream timestamp.
+ *
+ * The opaque GstAacParse data structure.
+ */
+struct _GstAacParse {
+  GstBaseParse element;
+
+  /* Stream type -related info */
+  gint           object_type;
+  gint           bitrate;
+  gint           sample_rate;
+  gint           channels;
+  gint           mpegversion;
+  gfloat         frames_per_sec;
+
+  GstAacHeaderType header_type;
+
+  guint64 framecount;
+  guint64 bytecount;
+  gboolean src_caps_set;
+  gboolean sync;
+  gboolean eos;
+
+  GstClockTime duration;
+  GstClockTime ts;
+};
+
+/**
+ * GstAacParseClass:
+ * @parent_class: Element parent class.
+ *
+ * The opaque GstAacParseClass data structure.
+ */
+struct _GstAacParseClass {
+  GstBaseParseClass parent_class;
+};
+
+GType gst_aacparse_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GST_AACPARSE_H__ */
Index: gst/aacparse/gstbaseparse.c
===================================================================
RCS file: gst/aacparse/gstbaseparse.c
diff -N gst/aacparse/gstbaseparse.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gst/aacparse/gstbaseparse.c	15 Sep 2008 13:02:44 -0000
@@ -0,0 +1,1751 @@
+/* GStreamer
+ * Copyright (C) 2008 Nokia Corporation. All rights reserved.
+ *   Contact: Stefan Kost <stefan.kost@nokia.com>
+ * Copyright (C) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:gstbaseparse
+ * @short_description: Base class for stream parsers
+ * @see_also: #GstBaseTransform
+ *
+ * This base class is for parser elements that process data and splits it 
+ * into separate audio/video/whatever frames.
+ *
+ * It provides for:
+ * <itemizedlist>
+ *   <listitem><para>One sinkpad and one srcpad</para></listitem>
+ *   <listitem><para>Handles state changes</para></listitem>
+ *   <listitem><para>Does flushing</para></listitem>
+ *   <listitem><para>Push mode</para></listitem>
+ *   <listitem><para>Pull mode</para></listitem>
+ *   <listitem><para>Handles events (NEWSEGMENT/EOS/FLUSH)</para></listitem>
+ *   <listitem><para>Handles seeking in both modes</para></listitem>
+ *   <listitem><para>
+ *        Handles POSITION/DURATION/SEEKING/FORMAT/CONVERT queries
+ *   </para></listitem>
+ * </itemizedlist>
+ *
+ * The purpose of this base class is to provide a basic functionality of
+ * a parser and share a lot of rather complex code.
+ *
+ * Description of the parsing mechanism:
+ * <orderedlist>
+ * <listitem>
+ *   <itemizedlist><title>Set-up phase</title>
+ *   <listitem><para>
+ *     GstBaseParse class calls @set_sink_caps to inform the subclass about
+ *     incoming sinkpad caps. Subclass should set the srcpad caps accordingly.
+ *   </para></listitem>
+ *   <listitem><para>
+ *     GstBaseParse calls @start to inform subclass that data processing is
+ *     about to start now.
+ *   </para></listitem>
+ *   <listitem><para>
+ *      At least in this point subclass needs to tell the GstBaseParse class
+ *      how big data chunks it wants to receive (min_frame_size). It can do 
+ *      this with @gst_base_parse_set_min_frame_size.
+ *   </para></listitem>
+ *   <listitem><para>
+ *      GstBaseParse class sets up appropriate data passing mode (pull/push)
+ *      and starts to process the data.
+ *   </para></listitem>
+ *   </itemizedlist>
+ * </listitem>
+ * <listitem>
+ *   <itemizedlist>
+ *   <title>Parsing phase</title>
+ *     <listitem><para>
+ *       GstBaseParse gathers at least min_frame_size bytes of data either 
+ *       by pulling it from upstream or collecting buffers into internal
+ *       #GstAdapter.
+ *     </para></listitem>
+ *     <listitem><para>
+ *       A buffer of min_frame_size bytes is passed to subclass with
+ *       @check_valid_frame. Subclass checks the contents and returns TRUE
+ *       if the buffer contains a valid frame. It also needs to set the
+ *       @framesize according to the detected frame size. If buffer didn't
+ *       contain a valid frame, this call must return FALSE and optionally
+ *       set the @skipsize value to inform base class that how many bytes
+ *       it needs to skip in order to find a valid frame. The passed buffer
+ *       is read-only.
+ *     </para></listitem>
+ *     <listitem><para>
+ *       After valid frame is found, it will be passed again to subclass with
+ *       @parse_frame call. Now subclass is responsible for parsing the
+ *       frame contents and setting the buffer timestamp, duration and caps.
+ *     </para></listitem>
+ *     <listitem><para>
+ *       Finally the buffer can be pushed downstream and parsing loop starts
+ *       over again.
+ *     </para></listitem>
+ *     <listitem><para>
+ *       During the parsing process GstBaseClass will handle both srcpad and
+ *       sinkpad events. They will be passed to subclass if @event or
+ *       @src_event callbacks have been provided.
+ *     </para></listitem>
+ *   </itemizedlist>
+ * </listitem>
+ * <listitem>
+ *   <itemizedlist><title>Shutdown phase</title>
+ *   <listitem><para>
+ *     GstBaseParse class calls @stop to inform the subclass that data
+ *     parsing will be stopped.
+ *   </para></listitem>
+ *   </itemizedlist>
+ * </listitem>
+ * </orderedlist>
+ *
+ * Subclass is responsible for providing pad template caps for
+ * source and sink pads. The pads need to be named "sink" and "src". It also 
+ * needs to set the fixed caps on srcpad, when the format is ensured (e.g. 
+ * when base class calls subclass' @set_sink_caps function).
+ *
+ * This base class uses GST_FORMAT_DEFAULT as a meaning of frames. So,
+ * subclass conversion routine needs to know that conversion from
+ * GST_FORMAT_TIME to GST_FORMAT_DEFAULT must return the
+ * frame number that can be found from the given byte position.
+ *
+ * GstBaseParse uses subclasses conversion methods also for seeking. If
+ * subclass doesn't provide @convert function, seeking will get disabled.
+ *
+ * Subclass @start and @stop functions will be called to inform the beginning
+ * and end of data processing.
+ *
+ * Things that subclass need to take care of:
+ * <itemizedlist>
+ *   <listitem><para>Provide pad templates</para></listitem>
+ *   <listitem><para>
+ *      Fixate the source pad caps when appropriate
+ *   </para></listitem>
+ *   <listitem><para>
+ *      Inform base class how big data chunks should be retrieved. This is
+ *      done with @gst_base_parse_set_min_frame_size function.
+ *   </para></listitem>
+ *   <listitem><para>
+ *      Examine data chunks passed to subclass with @check_valid_frame
+ *      and tell if they contain a valid frame
+ *   </para></listitem>
+ *   <listitem><para>
+ *      Set the caps and timestamp to frame that is passed to subclass with
+ *      @parse_frame function.
+ *   </para></listitem>
+ *   <listitem><para>Provide conversion functions</para></listitem>
+ *   <listitem><para>
+ *      Update the duration information with @gst_base_parse_set_duration
+ *   </para></listitem>
+ * </itemizedlist>
+ *
+ */
+
+/* TODO:
+ *  - Allow sending NEWSEGMENT event after handling the next frame
+ *  - Timestamp tracking and setting
+ *  - Allow dropping of frames outside the segment
+ *  - Send queries upstream
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "gstbaseparse.h"
+
+GST_DEBUG_CATEGORY_STATIC (gst_base_parse_debug);
+#define GST_CAT_DEFAULT gst_base_parse_debug
+
+/* Supported formats */
+static GstFormat fmtlist[] = {
+  GST_FORMAT_DEFAULT,
+  GST_FORMAT_BYTES,
+  GST_FORMAT_TIME,
+  0
+};
+
+#define GST_BASE_PARSE_GET_PRIVATE(obj)  \
+    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_PARSE, GstBaseParsePrivate))
+
+struct _GstBaseParsePrivate
+{
+  GstActivateMode pad_mode;
+
+  gint64 duration;
+  GstFormat duration_fmt;
+
+  guint min_frame_size;
+
+  gboolean discont;
+  gboolean flushing;
+
+  gint64 offset;
+  gint64 pending_offset;
+
+  GList *pending_events;
+
+  GstBuffer *cache;
+};
+
+struct _GstBaseParseClassPrivate
+{
+  gpointer _padding;
+};
+
+static GstElementClass *parent_class = NULL;
+
+static void gst_base_parse_base_init (gpointer g_class);
+static void gst_base_parse_base_finalize (gpointer g_class);
+static void gst_base_parse_class_init (GstBaseParseClass * klass);
+static void gst_base_parse_init (GstBaseParse * parse,
+    GstBaseParseClass * klass);
+
+GType
+gst_base_parse_get_type (void)
+{
+  static GType base_parse_type = 0;
+
+  if (!base_parse_type) {
+    static const GTypeInfo base_parse_info = {
+      sizeof (GstBaseParseClass),
+      (GBaseInitFunc) gst_base_parse_base_init,
+      (GBaseFinalizeFunc) gst_base_parse_base_finalize,
+      (GClassInitFunc) gst_base_parse_class_init,
+      NULL,
+      NULL,
+      sizeof (GstBaseParse),
+      0,
+      (GInstanceInitFunc) gst_base_parse_init,
+    };
+
+    base_parse_type = g_type_register_static (GST_TYPE_ELEMENT,
+        "GstAacBaseParse", &base_parse_info, G_TYPE_FLAG_ABSTRACT);
+  }
+  return base_parse_type;
+}
+
+static void gst_base_parse_finalize (GObject * object);
+
+static gboolean gst_base_parse_sink_activate (GstPad * sinkpad);
+static gboolean gst_base_parse_sink_activate_push (GstPad * pad,
+    gboolean active);
+static gboolean gst_base_parse_sink_activate_pull (GstPad * pad,
+    gboolean active);
+static gboolean gst_base_parse_handle_seek (GstBaseParse * parse,
+    GstEvent * event);
+
+static gboolean gst_base_parse_src_event (GstPad * pad, GstEvent * event);
+static gboolean gst_base_parse_sink_event (GstPad * pad, GstEvent * event);
+static gboolean gst_base_parse_query (GstPad * pad, GstQuery * query);
+static gboolean gst_base_parse_sink_setcaps (GstPad * pad, GstCaps * caps);
+static const GstQueryType * gst_base_parse_get_querytypes (GstPad * pad);
+
+static GstFlowReturn gst_base_parse_chain (GstPad * pad, GstBuffer * buffer);
+static void gst_base_parse_loop (GstPad * pad);
+
+static gboolean gst_base_parse_check_frame (GstBaseParse *parse,
+    GstBuffer *buffer, guint *framesize, gint *skipsize);
+
+static gboolean gst_base_parse_parse_frame (GstBaseParse *parse,
+    GstBuffer *buffer);
+
+static gboolean gst_base_parse_sink_eventfunc (GstBaseParse * parse,
+    GstEvent * event);
+
+static gboolean gst_base_parse_src_eventfunc (GstBaseParse * parse,
+    GstEvent * event);
+
+static gboolean gst_base_parse_is_seekable (GstBaseParse * parse);
+
+static void gst_base_parse_drain (GstBaseParse *parse);
+
+static void
+gst_base_parse_base_init (gpointer g_class)
+{
+  GstBaseParseClass *klass = GST_BASE_PARSE_CLASS (g_class);
+  GstBaseParseClassPrivate *priv;
+
+  GST_DEBUG_CATEGORY_INIT (gst_base_parse_debug, "aacbaseparse", 0,
+      "baseparse element");
+
+  /* TODO: Remove this once GObject supports class private data */
+  priv = g_slice_new0 (GstBaseParseClassPrivate);
+  if (klass->priv)
+    memcpy (priv, klass->priv, sizeof (GstBaseParseClassPrivate));
+  klass->priv = priv;
+}
+
+static void
+gst_base_parse_base_finalize (gpointer g_class)
+{
+  GstBaseParseClass *klass = GST_BASE_PARSE_CLASS (g_class);
+  
+  g_slice_free (GstBaseParseClassPrivate, klass->priv);
+  klass->priv = NULL;
+}
+
+static void
+gst_base_parse_finalize (GObject * object)
+{
+  GstBaseParse *parse  = GST_BASE_PARSE (object);
+
+  g_mutex_free (parse->parse_lock);
+  g_object_unref (parse->adapter);
+
+  if (parse->pending_segment) {
+    gst_event_replace (&parse->pending_segment, NULL);
+  }
+  if (parse->close_segment) {
+    gst_event_replace (&parse->close_segment, NULL);
+  }
+
+  if (parse->priv->cache) {
+    gst_buffer_unref (parse->priv->cache);
+    parse->priv->cache = NULL;
+  }
+
+  g_list_foreach (parse->priv->pending_events, (GFunc) gst_mini_object_unref, NULL);
+  g_list_free (parse->priv->pending_events);
+  parse->priv->pending_events = NULL;
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gst_base_parse_class_init (GstBaseParseClass * klass)
+{
+  GObjectClass *gobject_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  g_type_class_add_private (klass, sizeof (GstBaseParsePrivate));
+  parent_class = g_type_class_peek_parent (klass);
+  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_base_parse_finalize);
+
+  /* Default handlers */
+  klass->check_valid_frame = gst_base_parse_check_frame;
+  klass->parse_frame = gst_base_parse_parse_frame;
+  klass->event = gst_base_parse_sink_eventfunc;
+  klass->src_event = gst_base_parse_src_eventfunc;
+  klass->is_seekable = gst_base_parse_is_seekable;
+}
+
+static void
+gst_base_parse_init (GstBaseParse * parse,
+    GstBaseParseClass * bclass)
+{
+  GstPadTemplate *pad_template;
+
+  GST_DEBUG_OBJECT (parse, "gst_base_parse_init");
+
+  parse->priv = GST_BASE_PARSE_GET_PRIVATE (parse);
+
+  pad_template =
+      gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "sink");
+  g_return_if_fail (pad_template != NULL);
+  parse->sinkpad = gst_pad_new_from_template (pad_template, "sink");
+  gst_pad_set_event_function (parse->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_sink_event));
+  gst_pad_set_setcaps_function (parse->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_sink_setcaps));
+  gst_pad_set_chain_function (parse->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_chain));
+  gst_pad_set_activate_function (parse->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate));
+  gst_pad_set_activatepush_function (parse->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate_push));
+  gst_pad_set_activatepull_function (parse->sinkpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_sink_activate_pull));
+  gst_element_add_pad (GST_ELEMENT (parse), parse->sinkpad);
+
+  GST_DEBUG_OBJECT (parse, "sinkpad created");
+
+  pad_template =
+      gst_element_class_get_pad_template (GST_ELEMENT_CLASS (bclass), "src");
+  g_return_if_fail (pad_template != NULL);
+  parse->srcpad = gst_pad_new_from_template (pad_template, "src");
+  gst_pad_set_event_function (parse->srcpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_src_event));
+  gst_pad_set_query_type_function (parse->srcpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_get_querytypes));
+  gst_pad_set_query_function (parse->srcpad,
+      GST_DEBUG_FUNCPTR (gst_base_parse_query));
+  gst_element_add_pad (GST_ELEMENT (parse), parse->srcpad);
+  GST_DEBUG_OBJECT (parse, "src created");
+
+  parse->parse_lock = g_mutex_new ();
+  parse->adapter = gst_adapter_new ();
+  parse->pending_segment = NULL;
+  parse->close_segment = NULL;
+
+  parse->priv->pad_mode = GST_ACTIVATE_NONE;
+  parse->priv->duration = -1;
+  parse->priv->min_frame_size = 1;
+  parse->priv->discont = FALSE;
+  parse->priv->flushing = FALSE;
+  parse->priv->offset = 0;
+  GST_DEBUG_OBJECT (parse, "init ok");
+}
+
+
+
+/**
+ * gst_base_parse_check_frame:
+ * @parse: #GstBaseParse.
+ * @buffer: GstBuffer.
+ * @framesize: This will be set to tell the found frame size in bytes.
+ * @skipsize: Output parameter that tells how much data needs to be skipped
+ *            in order to find the following frame header.
+ *
+ * Default callback for check_valid_frame.
+ * 
+ * Returns: Always TRUE.
+ */
+static gboolean
+gst_base_parse_check_frame (GstBaseParse *parse,
+                            GstBuffer *buffer,
+                            guint *framesize,
+                            gint *skipsize)
+{
+  *framesize = GST_BUFFER_SIZE (buffer);
+  *skipsize = 0;
+  return TRUE;
+}
+
+
+/**
+ * gst_base_parse_parse_frame:
+ * @parse: #GstBaseParse.
+ * @buffer: #GstBuffer.
+ *
+ * Default callback for parse_frame.
+ */
+static gboolean
+gst_base_parse_parse_frame (GstBaseParse *parse, GstBuffer *buffer)
+{
+  /* FIXME: Could we even _try_ to do something clever here? */
+  GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE;
+  GST_BUFFER_DURATION (buffer) = GST_CLOCK_TIME_NONE;
+  return TRUE;
+}
+
+
+/**
+ * gst_base_parse_bytepos_to_time:
+ * @parse: #GstBaseParse.
+ * @bytepos: Position (in bytes) to be converted.
+ * @pos_in_time: #GstClockTime pointer where the result is set.
+ *
+ * Convert given byte position into #GstClockTime format.
+ * 
+ * Returns: TRUE if conversion succeeded.
+ */
+static gboolean
+gst_base_parse_bytepos_to_time (GstBaseParse *parse, gint64 bytepos,
+                                GstClockTime *pos_in_time)
+{
+  GstBaseParseClass *klass;
+  gboolean res = FALSE;
+
+  klass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  if (klass->convert) {
+    res = klass->convert (parse, GST_FORMAT_BYTES, bytepos,
+                          GST_FORMAT_TIME, (gint64 *) pos_in_time);
+  }
+  return res;
+}
+
+
+/**
+ * gst_base_parse_sink_event:
+ * @pad: #GstPad that received the event.
+ * @event: #GstEvent to be handled.
+ *
+ * Handler for sink pad events.
+ *
+ * Returns: TRUE if the event was handled.
+ */
+static gboolean
+gst_base_parse_sink_event (GstPad * pad, GstEvent * event)
+{
+  GstBaseParse *parse;
+  GstBaseParseClass *bclass;
+  gboolean handled = FALSE;
+  gboolean ret = TRUE;
+
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
+  bclass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  GST_DEBUG_OBJECT (parse, "handling event %d", GST_EVENT_TYPE (event));
+
+  /* Cache all events except EOS, NEWSEGMENT and FLUSH_STOP if we have a
+   * pending segment */
+  if (parse->pending_segment && GST_EVENT_TYPE (event) != GST_EVENT_EOS
+      && GST_EVENT_TYPE (event) != GST_EVENT_NEWSEGMENT
+      && GST_EVENT_TYPE (event) != GST_EVENT_FLUSH_START
+      && GST_EVENT_TYPE (event) != GST_EVENT_FLUSH_STOP) {
+    parse->priv->pending_events = g_list_append (parse->priv->pending_events, event);
+    ret = TRUE;
+  } else {
+
+    if (bclass->event)
+      handled = bclass->event (parse, event);
+
+    if (!handled)
+      ret = gst_pad_event_default (pad, event);
+  }
+
+  gst_object_unref (parse);
+  GST_DEBUG_OBJECT (parse, "event handled");
+  return ret;
+}
+
+
+/**
+ * gst_base_parse_sink_eventfunc:
+ * @parse: #GstBaseParse.
+ * @event: #GstEvent to be handled.
+ *
+ * Element-level event handler function.
+ *
+ * Returns: TRUE if the event was handled and not need forwarding.
+ */
+static gboolean
+gst_base_parse_sink_eventfunc (GstBaseParse * parse, GstEvent * event)
+{
+  gboolean handled = FALSE;
+  GstEvent **eventp;
+
+  switch (GST_EVENT_TYPE (event))
+  {
+    case GST_EVENT_NEWSEGMENT:
+    {
+      gdouble rate, applied_rate;
+      GstFormat format;
+      gint64 start, stop, pos;
+      gboolean update;
+
+      gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
+                                        &format, &start, &stop, &pos);
+
+
+      if (format == GST_FORMAT_BYTES) {
+        GstClockTime seg_start, seg_stop, seg_pos;
+
+        /* stop time is allowed to be open-ended, but not start & pos */
+        seg_stop = GST_CLOCK_TIME_NONE;
+        parse->priv->pending_offset = pos;
+
+        if (gst_base_parse_bytepos_to_time (parse, start, &seg_start) &&
+            gst_base_parse_bytepos_to_time (parse, pos, &seg_pos))
+        {
+          gst_event_unref (event);
+          event = gst_event_new_new_segment_full (update, rate, applied_rate,
+              GST_FORMAT_TIME, seg_start, seg_stop, seg_pos);
+          format = GST_FORMAT_TIME;
+          GST_DEBUG_OBJECT (parse, "Converted incoming segment to TIME. "
+              "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
+                  ", pos = %" GST_TIME_FORMAT, GST_TIME_ARGS (seg_start),
+                  GST_TIME_ARGS (seg_stop), GST_TIME_ARGS (seg_pos));
+        }
+      }
+
+      if (format != GST_FORMAT_TIME) {
+        /* Unknown incoming segment format. Output a default open-ended 
+        * TIME segment */
+        gst_event_unref (event);
+        event = gst_event_new_new_segment_full (update, rate, applied_rate,
+            GST_FORMAT_TIME, 0, GST_CLOCK_TIME_NONE, 0);
+      }
+
+      gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
+                                        &format, &start, &stop, &pos);
+
+      gst_segment_set_newsegment_full (&parse->segment, update, rate,
+                                       applied_rate, format, start, stop, pos);
+
+      GST_DEBUG_OBJECT (parse, "Created newseg rate %g, applied rate %g, "
+          "format %d, start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
+          ", pos = %" GST_TIME_FORMAT, rate, applied_rate, format,
+          GST_TIME_ARGS (start), GST_TIME_ARGS (stop), GST_TIME_ARGS (pos));
+
+      /* save the segment for later, right before we push a new buffer so that
+       * the caps are fixed and the next linked element can receive
+       * the segment. */
+      eventp = &parse->pending_segment;
+      gst_event_replace (eventp, event);
+      gst_event_unref (event);
+      handled = TRUE;
+      break;
+    }
+
+    case GST_EVENT_FLUSH_START:
+      parse->priv->flushing = TRUE;
+      /* Wait for _chain() to exit by taking the srcpad STREAM_LOCK */
+      GST_PAD_STREAM_LOCK (parse->srcpad);
+      handled = gst_pad_push_event (parse->srcpad, event);
+      GST_PAD_STREAM_UNLOCK (parse->srcpad);
+      break;
+
+    case GST_EVENT_FLUSH_STOP:
+      gst_adapter_clear (parse->adapter);
+      parse->priv->flushing = FALSE;
+      parse->priv->discont = TRUE;
+      break;
+
+    case GST_EVENT_EOS:
+      gst_base_parse_drain (parse);
+      break;
+
+    default:
+      break;
+  }
+
+  return handled;
+}
+
+
+/**
+ * gst_base_parse_src_event:
+ * @pad: #GstPad that received the event.
+ * @event: #GstEvent that was received.
+ *
+ * Handler for source pad events.
+ *
+ * Returns: TRUE if the event was handled.
+ */
+static gboolean
+gst_base_parse_src_event (GstPad * pad, GstEvent * event)
+{
+  GstBaseParse *parse;
+  GstBaseParseClass *bclass;
+  gboolean handled = FALSE;
+  gboolean ret = TRUE;
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
+  bclass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  GST_DEBUG_OBJECT (parse, "event %d, %s", GST_EVENT_TYPE (event),
+             GST_EVENT_TYPE_NAME (event));
+
+  if (bclass->src_event)
+    handled = bclass->src_event (parse, event);
+
+  if (!handled)
+    ret = gst_pad_event_default (pad, event);
+
+  gst_object_unref (parse);
+  return ret;
+}
+
+
+/**
+ * gst_base_parse_src_eventfunc:
+ * @parse: #GstBaseParse.
+ * @event: #GstEvent that was received.
+ *
+ * Default srcpad event handler.
+ *
+ * Returns: TRUE if the event was handled and can be dropped.
+ */
+static gboolean
+gst_base_parse_src_eventfunc (GstBaseParse * parse, GstEvent * event)
+{
+  gboolean handled = FALSE;
+  GstBaseParseClass *bclass;
+
+  bclass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_SEEK:
+    {
+      if (bclass->is_seekable (parse)) {
+        handled = gst_base_parse_handle_seek (parse, event);
+        gst_event_unref (event);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return handled;
+}
+
+
+/**
+ * gst_base_parse_is_seekable:
+ * @parse: #GstBaseParse.
+ *
+ * Default handler for is_seekable.
+ *
+ * Returns: Always TRUE.
+ */
+static gboolean
+gst_base_parse_is_seekable (GstBaseParse * parse)
+{
+  return TRUE;
+}
+
+
+/**
+ * gst_base_parse_handle_and_push_buffer:
+ * @parse: #GstBaseParse.
+ * @klass: #GstBaseParseClass.
+ * @buffer: #GstBuffer.
+ *
+ * Parses the frame from given buffer and pushes it forward. Also performs
+ * timestamp handling and checks the segment limits.
+ *
+ * This is called with srcpad STREAM_LOCK held.
+ *
+ * Returns: #GstFlowReturn
+ */
+static GstFlowReturn
+gst_base_parse_handle_and_push_buffer (GstBaseParse *parse,
+                                       GstBaseParseClass *klass,
+                                       GstBuffer *buffer)
+{
+  GstFlowReturn ret;
+  GstClockTime last_stop = GST_CLOCK_TIME_NONE;
+
+  if (parse->priv->discont) {
+    GST_DEBUG_OBJECT (parse, "marking DISCONT");
+    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
+    parse->priv->discont = FALSE;
+  }
+
+  ret = klass->parse_frame (parse, buffer);
+
+  /* FIXME: Check the output buffer for any missing metadata,
+   *        keep track of timestamp and calculate everything possible
+   *        if not set already */
+
+  if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer))
+    last_stop = GST_BUFFER_TIMESTAMP (buffer);
+  if (last_stop != GST_CLOCK_TIME_NONE && GST_BUFFER_DURATION_IS_VALID (buffer))
+    last_stop += GST_BUFFER_DURATION (buffer);
+
+  gst_buffer_set_caps (buffer, GST_PAD_CAPS (parse->srcpad));
+
+  /* TODO: Add to seek table */
+
+  if (ret == GST_FLOW_OK) {
+    if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) && 
+        GST_CLOCK_TIME_IS_VALID (parse->segment.stop) &&
+        GST_BUFFER_TIMESTAMP (buffer) > parse->segment.stop) {
+      GST_LOG_OBJECT (parse, "Dropped frame, after segment");
+      gst_buffer_unref (buffer);
+    } else if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer) && 
+        GST_BUFFER_DURATION_IS_VALID (buffer) &&
+        GST_CLOCK_TIME_IS_VALID (parse->segment.start) &&
+        GST_BUFFER_TIMESTAMP (buffer) + GST_BUFFER_DURATION_IS_VALID (buffer)
+            < parse->segment.start) {
+      /* FIXME: subclass needs way to override the start as downstream might
+       * need frames before for proper decoding */
+      GST_LOG_OBJECT (parse, "Dropped frame, before segment");
+      gst_buffer_unref (buffer);
+    } else {
+      ret = gst_pad_push (parse->srcpad, buffer);
+      GST_LOG_OBJECT (parse, "frame (%d bytes) pushed: %d", GST_BUFFER_SIZE (buffer), ret);
+    }
+  }
+  else {
+    gst_buffer_unref (buffer);
+  }
+
+  /* Update current running segment position */
+  if (ret == GST_FLOW_OK && last_stop != GST_CLOCK_TIME_NONE)
+    gst_segment_set_last_stop (&parse->segment, GST_FORMAT_TIME,
+                             last_stop);
+
+  /* convert internal flow to OK and mark discont for the next buffer. */
+  if (ret == GST_BASE_PARSE_FLOW_DROPPED) {
+    parse->priv->discont = TRUE;
+    ret = GST_FLOW_OK;
+  }
+  return ret;
+}
+
+
+/**
+ * gst_base_parse_drain:
+ * @parse: #GstBaseParse.
+ *
+ * Drains the adapter until it is empty. It decreases the min_frame_size to
+ * match the current adapter size and calls chain method until the adapter
+ * is emptied or chain returns with error.
+ */
+static void
+gst_base_parse_drain (GstBaseParse *parse)
+{
+  guint avail;
+
+  for (;;) {
+    avail = gst_adapter_available (parse->adapter);
+    if (!avail) break;
+
+    gst_base_parse_set_min_frame_size (parse, avail);
+    if (gst_base_parse_chain (parse->sinkpad, NULL) != GST_FLOW_OK) {
+      break;
+    }
+  }
+}
+
+
+/**
+ * gst_base_parse_chain:
+ * @pad: #GstPad.
+ * @buffer: #GstBuffer.
+ *
+ * Returns: #GstFlowReturn.
+ */
+static GstFlowReturn
+gst_base_parse_chain (GstPad * pad, GstBuffer * buffer)
+{
+  GstBaseParseClass *bclass;
+  GstBaseParse *parse;
+  GstFlowReturn ret = GST_FLOW_OK;
+  GstBuffer *outbuf = NULL;
+  GstBuffer *tmpbuf = NULL;
+  guint fsize = 0;
+  gint skip = -1;
+  const guint8 *data;
+  guint min_size;
+
+  parse = GST_BASE_PARSE (GST_OBJECT_PARENT (pad));
+  bclass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  if (parse->pending_segment) {
+    GST_DEBUG_OBJECT (parse, "chain pushing a pending segment");
+    gst_pad_push_event (parse->srcpad, parse->pending_segment);
+    parse->pending_segment = NULL;
+    parse->priv->offset = parse->priv->pending_offset;
+
+    /* Make sure that adapter doesn't have any old data after
+       newsegment has been pushed */
+
+    /* FIXME: when non-flushing seek occurs, chain is still processing the
+       data from old segment. If this processing loop is then interrupted
+       (e.g. paused), chain function exists and next time it gets called
+       all this old data gets lost and playback continues from new segment */
+    gst_adapter_clear (parse->adapter);
+  }
+
+  if (parse->priv->pending_events) {
+    GList *l;
+
+    for (l = parse->priv->pending_events; l != NULL; l = l->next) {
+      gst_pad_push_event (parse->srcpad, GST_EVENT (l->data));
+    }
+    g_list_free (parse->priv->pending_events);
+    parse->priv->pending_events = NULL;
+  }
+
+  if (buffer) {
+    GST_LOG_OBJECT (parse, "buffer size: %d, offset = %lld",
+            GST_BUFFER_SIZE(buffer), GST_BUFFER_OFFSET (buffer));
+
+
+    gst_adapter_push (parse->adapter, buffer);
+  }
+
+  /* Parse and push as many frames as possible */
+  /* Stop either when adapter is empty or we are flushing */
+  while (!parse->priv->flushing) {
+    tmpbuf = gst_buffer_new ();
+
+    GST_BASE_PARSE_LOCK (parse);
+    min_size = parse->priv->min_frame_size;
+    GST_BASE_PARSE_UNLOCK (parse);
+
+    /* Synchronization loop */
+    for (;;) {
+      /* Collect at least min_frame_size bytes */
+      if (gst_adapter_available (parse->adapter) < min_size)
+      {
+        GST_DEBUG_OBJECT (parse, "not enough data available (only %d bytes)",
+                   gst_adapter_available (parse->adapter));
+        gst_buffer_unref (tmpbuf);
+        goto done;
+      }
+
+      data = gst_adapter_peek (parse->adapter, min_size);
+      GST_BUFFER_DATA (tmpbuf) = (guint8 *) data;
+      GST_BUFFER_SIZE (tmpbuf) = min_size;
+      GST_BUFFER_OFFSET (tmpbuf) = parse->priv->offset;
+      GST_BUFFER_FLAG_SET (tmpbuf, GST_MINI_OBJECT_FLAG_READONLY);
+
+      if (parse->priv->discont) {
+        GST_DEBUG_OBJECT (parse, "marking DISCONT");
+        GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
+      }
+
+      skip = -1;
+      if (bclass->check_valid_frame (parse, tmpbuf, &fsize, &skip)) {
+        break;
+      }
+      if (skip > 0) {
+        GST_LOG_OBJECT (parse, "finding sync, skipping %d bytes", skip);
+        gst_adapter_flush (parse->adapter, skip);
+        parse->priv->offset += skip;
+      }
+      else if (skip == -1) {
+        /* subclass didn't touch this value. By default we skip 1 byte */
+        GST_LOG_OBJECT (parse, "finding sync, skipping 1 byte");
+        gst_adapter_flush (parse->adapter, 1);
+        parse->priv->offset++;
+      }
+      /* There is a possibility that subclass set the skip value to zero.
+         This means that it has probably found a frame but wants to ask
+         more data (by increasing the min_size) to be sure of this. */
+    }
+    gst_buffer_unref (tmpbuf);
+    tmpbuf = NULL;
+
+    if (skip > 0) {
+      /* Subclass found the sync, but still wants to skip some data */
+      GST_LOG_OBJECT (parse, "skipping %d bytes", skip);
+      gst_adapter_flush (parse->adapter, skip);
+      parse->priv->offset += skip;
+    }
+
+    /* Grab lock to prevent a race with FLUSH_START handler */
+    GST_PAD_STREAM_LOCK (parse->srcpad);
+
+    /* FLUSH_START event causes the "flushing" flag to be set. In this
+     * case we can leave the frame pushing loop */
+    if (parse->priv->flushing) {
+      GST_PAD_STREAM_UNLOCK (parse->srcpad);
+      break;
+    }
+
+    /* FIXME: Would it be more efficient to make a subbuffer instead? */
+    outbuf = gst_adapter_take_buffer (parse->adapter, fsize);
+
+    /* Subclass may want to know the data offset */
+    GST_BUFFER_OFFSET (outbuf) = parse->priv->offset;
+    parse->priv->offset += fsize;
+
+    ret = gst_base_parse_handle_and_push_buffer (parse, bclass, outbuf);
+    GST_PAD_STREAM_UNLOCK (parse->srcpad);
+
+    if (ret != GST_FLOW_OK) {
+      GST_LOG_OBJECT (parse, "push returned %d", ret);
+      break;
+    }
+  }
+
+done:
+  GST_LOG_OBJECT (parse, "chain leaving");
+  return ret;
+}
+
+static GstFlowReturn
+gst_base_parse_pull_range (GstBaseParse *parse, guint size, GstBuffer **buffer)
+{
+  GstFlowReturn ret = GST_FLOW_OK;
+
+  g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
+
+  /* Caching here actually makes much less difference than one would expect.
+   * We do it mainly to avoid pulling buffers of 1 byte all the time */
+  if (parse->priv->cache) {
+    guint64 cache_offset = GST_BUFFER_OFFSET (parse->priv->cache);
+    guint cache_size = GST_BUFFER_SIZE (parse->priv->cache);
+
+    if (cache_offset <= parse->priv->offset &&
+        (parse->priv->offset + size) < (cache_offset + cache_size)) {
+      *buffer = gst_buffer_create_sub (parse->priv->cache,
+            parse->priv->offset - cache_offset, size);
+      return GST_FLOW_OK;
+    }
+    /* not enough data in the cache, free cache and get a new one */
+    gst_buffer_unref (parse->priv->cache);
+    parse->priv->cache = NULL;
+  }
+
+  /* refill the cache */
+  ret = gst_pad_pull_range (parse->sinkpad, parse->priv->offset, MAX (size, 64 * 1024),
+      &parse->priv->cache);
+  if (ret != GST_FLOW_OK) {
+    parse->priv->cache = NULL;
+    return ret;
+  }
+
+  if (GST_BUFFER_SIZE (parse->priv->cache) >= size) {
+    *buffer = gst_buffer_create_sub (parse->priv->cache, 0, size);
+    return GST_FLOW_OK;
+  }
+
+  /* Not possible to get enough data, try a last time with
+   * requesting exactly the size we need */
+  gst_buffer_unref (parse->priv->cache);
+  parse->priv->cache = NULL;
+
+  ret = gst_pad_pull_range (parse->sinkpad, parse->priv->offset, size,
+      &parse->priv->cache);
+
+  if (ret != GST_FLOW_OK) {
+    GST_DEBUG_OBJECT (parse, "pull_range returned %d", ret);
+    *buffer = NULL;
+    return ret;
+  }
+
+  if (GST_BUFFER_SIZE (parse->priv->cache) < size) {
+    GST_WARNING_OBJECT (parse, "Dropping short buffer at offset %"
+        G_GUINT64_FORMAT ": wanted %u bytes, got %u bytes", parse->priv->offset,
+        size, GST_BUFFER_SIZE (parse->priv->cache));
+
+    gst_buffer_unref (parse->priv->cache);
+    parse->priv->cache = NULL;
+
+    *buffer = NULL;
+    return GST_FLOW_UNEXPECTED;
+  }
+
+  *buffer = gst_buffer_create_sub (parse->priv->cache, 0, size);
+
+  return GST_FLOW_OK;
+}
+
+/**
+ * gst_base_parse_loop:
+ * @pad: GstPad
+ *
+ * Loop that is used in pull mode to retrieve data from upstream.
+ */
+static void
+gst_base_parse_loop (GstPad * pad)
+{
+  GstBaseParse *parse;
+  GstBaseParseClass *klass;
+  GstBuffer *buffer, *outbuf;
+  gboolean ret = FALSE;
+  guint fsize = 0, min_size;
+  gint skip = 0;
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
+  klass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  if (parse->close_segment) {
+    GST_DEBUG_OBJECT (parse, "loop sending close segment");
+    gst_pad_push_event (parse->srcpad, parse->close_segment);
+    parse->close_segment = NULL;
+  }
+
+  if (parse->pending_segment) {
+    GST_DEBUG_OBJECT (parse, "loop push pending segment");
+    gst_pad_push_event (parse->srcpad, parse->pending_segment);
+    parse->pending_segment = NULL;
+  }
+
+  /* TODO: Check if we reach segment stop limit */
+
+  while (TRUE) {
+
+    GST_BASE_PARSE_LOCK (parse);
+    min_size = parse->priv->min_frame_size;
+    GST_BASE_PARSE_UNLOCK (parse);
+
+    ret = gst_base_parse_pull_range (parse, min_size, &buffer);
+
+    if (ret == GST_FLOW_UNEXPECTED)
+      goto eos;
+    else if (ret != GST_FLOW_OK)
+      goto need_pause;
+
+    if (parse->priv->discont) {
+      GST_DEBUG_OBJECT (parse, "marking DISCONT");
+      GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
+    }
+
+    skip = -1;
+    if (klass->check_valid_frame (parse, buffer, &fsize, &skip)) {
+      break;
+    }
+    if (skip > 0) {
+      GST_LOG_OBJECT (parse, "finding sync, skipping %d bytes", skip);
+      parse->priv->offset += skip;
+    }
+    else if (skip == -1) {
+      GST_LOG_OBJECT (parse, "finding sync, skipping 1 byte");
+      parse->priv->offset++;
+    }
+    GST_DEBUG_OBJECT (parse, "finding sync...");
+    gst_buffer_unref (buffer);
+  }
+
+  if (fsize <= GST_BUFFER_SIZE (buffer)) {
+    outbuf = gst_buffer_create_sub (buffer, 0, fsize);
+    gst_buffer_unref (buffer);
+  } else {
+    gst_buffer_unref (buffer);
+    ret = gst_base_parse_pull_range (parse, fsize, &outbuf);
+    
+    if (ret == GST_FLOW_UNEXPECTED)
+      goto eos;
+    else if (ret != GST_FLOW_OK)
+      goto need_pause;
+  }
+
+  parse->priv->offset += fsize;
+
+  /* Does the subclass want to skip too? */
+  if (skip > 0)
+    parse->priv->offset += skip;
+
+  /* This always unrefs the outbuf, even if error occurs */
+  ret = gst_base_parse_handle_and_push_buffer (parse, klass, outbuf);
+
+  if (ret != GST_FLOW_OK) {
+    GST_DEBUG_OBJECT (parse, "flow: %s", gst_flow_get_name (ret));
+    if (GST_FLOW_IS_FATAL (ret)) {
+      GST_ELEMENT_ERROR (parse, STREAM, FAILED, (NULL),
+                         ("streaming task paused, reason: %s",
+                          gst_flow_get_name (ret)));
+      gst_pad_push_event (pad, gst_event_new_eos ());
+    }
+    goto need_pause;
+  }
+
+  gst_object_unref (parse);
+  return;
+
+need_pause:
+  {
+    GST_LOG_OBJECT (parse, "pausing task");
+    gst_pad_pause_task (pad);
+    gst_object_unref (parse);
+    return;
+  }
+eos:
+  {
+    GST_LOG_OBJECT (parse, "pausing task %d", ret);
+    gst_pad_push_event (parse->srcpad, gst_event_new_eos ());
+    gst_pad_pause_task (pad);
+    gst_object_unref (parse);
+    return;
+  }
+}
+
+
+/**
+ * gst_base_parse_sink_activate:
+ * @sinkpad: #GstPad to be activated.
+ *
+ * Returns: TRUE if activation succeeded.
+ */
+static gboolean
+gst_base_parse_sink_activate (GstPad * sinkpad)
+{
+  GstBaseParse *parse;
+  gboolean result = TRUE;
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (sinkpad));
+  
+  GST_DEBUG_OBJECT (parse, "sink activate");
+
+  if (gst_pad_check_pull_range (sinkpad)) {
+    GST_DEBUG_OBJECT (parse, "trying to activate in pull mode");
+    result = gst_pad_activate_pull (sinkpad, TRUE);
+  } else {
+    GST_DEBUG_OBJECT (parse, "trying to activate in push mode");
+    result = gst_pad_activate_push (sinkpad, TRUE);
+  }
+
+  GST_DEBUG_OBJECT (parse, "sink activate return %d", result);
+  gst_object_unref (parse);
+  return result;
+}
+
+
+/**
+ * gst_base_parse_activate:
+ * @parse: #GstBaseParse.
+ * @active: TRUE if element will be activated, FALSE if disactivated.
+ *
+ * Returns: TRUE if the operation succeeded.
+ */
+static gboolean
+gst_base_parse_activate (GstBaseParse *parse, gboolean active)
+{
+  GstBaseParseClass *klass;
+  gboolean result = FALSE;
+
+  GST_DEBUG_OBJECT (parse, "activate");
+
+  klass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  if (active) {
+    if (parse->priv->pad_mode == GST_ACTIVATE_NONE && klass->start)
+      result = klass->start (parse);
+
+    GST_OBJECT_LOCK (parse);
+    gst_segment_init (&parse->segment, GST_FORMAT_TIME);
+    parse->priv->duration = -1;
+    parse->priv->discont = FALSE;
+    parse->priv->flushing = FALSE;
+    parse->priv->offset = 0;
+
+    if (parse->pending_segment)
+      gst_event_unref (parse->pending_segment);
+
+    parse->pending_segment =
+        gst_event_new_new_segment (FALSE, parse->segment.rate,
+                                   parse->segment.format,
+                                   parse->segment.start,
+				   parse->segment.stop,
+                                   parse->segment.last_stop);
+
+    GST_OBJECT_UNLOCK (parse);
+  }
+  else {
+    /* We must make sure streaming has finished before resetting things
+    * and calling the ::stop vfunc */
+    GST_PAD_STREAM_LOCK (parse->sinkpad);
+    GST_PAD_STREAM_UNLOCK (parse->sinkpad);
+
+    if (parse->priv->pad_mode != GST_ACTIVATE_NONE && klass->stop)
+      result = klass->stop (parse);
+
+    g_list_foreach (parse->priv->pending_events, (GFunc) gst_mini_object_unref, NULL);
+    g_list_free (parse->priv->pending_events);
+    parse->priv->pending_events = NULL;
+
+    if (parse->priv->cache) {
+      gst_buffer_unref (parse->priv->cache);
+      parse->priv->cache = NULL;
+    }
+
+    parse->priv->pad_mode = GST_ACTIVATE_NONE;
+  }
+  GST_DEBUG_OBJECT (parse, "activate: %d", result);
+  return result;
+}
+
+
+/**
+ * gst_base_parse_sink_activate_push:
+ * @pad: #GstPad to be (de)activated.
+ * @active: TRUE when activating, FALSE when deactivating.
+ *
+ * Returns: TRUE if (de)activation succeeded.
+ */
+static gboolean
+gst_base_parse_sink_activate_push (GstPad * pad, gboolean active)
+{
+  gboolean result = TRUE;
+  GstBaseParse *parse;
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
+  
+  GST_DEBUG_OBJECT (parse, "sink activate push");
+
+  result = gst_base_parse_activate (parse, active);
+
+  if (result)
+    parse->priv->pad_mode = active ? GST_ACTIVATE_PUSH : GST_ACTIVATE_NONE;
+
+  GST_DEBUG_OBJECT (parse, "sink activate push: %d", result);
+  
+  gst_object_unref (parse);
+  return result;
+}
+
+
+/**
+ * gst_base_parse_sink_activate_pull:
+ * @sinkpad: #GstPad to be (de)activated.
+ * @active: TRUE when activating, FALSE when deactivating.
+ *
+ * Returns: TRUE if (de)activation succeeded.
+ */
+static gboolean
+gst_base_parse_sink_activate_pull (GstPad * sinkpad, gboolean active)
+{
+  gboolean result = FALSE;
+  GstBaseParse *parse;
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (sinkpad));
+
+  GST_DEBUG_OBJECT (parse, "activate pull");
+
+  result = gst_base_parse_activate (parse, active);
+
+  if (result) {
+    if (active) {
+      result &= gst_pad_start_task (sinkpad,
+                                    (GstTaskFunction) gst_base_parse_loop,
+                                    sinkpad);
+    } else {
+      result &= gst_pad_stop_task (sinkpad);
+    }
+  }
+
+  if (result)
+    parse->priv->pad_mode = active ? GST_ACTIVATE_PULL : GST_ACTIVATE_NONE;
+
+  GST_DEBUG_OBJECT (parse, "sink activate pull: %d", result);
+
+  gst_object_unref (parse);
+  return result;
+}
+
+
+/**
+ * gst_base_parse_set_duration:
+ * @parse: #GstBaseParse.
+ * @fmt: #GstFormat.
+ * @duration: duration value.
+ *
+ * Sets the duration of the currently playing media. Subclass can use this
+ * when it notices a change in the media duration.
+ */
+void gst_base_parse_set_duration (GstBaseParse *parse,
+                                  GstFormat fmt,
+                                  gint64 duration)
+{
+  g_return_if_fail (parse != NULL);
+
+  GST_BASE_PARSE_LOCK (parse);
+  if (duration != parse->priv->duration) {
+    GstMessage *m;
+
+    m = gst_message_new_duration (GST_OBJECT (parse), fmt, duration);
+    gst_element_post_message (GST_ELEMENT (parse), m);
+
+    /* TODO: what about duration tag? */
+  }
+  parse->priv->duration = duration;
+  parse->priv->duration_fmt = fmt;
+  GST_DEBUG_OBJECT (parse, "set duration: %lld", duration);
+  GST_BASE_PARSE_UNLOCK (parse);
+}
+
+
+/**
+ * gst_base_parse_set_min_frame_size:
+ * @parse: #GstBaseParse.
+ * @min_size: Minimum size of the data that this base class should give to
+ *            subclass.
+ *
+ * Subclass can use this function to tell the base class that it needs to
+ * give at least #min_size buffers.
+ */
+void gst_base_parse_set_min_frame_size (GstBaseParse *parse, guint min_size)
+{
+  g_return_if_fail (parse != NULL);
+
+  GST_BASE_PARSE_LOCK (parse);
+  parse->priv->min_frame_size = min_size;
+  GST_LOG_OBJECT (parse, "set frame_min_size: %d", min_size);
+  GST_BASE_PARSE_UNLOCK (parse);
+}
+
+
+/**
+ * gst_base_parse_get_querytypes:
+ * @pad: GstPad
+ *
+ * Returns: A table of #GstQueryType items describing supported query types.
+ */
+static const GstQueryType *
+gst_base_parse_get_querytypes (GstPad * pad)
+{
+  static const GstQueryType list[] = {
+    GST_QUERY_POSITION,
+    GST_QUERY_DURATION,
+    GST_QUERY_FORMATS,
+    GST_QUERY_SEEKING,
+    GST_QUERY_CONVERT,
+    0
+  };
+
+  return list;
+}
+
+
+/**
+ * gst_base_parse_query:
+ * @pad: #GstPad.
+ * @query: #GstQuery.
+ *
+ * Returns: TRUE on success.
+ */
+static gboolean
+gst_base_parse_query (GstPad * pad, GstQuery * query)
+{
+  GstBaseParse *parse;
+  GstBaseParseClass *klass;
+  gboolean res = FALSE;
+
+  parse = GST_BASE_PARSE (GST_PAD_PARENT (pad));
+  klass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  /* If subclass doesn't provide conversion function we can't reply
+     to the query either */
+  if (!klass->convert) {
+    return FALSE;
+  }
+
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_POSITION:
+    {
+      gint64 dest_value;
+      GstFormat format;
+
+      GST_DEBUG_OBJECT (parse, "position query");
+
+      gst_query_parse_position (query, &format, NULL);
+
+      g_mutex_lock (parse->parse_lock);
+
+      if (format == GST_FORMAT_BYTES) {
+        dest_value = parse->priv->offset;
+        res = TRUE;
+      }
+      else if (format == parse->segment.format &&
+          GST_CLOCK_TIME_IS_VALID (parse->segment.last_stop))
+      {
+        dest_value = parse->segment.last_stop;
+        res = TRUE;
+      } else {
+        /* priv->offset is updated in both PUSH/PULL modes */
+        res = klass->convert (parse, GST_FORMAT_BYTES, parse->priv->offset,
+                              format, &dest_value);
+      }
+      g_mutex_unlock (parse->parse_lock);
+
+      if (res)
+        gst_query_set_position (query, format, dest_value);
+      else
+        res = gst_pad_query_default (pad, query);
+
+      break;
+    }
+    case GST_QUERY_DURATION:
+    {
+      GstFormat format;
+      gint64 dest_value;
+
+      GST_DEBUG_OBJECT (parse, "duration query");
+
+      gst_query_parse_duration (query, &format, NULL);
+
+      g_mutex_lock (parse->parse_lock);
+
+      if (format == GST_FORMAT_BYTES) {
+        res = gst_pad_query_peer_duration (parse->sinkpad, &format,
+                                           &dest_value);
+      }
+      else if (parse->priv->duration != -1 &&
+          format == parse->priv->duration_fmt)
+      {
+        dest_value = parse->priv->duration;
+        res = TRUE;
+      } else if (parse->priv->duration != -1) {
+        res = klass->convert (parse, parse->priv->duration_fmt,
+                              parse->priv->duration,
+                              format, &dest_value);
+      }
+
+      g_mutex_unlock (parse->parse_lock);
+
+      if (res)
+        gst_query_set_duration (query, format, dest_value);
+      else
+        res = gst_pad_query_default (pad, query);
+      break;
+    }
+    case GST_QUERY_SEEKING:
+    {
+      GstFormat fmt;
+      gboolean seekable = FALSE;
+
+      GST_DEBUG_OBJECT (parse, "seeking query");
+
+      gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
+
+      if (fmt != GST_FORMAT_TIME)
+      {
+        return gst_pad_query_default (pad, query);
+      }
+
+      seekable = klass->is_seekable (parse);
+
+      /* TODO: could this duration be calculated/converted if subclass
+               hasn't given it? */
+      gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0,
+                             (parse->priv->duration == -1) ?
+                                 GST_CLOCK_TIME_NONE : parse->priv->duration);
+
+      GST_DEBUG_OBJECT (parse, "seekable: %d", seekable);
+      res = TRUE;
+      break;
+    }
+    case GST_QUERY_FORMATS:
+      gst_query_set_formatsv (query, 3, fmtlist);
+      res = TRUE;
+      break;
+
+    case GST_QUERY_CONVERT:
+    {
+      GstFormat src_format, dest_format;
+      gint64 src_value, dest_value;
+
+      gst_query_parse_convert (query, &src_format, &src_value,
+                               &dest_format, &dest_value);
+
+      /* FIXME: hm? doesn't make sense 
+       * We require all those values to be given
+      if (src_format && src_value && dest_format && dest_value ) { */
+        res = klass->convert (parse, src_format, src_value,
+                              dest_format, &dest_value);
+        if (res) {
+          gst_query_set_convert (query, src_format, src_value,
+                                 dest_format, dest_value);
+        }
+      /*}*/
+      break;
+    }
+    default:
+      res = gst_pad_query_default (pad, query);
+      break;
+  }
+  return res;
+}
+
+
+/**
+ * gst_base_parse_handle_seek:
+ * @parse: #GstBaseParse.
+ * @event: #GstEvent.
+ *
+ * Returns: TRUE if seek succeeded.
+ */
+static gboolean
+gst_base_parse_handle_seek (GstBaseParse * parse, GstEvent * event)
+{
+  GstBaseParseClass *klass;
+  gdouble rate;
+  GstFormat format;
+  GstSeekFlags flags;
+  GstSeekType cur_type = GST_SEEK_TYPE_NONE, stop_type;
+  gboolean flush, update, res = TRUE;
+  gint64 cur, stop, seekpos;
+  GstSegment seeksegment = { 0, };
+  GstFormat dstformat;
+
+  klass = GST_BASE_PARSE_GET_CLASS (parse);
+
+  gst_event_parse_seek (event, &rate, &format, &flags,
+                        &cur_type, &cur, &stop_type, &stop);
+
+  /* no negative rates yet */
+  if (rate < 0.0)
+    goto negative_rate;
+
+  if (cur_type != GST_SEEK_TYPE_SET)
+    goto wrong_type;
+
+  /* For any format other than TIME, see if upstream handles
+   * it directly or fail. For TIME, try upstream, but do it ourselves if
+   * it fails upstream */
+  if (format != GST_FORMAT_TIME) {
+    gst_event_ref (event);
+    return gst_pad_push_event (parse->sinkpad, event);
+  }
+  else {
+    gst_event_ref (event);
+    if (gst_pad_push_event (parse->sinkpad, event))
+      return TRUE;
+  }
+
+  /* get flush flag */
+  flush = flags & GST_SEEK_FLAG_FLUSH;
+
+  dstformat = GST_FORMAT_BYTES;
+  if (!gst_pad_query_convert (parse->srcpad, format, cur,
+                              &dstformat, &seekpos))
+  {
+    GST_DEBUG_OBJECT (parse, "conversion failed");
+    return FALSE;
+  }
+
+  GST_DEBUG_OBJECT (parse, "seek position %lld in bytes: %lld", cur, seekpos);
+
+  if (parse->priv->pad_mode == GST_ACTIVATE_PULL) {
+    gint64 last_stop;
+
+    GST_DEBUG_OBJECT (parse, "seek in PULL mode");
+
+    if (flush) {
+      if (parse->srcpad) {
+        GST_DEBUG_OBJECT (parse, "sending flush start");
+        gst_pad_push_event (parse->srcpad, gst_event_new_flush_start ());
+      }
+    }
+    else {
+      gst_pad_pause_task (parse->sinkpad);
+    }
+
+    /* we should now be able to grab the streaming thread because we stopped it
+     * with the above flush/pause code */
+    GST_PAD_STREAM_LOCK (parse->sinkpad);
+
+    /* save current position */
+    last_stop = parse->segment.last_stop;
+    GST_DEBUG_OBJECT (parse, "stopped streaming at %" G_GINT64_FORMAT, last_stop);
+
+    /* copy segment, we need this because we still need the old
+     * segment when we close the current segment. */
+    memcpy (&seeksegment, &parse->segment, sizeof (GstSegment));
+
+    GST_DEBUG_OBJECT (parse, "configuring seek");
+    gst_segment_set_seek (&seeksegment, rate, format, flags,
+                          cur_type, cur, stop_type, stop, &update);
+
+    /* figure out the last position we need to play. If it's configured (stop !=
+     * -1), use that, else we play until the total duration of the file */
+    if ((stop = seeksegment.stop) == -1)
+      stop = seeksegment.duration;
+
+    parse->priv->offset = seekpos;
+
+    /* prepare for streaming again */
+    if (flush) {
+      GST_DEBUG_OBJECT (parse, "sending flush stop");
+      gst_pad_push_event (parse->srcpad, gst_event_new_flush_stop ());
+    }
+    else {
+      if (parse->close_segment)
+        gst_event_unref (parse->close_segment);
+
+      parse->close_segment = gst_event_new_new_segment (TRUE,
+          parse->segment.rate, parse->segment.format,
+          parse->segment.accum, parse->segment.last_stop,
+          parse->segment.accum);
+
+      /* keep track of our last_stop */
+      seeksegment.accum = parse->segment.last_stop;
+
+      GST_DEBUG_OBJECT (parse, "Created close seg format %d, "
+          "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
+          ", pos = %" GST_TIME_FORMAT, format,
+          GST_TIME_ARGS (parse->segment.accum),
+          GST_TIME_ARGS (parse->segment.last_stop),
+          GST_TIME_ARGS (parse->segment.accum));
+    }
+
+    memcpy (&parse->segment, &seeksegment, sizeof (GstSegment));
+
+    /* store the newsegment event so it can be sent from the streaming thread.*/
+    if (parse->pending_segment)
+      gst_event_unref (parse->pending_segment);
+
+    /* This will be sent later in _loop() */
+    parse->pending_segment =
+        gst_event_new_new_segment (FALSE, parse->segment.rate,
+                                   parse->segment.format,
+                                   parse->segment.last_stop, stop,
+                                   parse->segment.last_stop);
+
+    GST_DEBUG_OBJECT (parse, "Created newseg format %d, "
+        "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT
+        ", pos = %" GST_TIME_FORMAT, format,
+        GST_TIME_ARGS (parse->segment.last_stop),
+        GST_TIME_ARGS (stop),
+        GST_TIME_ARGS (parse->segment.last_stop));
+
+    /* mark discont if we are going to stream from another position. */
+    if (last_stop != parse->segment.last_stop) {
+      GST_DEBUG_OBJECT (parse, "mark DISCONT, we did a seek to another position");
+      parse->priv->discont = TRUE;
+    }
+
+    /* Start streaming thread if paused */
+    gst_pad_start_task (parse->sinkpad,
+                        (GstTaskFunction) gst_base_parse_loop,
+                         parse->sinkpad);
+
+    GST_PAD_STREAM_UNLOCK (parse->sinkpad);
+  }
+  else {
+    GstEvent *new_event;
+    /* The only thing we need to do in PUSH-mode is to send the
+       seek event (in bytes) to upstream. Segment / flush handling happens
+       in corresponding src event handlers */
+    GST_DEBUG_OBJECT (parse, "seek in PUSH mode");
+    new_event = gst_event_new_seek(rate, GST_FORMAT_BYTES, flush,
+                                             GST_SEEK_TYPE_SET, seekpos,
+                                             stop_type, stop);
+
+    res = gst_pad_push_event (parse->sinkpad, new_event);
+  }
+
+done:
+  return res;
+
+  /* ERRORS */
+negative_rate:
+  {
+    GST_DEBUG_OBJECT (parse, "negative playback rates are not supported yet.");
+    res = FALSE;
+    goto done;
+  }
+wrong_type:
+  {
+    GST_DEBUG_OBJECT (parse, "unsupported seek type.");
+    res = FALSE;
+    goto done;
+  }
+}
+
+
+/**
+ * gst_base_parse_sink_setcaps:
+ * @pad: #GstPad.
+ * @caps: #GstCaps.
+ *
+ * Returns: TRUE if caps were accepted.
+ */
+static gboolean
+gst_base_parse_sink_setcaps (GstPad * pad, GstCaps * caps)
+{
+  GstBaseParse *parse;
+  GstBaseParseClass *klass;
+  gboolean res = TRUE;
+
+  gchar *caps_str = gst_caps_to_string (caps);
+  g_free (caps_str);
+
+  parse = GST_BASE_PARSE (gst_pad_get_parent (pad));
+  klass = GST_BASE_PARSE_GET_CLASS (parse);
+  
+  GST_DEBUG_OBJECT (parse, "setcaps: %s", caps_str);
+
+  if (klass->set_sink_caps)
+    res = klass->set_sink_caps (parse, caps);
+
+  parse->negotiated = res;
+  gst_object_unref (parse);
+  return gst_pad_set_caps (pad, caps);
+}
+
Index: gst/aacparse/gstbaseparse.h
===================================================================
RCS file: gst/aacparse/gstbaseparse.h
diff -N gst/aacparse/gstbaseparse.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gst/aacparse/gstbaseparse.h	15 Sep 2008 13:02:44 -0000
@@ -0,0 +1,237 @@
+/* GStreamer
+ * Copyright (C) 2008 Nokia Corporation. All rights reserved.
+ *
+ * Contact: Stefan Kost <stefan.kost@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GST_BASE_PARSE_H__
+#define __GST_BASE_PARSE_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstadapter.h>
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_BASE_PARSE		   (gst_base_parse_get_type())
+#define GST_BASE_PARSE(obj)		   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BASE_PARSE,GstBaseParse))
+#define GST_BASE_PARSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_BASE_PARSE,GstBaseParseClass))
+#define GST_BASE_PARSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_BASE_PARSE,GstBaseParseClass))
+#define GST_IS_BASE_PARSE(obj)	   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BASE_PARSE))
+#define GST_IS_BASE_PARSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BASE_PARSE))
+#define GST_BASE_PARSE_CAST(obj)	((GstBaseParse *)(obj))
+
+/**
+ * GST_BASE_PARSE_SINK_NAME:
+ *
+ * the name of the templates for the sink pad
+ */
+#define GST_BASE_PARSE_SINK_NAME	"sink"
+/**
+ * GST_BASE_PARSE_SRC_NAME:
+ *
+ * the name of the templates for the source pad
+ */
+#define GST_BASE_PARSE_SRC_NAME	"src"
+
+/**
+ * GST_BASE_PARSE_SRC_PAD:
+ * @obj: base parse instance
+ *
+ * Gives the pointer to the source #GstPad object of the element.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_PARSE_SRC_PAD(obj)		(GST_BASE_PARSE_CAST (obj)->srcpad)
+
+/**
+ * GST_BASE_PARSE_SINK_PAD:
+ * @obj: base parse instance
+ *
+ * Gives the pointer to the sink #GstPad object of the element.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_PARSE_SINK_PAD(obj)	(GST_BASE_PARSE_CAST (obj)->sinkpad)
+
+/**
+ * GST_BASE_PARSE_FLOW_DROPPED:
+ *
+ * A #GstFlowReturn that can be returned from parse_frame to
+ * indicate that no output buffer was generated.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_PARSE_FLOW_DROPPED   GST_FLOW_CUSTOM_SUCCESS
+
+/**
+ * GST_BASE_PARSE_LOCK:
+ * @obj: base parse instance
+ *
+ * Obtain a lock to protect the parse function from concurrent access.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_PARSE_LOCK(obj)   g_mutex_lock (GST_BASE_PARSE_CAST (obj)->parse_lock)
+
+/**
+ * GST_BASE_PARSE_UNLOCK:
+ * @obj: base parse instance
+ *
+ * Release the lock that protects the parse function from concurrent access.
+ *
+ * Since: 0.10.x
+ */
+#define GST_BASE_PARSE_UNLOCK(obj) g_mutex_unlock (GST_BASE_PARSE_CAST (obj)->parse_lock)
+
+typedef struct _GstBaseParse GstBaseParse;
+typedef struct _GstBaseParseClass GstBaseParseClass;
+typedef struct _GstBaseParsePrivate GstBaseParsePrivate;
+typedef struct _GstBaseParseClassPrivate GstBaseParseClassPrivate;
+
+/**
+ * GstBaseParse:
+ * @element: the parent element.
+ *
+ * The opaque #GstBaseParse data structure.
+ */
+struct _GstBaseParse {
+  GstElement	 element;
+  GstAdapter   *adapter;
+
+  /*< protected >*/
+  /* source and sink pads */
+  GstPad	*sinkpad;
+  GstPad	*srcpad;
+
+  /* MT-protected (with STREAM_LOCK) */
+  GstSegment     segment;
+
+  /* Newsegment event to be sent after SEEK */
+  GstEvent       *pending_segment;
+
+  /* Segment event that closes the running segment prior to SEEK */
+  GstEvent       *close_segment;
+
+  /* Caps nego done already? */
+  gboolean   negotiated;
+
+  GMutex	*parse_lock;
+
+  /*< private >*/
+  gpointer       _gst_reserved[GST_PADDING_LARGE];
+  GstBaseParsePrivate *priv;
+};
+
+/**
+ * GstBaseParseClass:
+ * @start:          Optional.
+ *                  Called when the element starts processing.
+ *                  Allows opening external resources.
+ * @stop:           Optional.
+ *                  Called when the element stops processing.
+ *                  Allows closing external resources.
+ * @set_sink_caps:  allows the subclass to be notified of the actual caps set.
+ * @check_valid_frame:  Check if the given piece of data contains a valid
+ *                      frame.
+ * @parse_frame:    Parse the already checked frame. Subclass need to
+ *                  set the buffer timestamp, duration, caps and possibly
+ *                  other necessary metadata. This is called with srcpad's
+ *                  STREAM_LOCK held.
+ * @convert:        Optional.
+ *                  Convert between formats.
+ * @find_frame:     Optional.
+ *                  Finds a frame. Gets a position passed and should return
+ *                  TRUE and the offset in bytes where this position is.
+ *                  Will only be called in pull mode and the subclass can pull
+ *                  whatever it wants from upstream. If not implemented,
+ *                  the base class will implement it by calling
+ *                  @check_valid_frame and @parse_frame to find the wanted
+ *                  frame and build a seek table.
+ * @event:          Optional.
+ *                  Event handler on the sink pad. This function should return
+ *                  TRUE if the event was handled and can be dropped.
+ * @src_event:      Optional.
+ *                  Event handler on the source pad. Should return TRUE
+ *                  if the event was handled and can be dropped.
+ * @is_seekable:    Optional.
+ *                  Subclass can override this if it wants to control the
+ *                  seekability of the stream. Otherwise the element assumes
+ *                  that stream is always seekable.
+ *
+ * Subclasses can override any of the available virtual methods or not, as
+ * needed. At minimum @check_valid_frame and @parse_frame needs to be
+ * overridden.
+ */
+struct _GstBaseParseClass {
+  GstElementClass parent_class;
+
+  /*< public >*/
+  /* virtual methods for subclasses */
+
+  gboolean      (*start)              (GstBaseParse *parse);
+
+  gboolean      (*stop)               (GstBaseParse *parse);
+
+  gboolean      (*set_sink_caps)      (GstBaseParse *parse,
+                                       GstCaps *caps);
+
+  gboolean      (*check_valid_frame)  (GstBaseParse *parse,
+                                       GstBuffer *buffer,
+                                       guint *framesize,
+                                       gint *skipsize);
+
+  GstFlowReturn (*parse_frame)        (GstBaseParse *parse,
+                                       GstBuffer *buffer);
+
+  gboolean      (*convert)            (GstBaseParse * parse,
+                                       GstFormat src_format,
+                                       gint64 src_value,
+                                       GstFormat dest_format,
+                                       gint64 * dest_value);
+
+  gboolean      (*find_frame)         (GstBaseParse *parse,
+                                       GstFormat src_format,
+                                       gint64 src_value,
+                                       gint64 * dest_value);
+
+  gboolean      (*event)              (GstBaseParse *parse,
+                                       GstEvent *event);
+
+  gboolean      (*src_event)          (GstBaseParse *parse,
+                                       GstEvent *event);
+
+  gboolean      (*is_seekable)        (GstBaseParse *parse);
+
+  /*< private >*/
+  gpointer       _gst_reserved[GST_PADDING_LARGE];  
+  GstBaseParseClassPrivate *priv;
+};
+
+GType           gst_base_parse_get_type         (void);
+
+
+void gst_base_parse_set_duration (GstBaseParse *parse,
+                                  GstFormat fmt,
+                                  gint64 duration);
+
+void gst_base_parse_set_min_frame_size (GstBaseParse *parse,
+                                        guint min_size);
+
+G_END_DECLS
+
+#endif /* __GST_BASE_PARSE_H__ */
