GStreamer

CVS Root:       /cvsroot/gstreamer
Module:         gstreamer
Changes by:     theuraeus
Date:           Wed Oct 01 2003  12:35:54 PDT

Log message:
latest fixes to spec file

Modified files:
    .               : gstreamer.spec.in

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gstreamer.spec.in.diff?r1=1.120&r2=1.121

====Begin Diffs====
Index: gstreamer.spec.in
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gstreamer.spec.in,v
retrieving revision 1.120
retrieving revision 1.121
diff -u -d -r1.120 -r1.121
--- gstreamer.spec.in	19 Aug 2003 18:25:53 -0000	1.120
+++ gstreamer.spec.in	1 Oct 2003 19:35:41 -0000	1.121
@@ -127,7 +127,7 @@
 
 %post
 /sbin/ldconfig
-%{_bindir}/gst-register > /dev/null 2> /dev/null
+%{_bindir}/gst-register-%{majorminor} > /dev/null 2> /dev/null
 
 %postun
 /sbin/ldconfig
@@ -149,7 +149,6 @@
 %{_libdir}/gstreamer-%{majorminor}/libgstelements*.so*
 %{_libdir}/gstreamer-%{majorminor}/libgsttypes*.so*
 %{_libdir}/gstreamer-%{majorminor}/libgststaticautoplug*.so*
-%{_libdir}/gstreamer-%{majorminor}/libgstbytestream*.so*
 %{_libdir}/gstreamer-%{majorminor}/libgstgetbits*.so*
 %{_libdir}/gstreamer-%{majorminor}/libgstspider*.so*
 %{_libdir}/gstreamer-%{majorminor}/libgstindexers.so
@@ -183,8 +182,6 @@
 %{_includedir}/%{name}-%{majorminor}/gst/*.h
 %dir %{_includedir}/%{name}-%{majorminor}/gst/control
 %{_includedir}/%{name}-%{majorminor}/gst/control/*.h
-%dir %{_includedir}/%{name}-%{majorminor}/gst/bytestream
-%{_includedir}/%{name}-%{majorminor}/gst/bytestream/bytestream.h
 %dir %{_includedir}/%{name}-%{majorminor}/gst/getbits
 %{_includedir}/%{name}-%{majorminor}/gst/getbits/getbits.h
 # %{_libdir}/libgstreamer.a

CVS Root:       /cvsroot/gstreamer
Module:         gst-plugins
Changes by:     rbultje
Date:           Wed Oct 01 2003  06:15:25 PDT

Log message:
New typefind system:
* bytestream is now part of the core
* all plugins have been modified to use this new typefind system
* asf typefinding added
* mpeg video stream typefiding removed because it's broken
* duplicate typefind entries removed
* extra id3 typefinding added, because we've seen 4 types of files
(riff/wav, flac, vorbis, mp3) with id3 headers and each of these needs
to work. Instead, I've added an id3 element and let it redo typefiding
after the id3 header. this needs a hack because spider only typefinds
once. We can remove this hack once spider supports multiple typefinds.
* with all this, mp3 typefinding is semi-rewritten
* id3 typefinding in flac/vorbis is removed, it's no longer needed
* fixed spider and gst-typefind to use this, too.
* Other general cleanups

Modified files:
    gst/modplug     : gstmodplug.cc gstmodplug.h
    gst/mpegaudioparse: Makefile.am gstmpegaudioparse.c
    gst/mpegstream  : gstmpegdemux.c gstmpegpacketize.h gstmpegparse.c
                      gstmpegparse.h gstmpegstream.c gstrfc2250enc.c
                      gstrfc2250enc.h
    gst/qtdemux     : qtdemux.c qtdemux.h
Removed files:
    gst/mpegaudioparse: gstmp3types.c

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/modplug/gstmodplug.cc.diff?r1=1.30&r2=1.31
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/modplug/gstmodplug.h.diff?r1=1.10&r2=1.11
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegaudioparse/Makefile.am.diff?r1=1.10&r2=1.11
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegaudioparse/gstmp3types.c
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegaudioparse/gstmpegaudioparse.c.diff?r1=1.23&r2=1.24
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstmpegdemux.c.diff?r1=1.39&r2=1.40
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstmpegpacketize.h.diff?r1=1.7&r2=1.8
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstmpegparse.c.diff?r1=1.42&r2=1.43
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstmpegparse.h.diff?r1=1.14&r2=1.15
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstmpegstream.c.diff?r1=1.6&r2=1.7
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstrfc2250enc.c.diff?r1=1.11&r2=1.12
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegstream/gstrfc2250enc.h.diff?r1=1.2&r2=1.3
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/qtdemux/qtdemux.c.diff?r1=1.21&r2=1.22
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/qtdemux/qtdemux.h.diff?r1=1.3&r2=1.4

====Begin Diffs====
Index: gstmodplug.cc
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/modplug/gstmodplug.cc,v
retrieving revision 1.30
retrieving revision 1.31
diff -u -d -r1.30 -r1.31
--- gstmodplug.cc	16 Sep 2003 09:59:58 -0000	1.30
+++ gstmodplug.cc	1 Oct 2003 13:14:48 -0000	1.31
@@ -130,31 +130,39 @@
 static GstElementClass *parent_class = NULL;
 
 static GstCaps* 
-modplug_type_find (GstBuffer *buf, gpointer priv) 
-{  
-  if (GST_BUFFER_SIZE (buf) < 75)
-    return NULL;
+modplug_type_find (GstByteStream *bs, gpointer priv) 
+{
+  GstBuffer *buf = NULL;
+  GstCaps *newc = NULL;
 
-  if (MOD_CheckType (buf)     ||
-      Mod_669_CheckType (buf) ||
-      Amf_CheckType (buf)     ||
-      Dsm_CheckType (buf)     ||
-      Fam_CheckType (buf)     ||
-      Gdm_CheckType (buf)     ||
-      Imf_CheckType (buf)     ||
-      It_CheckType (buf)      ||
-      M15_CheckType (buf)     ||
-      /*Med_CheckType (buf)     || <- FIXME */
-      Mtm_CheckType (buf)     ||
-      Okt_CheckType (buf)     ||
-      S3m_CheckType (buf)     ||
-      Xm_CheckType (buf)) {
-    return gst_caps_new ("modplug_type_find",
-			 "audio/x-mod",
-			   NULL);
+  if (gst_bytestream_peek (bs, &buf, 75) == 75) {
+    if (MOD_CheckType (buf)     ||
+        Mod_669_CheckType (buf) ||
+        Amf_CheckType (buf)     ||
+        Dsm_CheckType (buf)     ||
+        Fam_CheckType (buf)     ||
+        Gdm_CheckType (buf)     ||
+        Imf_CheckType (buf)     ||
+        It_CheckType (buf)      ||
+        M15_CheckType (buf)     ||
+#if 0
+        Med_CheckType (buf)     || /* FIXME */
+#endif
+        Mtm_CheckType (buf)     ||
+        Okt_CheckType (buf)     ||
+        S3m_CheckType (buf)     ||
+        Xm_CheckType (buf)) {
+      newc = GST_CAPS_NEW ("modplug_type_find",
+			   "audio/x-mod",
+			     NULL);
+    }
   }
-  
-  return NULL;
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return newc;
 }
 
 static GstTypeDefinition modplug_definitions[] = {
Index: gstmodplug.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/modplug/gstmodplug.h,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- gstmodplug.h	27 Jun 2003 23:46:13 -0000	1.10
+++ gstmodplug.h	1 Oct 2003 13:14:48 -0000	1.11
@@ -28,7 +28,7 @@
 #endif /* __cplusplus */
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 	
 #include "modplug_types.h"	
 
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegaudioparse/Makefile.am,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- Makefile.am	11 Sep 2003 19:57:57 -0000	1.10
+++ Makefile.am	1 Oct 2003 13:14:49 -0000	1.11
@@ -1,17 +1,9 @@
-#FIXME clean me up a bit
-
-plugin_LTLIBRARIES = libgstmpegaudioparse.la libgstmp3types.la
+plugin_LTLIBRARIES = libgstmpegaudioparse.la
 
 libgstmpegaudioparse_la_SOURCES = gstmpegaudioparse.c
 libgstmpegaudioparse_la_CFLAGS = $(GST_CFLAGS)
 libgstmpegaudioparse_la_LIBADD =
 libgstmpegaudioparse_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
 
-libgstmp3types_la_SOURCES = gstmp3types.c
-libgstmp3types_la_CFLAGS = $(GST_CFLAGS)
-libgstmp3types_la_LIBADD =
-libgstmp3types_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
-
 noinst_HEADERS = gstmpegaudioparse.h
 EXTRA_DIST = README
-
--- gstmp3types.c DELETED ---
Index: gstmpegaudioparse.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegaudioparse/gstmpegaudioparse.c,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- gstmpegaudioparse.c	16 Sep 2003 09:59:59 -0000	1.23
+++ gstmpegaudioparse.c	1 Oct 2003 13:14:49 -0000	1.24
@@ -35,6 +35,15 @@
   "(C) 1999",
 };
 
+static GstCaps * mp3_type_find (GstByteStream *bs, gpointer data);
+
+static GstTypeDefinition mp3type_definition = {
+  "mp3_audio/mpeg",
+  "audio/mpeg",
+  ".mp3 .mp2 .mp1 .mpga",
+  mp3_type_find,
+};
+
 static GstPadTemplate*
 mp3_src_factory (void)
 {
@@ -115,11 +124,221 @@
       0,
       (GInstanceInitFunc)gst_mp3parse_init,
     };
-    mp3parse_type = g_type_register_static(GST_TYPE_ELEMENT, "GstMPEGAudioParse", &mp3parse_info, 0);
+    mp3parse_type = g_type_register_static (GST_TYPE_ELEMENT,
+					    "GstMPEGAudioParse",
+					    &mp3parse_info, 0);
   }
   return mp3parse_type;
 }
 
+static guint mp3types_bitrates[2][3][16] =
+{ { {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, },
+    {0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384, },
+    {0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, } },
+  { {0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256, },
+    {0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, },
+    {0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, } },
+};
+
+static guint mp3types_freqs[3][3] =
+{ {44100, 48000, 32000},
+  {22050, 24000, 16000}, 
+  {11025, 12000,  8000}};
+
+static inline guint
+mp3_type_frame_length_from_header (guint32 header, guint *put_layer,
+				   guint *put_channels, guint *put_bitrate,
+				   guint *put_samplerate)
+{
+  guint length;
+  gulong mode, samplerate, bitrate, layer, version, channels;
+
+  /* we don't need extension, copyright, original or
+   * emphasis for the frame length */
+  header >>= 6;
+
+  /* mode */
+  mode = header & 0x3;
+  header >>= 3;
+
+  /* padding */
+  length = header & 0x1;
+  header >>= 1;
+
+  /* sampling frequency */
+  samplerate = header & 0x3;
+  if (samplerate == 3)
+    return 0;
+  header >>= 2;
+
+  /* bitrate index */
+  bitrate = header & 0xF;
+  if (bitrate == 15 || bitrate == 0)
+    return 0;
+
+  /* ignore error correction, too */
+  header >>= 5;
+
+  /* layer */
+  layer = 4 - (header & 0x3);
+  if (layer == 4)
+    return 0;
+  header >>= 2;
+
+  /* version */
+  version = header & 0x3;
+  if (version == 1)
+    return 0;
+
+  /* lookup */
+  channels = (mode == 3) ? 1 : 2;
+  bitrate = mp3types_bitrates[version == 3 ? 0 : 1][layer - 1][bitrate];
+  samplerate = mp3types_freqs[version > 0 ? version - 1 : 0][samplerate];
+
+  /* calculating */
+  if (layer == 1) {
+    length = ((12000 * bitrate / samplerate) + length) * 4;
+  } else {
+    length += ((layer == 3 && version == 0) ? 144000 : 72000) * bitrate / samplerate;
+  }
+
+  GST_DEBUG ("Calculated mp3 frame length of %u bytes", length);
+  GST_DEBUG ("samplerate = %lu - bitrate = %lu - layer = %lu - version = %lu"
+	     " - channels = %lu",
+	     samplerate, bitrate, layer, version, channels);
+
+  if (put_layer)
+    *put_layer = layer;
+  if (put_channels)
+    *put_channels = channels;
+  if (put_bitrate)
+    *put_bitrate = bitrate;
+  if (put_samplerate)
+    *put_samplerate = samplerate;
+
+  return length;
+}
+
+/**
+ * The chance that random data is identified as a valid mp3 header is 63 / 2^18
+ * (0.024%) per try. This makes the function for calculating false positives
+ *   1 - (1 - ((63 / 2 ^18) ^ GST_MP3_TYPEFIND_MIN_HEADERS)) ^ buffersize)
+ * This has the following probabilities of false positives:
+ * bufsize	          MIN_HEADERS
+ * (bytes)	1	2	3	4
+ * 4096		62.6%	 0.02%	 0%	 0%
+ * 16384	98%	 0.09%	 0%	 0%
+ * 1 MiB       100%	 5.88%	 0%	 0%
+ * 1 GiB       100%    100%	 1.44%   0%
+ * 1 TiB       100%    100%    100%      0.35%
+ * This means that the current choice (3 headers by most of the time 4096 byte
+ * buffers is pretty safe for now.
+ *
+ * The max. size of each frame is 1440 bytes, which means that for N frames
+ * to be detected, we need 1440 * GST_MP3_TYPEFIND_MIN_HEADERS + 3 of data.
+ * Assuming we step into the stream right after the frame header, this
+ * means we need 1440 * (GST_MP3_TYPEFIND_MIN_HEADERS + 1) - 1 + 3 bytes
+ * of data (5762) to always detect any mp3.
+ */
+
+/* increase this value when this function finds too many false positives */
+#define GST_MP3_TYPEFIND_MIN_HEADERS 3
+#define GST_MP3_TYPEFIND_MIN_DATA (1440 * (GST_MP3_TYPEFIND_MIN_HEADERS + 1) - 1 + 3)
+
+static GstCaps *
+mp3_caps_create (guint layer, guint channels,
+		 guint bitrate, guint samplerate)
+{
+  GstCaps *new;
+
+  g_assert (layer);
+  g_assert (samplerate);
+  g_assert (bitrate);
+  g_assert (channels);
+
+  new = GST_CAPS_NEW ("mp3_type_find",
+		      "audio/mpeg",
+			"mpegversion", GST_PROPS_INT (1),
+			"layer",       GST_PROPS_INT (layer),
+			/*"bitrate",     GST_PROPS_INT (bitrate),*/
+			"rate",        GST_PROPS_INT (samplerate),
+			"channels",    GST_PROPS_INT (channels));
+
+  return new;
+}
+
+static GstCaps *
+mp3_type_find (GstByteStream *bs, gpointer private)
+{
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
+  guint8 *data;
+  guint size;
+  guint32 head;
+  guint layer = 0, bitrate = 0, samplerate = 0, channels = 0;
+
+  /* note that even if we don't get the requested size,
+   * it might still be a (very small) mp3 */
+  gst_bytestream_peek (bs, &buf, GST_MP3_TYPEFIND_MIN_DATA);
+  if (!buf) {
+    goto done;
+  }
+  
+  data = GST_BUFFER_DATA (buf);
+  size = GST_BUFFER_SIZE (buf);
+  
+  while (size >= 4) {
+    head = GUINT32_FROM_BE(*((guint32 *)data));
+    if ((head & 0xffe00000) == 0xffe00000) {
+      guint length;
+      guint prev_layer = 0, prev_bitrate = 0,
+	    prev_channels = 0, prev_samplerate = 0;
+      guint found = 0; /* number of valid headers found */
+      guint pos = 0;
+
+      do {
+        if (!(length = mp3_type_frame_length_from_header (head, &layer,
+							  &channels, &bitrate,
+							  &samplerate))) {
+          break;
+	}
+	if ((prev_layer && prev_layer != layer) || !layer ||
+	    (prev_bitrate && prev_bitrate != bitrate) || !bitrate ||
+	    (prev_samplerate && prev_samplerate != samplerate) || !samplerate ||
+	    (prev_channels && prev_channels != channels) || !channels) {
+          /* this means an invalid property, or a change, which likely
+	   * indicates that this is not a mp3 but just a random bytestream */
+	  break;
+	}
+	prev_layer = layer;
+	prev_bitrate = bitrate;
+	prev_channels = channels;
+	prev_samplerate = samplerate;
+	pos += length;
+	if (++found >= GST_MP3_TYPEFIND_MIN_HEADERS) {
+          /* we're pretty sure that this is mp3 now */
+          new = mp3_caps_create (layer, channels, bitrate, samplerate);
+	  goto done;
+        }
+
+        /* and now, find a new head */
+        head = GUINT32_FROM_BE(*((guint32 *) &(data[pos])));  
+        if ((head & 0xffe00000) != 0xffe00000)
+	  break;
+      } while (TRUE);
+    }
+    data++;
+    size--;
+  }
+
+done:
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return new;
+}
+
 static void
 gst_mp3parse_class_init (GstMPEGAudioParseClass *klass)
 {
@@ -247,7 +466,10 @@
         header2 = GUINT32_FROM_BE(*((guint32 *)(data+offset+bpf)));
         GST_DEBUG ("mp3parse: header=%08X, header2=%08X, bpf=%d", (unsigned int)header, (unsigned int)header2, bpf );
 
-        #define HDRMASK ~( (0xF<<12)/*bitrate*/ | (1<<9)/*padding*/ | (3<<4)/*mode extension*/ ) /* mask the bits which are allowed to differ between frames */
+/* mask the bits which are allowed to differ between frames */
+#define HDRMASK ~((0xF << 12)  /* bitrate */ | \
+		  (0x1 <<  9)  /* padding */ | \
+		  (0x3 <<  4)) /*mode extension*/
 
         if ( (header2&HDRMASK) != (header&HDRMASK) ) { /* require 2 matching headers in a row */
            GST_DEBUG ("mp3parse: next header doesn't match (header=%08X, header2=%08X, bpf=%d)", (unsigned int)header, (unsigned int)header2, bpf );
@@ -309,56 +531,23 @@
   }
 }
 
-static int mp3parse_tabsel[2][3][16] =
-{ { {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, },
-    {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, },
-    {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, } },
-  { {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, },
-    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, },
-    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, } },
-};
-
-static long mp3parse_freqs[9] =
-{44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000};
-
-
 static long
 bpf_from_header (GstMPEGAudioParse *parse, unsigned long header)
 {
-  int layer_index,layer,lsf,samplerate_index,padding,mode;
-  long bpf;
-  gint channels, rate;
-
-  /*mpegver = (header >> 19) & 0x3; // don't need this for bpf */
-  layer_index = (header >> 17) & 0x3;
-  layer = 4 - layer_index;
-  lsf = (header & (1 << 20)) ? ((header & (1 << 19)) ? 0 : 1) : 1;
-  parse->bit_rate = mp3parse_tabsel[lsf][layer - 1][((header >> 12) & 0xf)];
-  samplerate_index = (header >> 10) & 0x3;
-  padding = (header >> 9) & 0x1;
-  mode = (header >> 6) & 0x3;
+  guint bitrate, layer, rate, channels, length;
 
-  if (layer == 1) {
-    bpf = parse->bit_rate * 12000;
-    bpf /= mp3parse_freqs[samplerate_index];
-    bpf = ((bpf + padding) << 2);
-  } else {
-    bpf = parse->bit_rate * 144000;
-    bpf /= mp3parse_freqs[samplerate_index];
-    bpf += padding;
+  if (!(length = mp3_type_frame_length_from_header (header, &layer,
+						    &channels,
+						    &bitrate, &rate))) {
+    return 0;
   }
 
-  channels = (mode == 3) ? 1 : 2;
-  rate = mp3parse_freqs[samplerate_index];
   if (channels != parse->channels ||
       rate     != parse->rate     ||
-      layer    != parse->layer) {
-    GstCaps *caps = GST_CAPS_NEW ("mp3parse_src",
-                                  "audio/mpeg",
-                                    "mpegversion", GST_PROPS_INT (1),
-                                    "layer",    GST_PROPS_INT (layer),
-                                    "channels", GST_PROPS_INT (channels),
-                                    "rate",     GST_PROPS_INT (rate));
+      layer    != parse->layer    ||
+      bitrate  != parse->bit_rate) {
+    GstCaps *caps = mp3_caps_create (layer, channels, bitrate, rate);
+
     if (gst_pad_try_set_caps(parse->srcpad, caps) <= 0) {
       gst_element_error (GST_ELEMENT (parse),
                          "mp3parse: failed to negotiate format with next element");
@@ -367,12 +556,10 @@
     parse->channels = channels;
     parse->layer    = layer;
     parse->rate     = rate;
+    parse->bit_rate = bitrate;
   }
 
-  /*g_print("%08x: layer %d lsf %d bitrate %d samplerate_index %d padding %d - bpf %d\n", */
-/*header,layer,lsf,bitrate,samplerate_index,padding,bpf); */
-
-  return bpf;
+  return length;
 }
 
 static gboolean
@@ -470,6 +657,7 @@
 plugin_init (GModule *module, GstPlugin *plugin)
 {
   GstElementFactory *factory;
+  GstTypeFactory *type;
 
   /* create an elementfactory for the mp3parse element */
   factory = gst_element_factory_new ("mp3parse",
@@ -484,6 +672,10 @@
   gst_element_factory_add_pad_template (factory, src_temp);
 
   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  /* type finding */
+  type = gst_type_factory_new (&mp3type_definition);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
 
   return TRUE;
 }
Index: qtdemux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/qtdemux/qtdemux.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- qtdemux.c	19 Jul 2003 23:47:41 -0000	1.21
+++ qtdemux.c	1 Oct 2003 13:14:50 -0000	1.22
@@ -104,7 +104,7 @@
   "(C) 2003",
 };
 
-static GstCaps* quicktime_type_find (GstBuffer *buf, gpointer private);
+static GstCaps* quicktime_type_find (GstByteStream *bs, gpointer private);
 
 static GstTypeDefinition quicktimedefinition = {
   "qtdemux_video/quicktime",
@@ -187,24 +187,29 @@
 }
 
 static GstCaps*
-quicktime_type_find (GstBuffer *buf, gpointer private)
+quicktime_type_find (GstByteStream *bs, gpointer private)
 {
-  gchar *data = GST_BUFFER_DATA (buf);
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
-  g_return_val_if_fail (data != NULL, NULL);
-  
-  if(GST_BUFFER_SIZE(buf) < 8){
-    return NULL;
+  if (gst_bytestream_peek (bs, &buf, 8) == 8) {
+    gchar *data = GST_BUFFER_DATA (buf);
+
+    if (!strncmp (&data[4], "wide", 4) ||
+        !strncmp (&data[4], "moov", 4) ||
+        !strncmp (&data[4], "mdat", 4) ||
+        !strncmp (&data[4], "free", 4)) {
+      new = GST_CAPS_NEW ("quicktime_type_find",
+			  "video/quicktime",
+			    NULL);
+    }
   }
-  if (strncmp (&data[4], "wide", 4)==0 ||
-      strncmp (&data[4], "moov", 4)==0 ||
-      strncmp (&data[4], "mdat", 4)==0 ||
-      strncmp (&data[4], "free", 4)==0) {
-    return gst_caps_new ("quicktime_type_find",
-		         "video/quicktime", 
-			 NULL);
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
   }
-  return NULL;
+
+  return new;
 }
 
 static gboolean
@@ -221,9 +226,6 @@
     0,
   };
   gint i;
-
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   factory = gst_element_factory_new ("qtdemux", GST_TYPE_QTDEMUX,
                                      &gst_qtdemux_details);
Index: qtdemux.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/qtdemux/qtdemux.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- qtdemux.h	16 Jun 2003 17:39:26 -0000	1.3
+++ qtdemux.h	1 Oct 2003 13:14:50 -0000	1.4
@@ -22,7 +22,7 @@
 #define __GST_QTDEMUX_H__
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #ifdef __cplusplus
 extern "C" {
Index: gstmpegdemux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstmpegdemux.c,v
retrieving revision 1.39
retrieving revision 1.40
diff -u -d -r1.39 -r1.40
--- gstmpegdemux.c	28 Jul 2003 14:56:01 -0000	1.39
+++ gstmpegdemux.c	1 Oct 2003 13:14:49 -0000	1.40
@@ -1235,10 +1235,6 @@
 {
   GstElementFactory *factory;
 
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
-
   /* create an elementfactory for the mpeg_demux element */
   factory = gst_element_factory_new ("mpegdemux", GST_TYPE_MPEG_DEMUX,
                                      &mpeg_demux_details);
Index: gstmpegpacketize.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstmpegpacketize.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- gstmpegpacketize.h	26 May 2002 21:59:22 -0000	1.7
+++ gstmpegpacketize.h	1 Oct 2003 13:14:49 -0000	1.8
@@ -24,7 +24,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 
 #ifdef __cplusplus
Index: gstmpegparse.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstmpegparse.c,v
retrieving revision 1.42
retrieving revision 1.43
diff -u -d -r1.42 -r1.43
--- gstmpegparse.c	16 Sep 2003 09:59:59 -0000	1.42
+++ gstmpegparse.c	1 Oct 2003 13:14:49 -0000	1.43
@@ -915,10 +915,6 @@
 {
   GstElementFactory *factory;
 
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
-
   /* create an elementfactory for the mpeg_parse element */
   factory = gst_element_factory_new ("mpegparse", GST_TYPE_MPEG_PARSE,
                                      &mpeg_parse_details);
Index: gstmpegparse.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstmpegparse.h,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- gstmpegparse.h	19 Jan 2003 13:42:43 -0000	1.14
+++ gstmpegparse.h	1 Oct 2003 13:14:49 -0000	1.15
@@ -22,7 +22,7 @@
 #define __MPEG_PARSE_H__
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include "gstmpegpacketize.h"
 
 #ifdef __cplusplus
Index: gstmpegstream.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstmpegstream.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- gstmpegstream.c	9 Sep 2002 23:24:29 -0000	1.6
+++ gstmpegstream.c	1 Oct 2003 13:14:49 -0000	1.7
@@ -25,10 +25,6 @@
 static gboolean
 plugin_init (GModule *module, GstPlugin *plugin)
 {
-  /* mpegdemux needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
-
   /* short-circuit here; this is potentially dangerous since if the second
    * or third init fails then the whole plug-in will be placed on the register
    * stack again and the first _init will be called more than once
Index: gstrfc2250enc.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstrfc2250enc.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- gstrfc2250enc.c	29 Jun 2003 19:45:47 -0000	1.11
+++ gstrfc2250enc.c	1 Oct 2003 13:14:49 -0000	1.12
@@ -328,10 +328,6 @@
 {
   GstElementFactory *factory;
 
-  /* this filter needs the bytestream package */
-  if (!gst_library_load("gstbytestream"))
-    return FALSE;
-
   /* create an elementfactory for the rfc2250_enc element */
   factory = gst_element_factory_new ("rfc2250enc", GST_TYPE_RFC2250_ENC,
                                      &rfc2250_enc_details);
Index: gstrfc2250enc.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegstream/gstrfc2250enc.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- gstrfc2250enc.h	20 Mar 2002 21:44:57 -0000	1.2
+++ gstrfc2250enc.h	1 Oct 2003 13:14:49 -0000	1.3
@@ -24,7 +24,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include "gstmpegpacketize.h"

CVS Root:       /cvsroot/gstreamer
Module:         gst-plugins
Changes by:     rbultje
Date:           Wed Oct 01 2003  06:15:22 PDT

Log message:
New typefind system:
* bytestream is now part of the core
* all plugins have been modified to use this new typefind system
* asf typefinding added
* mpeg video stream typefiding removed because it's broken
* duplicate typefind entries removed
* extra id3 typefinding added, because we've seen 4 types of files
(riff/wav, flac, vorbis, mp3) with id3 headers and each of these needs
to work. Instead, I've added an id3 element and let it redo typefiding
after the id3 header. this needs a hack because spider only typefinds
once. We can remove this hack once spider supports multiple typefinds.
* with all this, mp3 typefinding is semi-rewritten
* id3 typefinding in flac/vorbis is removed, it's no longer needed
* fixed spider and gst-typefind to use this, too.
* Other general cleanups

Modified files:
    .               : configure.ac
    ext             : Makefile.am
    ext/a52dec      : gsta52dec.c gsta52dec.h
    ext/alsa        : gstalsa.c
    ext/audiofile   : gstafparse.c gstafparse.h
    ext/dv          : gstdvdec.c gstdvdec.h
    ext/ffmpeg      : gstffmpeg.c gstffmpegdemux.c gstffmpegprotocol.c
    ext/flac        : gstflac.c gstflacdec.h
    ext/ivorbis     : vorbis.c vorbisfile.c
    ext/jack        : gstjack.h
    ext/ladspa      : gstladspa.c gstladspa.h
    ext/mad         : gstmad.c
    ext/matroska    : gstmatroska-io.h gstmatroskademux.cpp
                      gstmatroskademux.h
    ext/mplex       : gstmplex.h
    ext/vorbis      : vorbis.c vorbisfile.c
    gst/adder       : gstadder.c gstadder.h
    gst/asfdemux    : gstasfdemux.c gstasfdemux.h gstasfmux.c
    gst/auparse     : gstauparse.c
    gst/avi         : gstavidemux.c gstavidemux.h
    gst/cdxaparse   : gstcdxaparse.c gstcdxaparse.h
    gst/festival    : gstfestival.c
    gst/flx         : gstflxdec.c gstflxdec.h
    gst/intfloat    : gstfloat2int.c gstfloat2int.h
    gst/mixmatrix   : mixmatrix.c

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/configure.ac.diff?r1=1.296&r2=1.297
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/Makefile.am.diff?r1=1.80&r2=1.81
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/a52dec/gsta52dec.c.diff?r1=1.23&r2=1.24
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/a52dec/gsta52dec.h.diff?r1=1.4&r2=1.5
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/alsa/gstalsa.c.diff?r1=1.69&r2=1.70
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/audiofile/gstafparse.c.diff?r1=1.15&r2=1.16
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/audiofile/gstafparse.h.diff?r1=1.2&r2=1.3
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/dv/gstdvdec.c.diff?r1=1.40&r2=1.41
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/dv/gstdvdec.h.diff?r1=1.8&r2=1.9
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ffmpeg/gstffmpeg.c.diff?r1=1.9&r2=1.10
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ffmpeg/gstffmpegdemux.c.diff?r1=1.10&r2=1.11
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ffmpeg/gstffmpegprotocol.c.diff?r1=1.5&r2=1.6
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/flac/gstflac.c.diff?r1=1.13&r2=1.14
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/flac/gstflacdec.h.diff?r1=1.4&r2=1.5
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ivorbis/vorbis.c.diff?r1=1.5&r2=1.6
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ivorbis/vorbisfile.c.diff?r1=1.8&r2=1.9
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/jack/gstjack.h.diff?r1=1.8&r2=1.9
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ladspa/gstladspa.c.diff?r1=1.37&r2=1.38
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/ladspa/gstladspa.h.diff?r1=1.6&r2=1.7
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/mad/gstmad.c.diff?r1=1.70&r2=1.71
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/matroska/gstmatroska-io.h.diff?r1=1.1&r2=1.2
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/matroska/gstmatroskademux.cpp.diff?r1=1.6&r2=1.7
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/matroska/gstmatroskademux.h.diff?r1=1.2&r2=1.3
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/mplex/gstmplex.h.diff?r1=1.3&r2=1.4
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/vorbis/vorbis.c.diff?r1=1.13&r2=1.14
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/ext/vorbis/vorbisfile.c.diff?r1=1.38&r2=1.39
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/adder/gstadder.c.diff?r1=1.34&r2=1.35
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/adder/gstadder.h.diff?r1=1.5&r2=1.6
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/asfdemux/gstasfdemux.c.diff?r1=1.21&r2=1.22
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/asfdemux/gstasfdemux.h.diff?r1=1.6&r2=1.7
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/asfdemux/gstasfmux.c.diff?r1=1.4&r2=1.5
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/auparse/gstauparse.c.diff?r1=1.19&r2=1.20
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/avi/gstavidemux.c.diff?r1=1.78&r2=1.79
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/avi/gstavidemux.h.diff?r1=1.14&r2=1.15
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/cdxaparse/gstcdxaparse.c.diff?r1=1.8&r2=1.9
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/cdxaparse/gstcdxaparse.h.diff?r1=1.1&r2=1.2
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/festival/gstfestival.c.diff?r1=1.6&r2=1.7
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/flx/gstflxdec.c.diff?r1=1.26&r2=1.27
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/flx/gstflxdec.h.diff?r1=1.4&r2=1.5
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/intfloat/gstfloat2int.c.diff?r1=1.43&r2=1.44
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/intfloat/gstfloat2int.h.diff?r1=1.13&r2=1.14
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mixmatrix/mixmatrix.c.diff?r1=1.12&r2=1.13

====Begin Diffs====
Index: configure.ac
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/configure.ac,v
retrieving revision 1.296
retrieving revision 1.297
diff -u -d -r1.296 -r1.297
--- configure.ac	30 Sep 2003 21:44:53 -0000	1.296
+++ configure.ac	1 Oct 2003 13:14:40 -0000	1.297
@@ -262,7 +262,7 @@
 	ac3parse adder audioscale auparse avi \
 	asfdemux audioconvert cdxaparse chart \
 	cutter debug deinterlace effectv festival \
-	filter flx goom intfloat law level median mixmatrix \
+	filter flx goom id3 intfloat law level median mixmatrix \
 	mpeg1sys mpeg1videoparse mpeg2enc mpeg2sub \
 	mpegaudio mpegaudioparse mpegstream mpegtypes \
         monoscope oneton overlay passthrough playondemand qtdemux \
@@ -1180,6 +1180,7 @@
 gst/filter/Makefile
 gst/flx/Makefile
 gst/goom/Makefile
+gst/id3/Makefile
 gst/intfloat/Makefile
 gst/law/Makefile
 gst/level/Makefile
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/Makefile.am,v
retrieving revision 1.80
retrieving revision 1.81
diff -u -d -r1.80 -r1.81
--- Makefile.am	27 Jul 2003 05:29:10 -0000	1.80
+++ Makefile.am	1 Oct 2003 13:14:40 -0000	1.81
@@ -278,8 +278,9 @@
 	$(ARTS_DIR) $(ARTSC_DIR) $(AUDIOFILE_DIR) \
 	$(CDPARANOIA_DIR) $(DIVX_DIR) \
 	$(DVDREAD_DIR) $(DVDNAV_DIR) $(ESD_DIR) $(MAS_DIR) \
-	$(FFMPEG_DIR) $(FLAC_DIR) $(GDK_PIXBUF_DIR) $(GNOMEVFS_DIR) $(GSM_DIR) \
-	$(HERMES_DIR) $(JACK_DIR) $(JPEG_DIR) \
+	$(FFMPEG_DIR) $(FLAC_DIR) $(GDK_PIXBUF_DIR) \
+	$(GNOMEVFS_DIR) $(GSM_DIR) $(HERMES_DIR) \
+	$(JACK_DIR) $(JPEG_DIR) \
 	$(LADSPA_DIR) $(LAME_DIR) $(LCS_DIR) \
 	$(LIBDV_DIR) $(LIBFAME_DIR) $(LIBPNG_DIR) \
 	$(MAD_DIR) $(MATROSKA_DIR) $(MIKMOD_DIR) \
Index: gsta52dec.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/a52dec/gsta52dec.c,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- gsta52dec.c	16 Sep 2003 09:59:51 -0000	1.23
+++ gsta52dec.c	1 Oct 2003 13:14:40 -0000	1.24
@@ -619,10 +619,6 @@
 {
   GstElementFactory *factory;
 
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
-
   /* create an elementfactory for the a52dec element */
   factory = gst_element_factory_new ("a52dec", GST_TYPE_A52DEC, &gst_a52dec_details);
   g_return_val_if_fail (factory != NULL, FALSE);
Index: gsta52dec.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/a52dec/gsta52dec.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- gsta52dec.h	18 Jan 2003 17:06:01 -0000	1.4
+++ gsta52dec.h	1 Oct 2003 13:14:41 -0000	1.5
@@ -23,7 +23,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 G_BEGIN_DECLS
 
Index: gstalsa.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/alsa/gstalsa.c,v
retrieving revision 1.69
retrieving revision 1.70
diff -u -d -r1.69 -r1.70
--- gstalsa.c	16 Sep 2003 09:59:52 -0000	1.69
+++ gstalsa.c	1 Oct 2003 13:14:41 -0000	1.70
@@ -2351,9 +2351,6 @@
 {
   GstElementFactory *factory;
 
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
-
   factory = gst_element_factory_new ("alsasrc", GST_TYPE_ALSA_SRC, &gst_alsa_src_details);
   g_return_val_if_fail (factory != NULL, FALSE);
   gst_element_factory_add_pad_template (factory, gst_alsa_src_pad_factory ());
Index: gstafparse.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/audiofile/gstafparse.c,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- gstafparse.c	6 Jul 2003 20:49:13 -0000	1.15
+++ gstafparse.c	1 Oct 2003 13:14:42 -0000	1.16
@@ -337,8 +337,7 @@
   /* load audio support library */
   if (!gst_library_load ("gstaudio"))
     return FALSE;
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
+
   return TRUE;
 }
 
Index: gstafparse.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/audiofile/gstafparse.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- gstafparse.h	26 May 2002 21:59:20 -0000	1.2
+++ gstafparse.h	1 Oct 2003 13:14:42 -0000	1.3
@@ -27,7 +27,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include <audiofile.h>			/* what else are we to do */
 #include <af_vfs.h>
 
Index: gstdvdec.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/dv/gstdvdec.c,v
retrieving revision 1.40
retrieving revision 1.41
diff -u -d -r1.40 -r1.41
--- gstdvdec.c	16 Sep 2003 09:59:52 -0000	1.40
+++ gstdvdec.c	1 Oct 2003 13:14:43 -0000	1.41
@@ -159,30 +159,34 @@
 
 /* typefind stuff */
 static GstCaps*
-dv_type_find (GstBuffer *buf, gpointer private)
+dv_type_find (GstByteStream *bs, gpointer private)
 {
-  guint32 head;
+  GstBuffer *buf = NULL;
   GstCaps *new = NULL;
 
-  if (GST_BUFFER_SIZE (buf) < 5)
-    return NULL;
-
-  head = GUINT32_FROM_BE(*((guint32 *)GST_BUFFER_DATA(buf)));
+  if (gst_bytestream_peek (bs, &buf, 5) == 5) {
+    guint32 head = GUINT32_FROM_BE (*((guint32 *) GST_BUFFER_DATA (buf)));
 
-  /* check for DIF  and DV flag */
-  if ((head & 0xffffff00) == 0x1f070000 && !(GST_BUFFER_DATA(buf)[4] & 0x01)) {
-    gchar *format;
+    /* check for DIF  and DV flag */
+    if ((head & 0xffffff00) == 0x1f070000 &&
+        !(GST_BUFFER_DATA (buf)[4] & 0x01)) {
+      gchar *format;
 
-    if ((head & 0x000000ff) & 0x80)
-      format = "PAL";
-    else
-      format = "NTSC";
+      if ((head & 0x000000ff) & 0x80)
+        format = "PAL";
+      else
+        format = "NTSC";
     
-    new = GST_CAPS_NEW ("dv_type_find",
-                        "video/x-dv",
-                          "systemstream", GST_PROPS_BOOLEAN (TRUE)
-		       );
+      new = GST_CAPS_NEW ("dv_type_find",
+                          "video/x-dv",
+                          "systemstream", GST_PROPS_BOOLEAN (TRUE));
+    }
+  }
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
   }
+
   return new;
 }
 
@@ -1001,9 +1005,6 @@
 {
   GstElementFactory *factory;
   GstTypeFactory *type;
-
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   /* We need to create an ElementFactory for each element we provide.
    * This consists of the name of the element, the GType identifier,
Index: gstdvdec.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/dv/gstdvdec.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- gstdvdec.h	2 Nov 2002 13:34:42 -0000	1.8
+++ gstdvdec.h	1 Oct 2003 13:14:43 -0000	1.9
@@ -29,7 +29,7 @@
 
 
 #include <libdv/dv.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 
 /* This is the definition of the element's object structure. */
Index: gstjack.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/jack/gstjack.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- gstjack.h	30 Sep 2003 12:56:27 -0000	1.8
+++ gstjack.h	1 Oct 2003 13:14:44 -0000	1.9
@@ -22,7 +22,7 @@
 
 #include <jack/jack.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 //#define JACK_DEBUG(str, a...) g_message (str, ##a)
 #define JACK_DEBUG(str, a...)
Index: gstflac.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/flac/gstflac.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- gstflac.c	20 Sep 2003 19:34:31 -0000	1.13
+++ gstflac.c	1 Oct 2003 13:14:43 -0000	1.14
@@ -26,7 +26,7 @@
 extern GstElementDetails flacenc_details;
 extern GstElementDetails flacdec_details;
 
-static GstCaps* 	flac_type_find 	(GstBuffer *buf, gpointer private);
+static GstCaps* 	flac_type_find 	(GstByteStream *bs, gpointer private);
 
 GstPadTemplate *gst_flacdec_src_template, *gst_flacdec_sink_template; 
 GstPadTemplate *gst_flacenc_src_template, *gst_flacenc_sink_template;
@@ -70,37 +70,26 @@
 
 
 static GstCaps* 
-flac_type_find (GstBuffer *buf, gpointer private) 
+flac_type_find (GstByteStream *bs, gpointer private) 
 {
-  gint offset;
-  guint8 *data;
-  gint size;
-  guint32 head;
-  
-  if (GST_BUFFER_SIZE (buf) < 4)
-    return NULL;
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
-  data = GST_BUFFER_DATA (buf);
-  size = GST_BUFFER_SIZE (buf);
-  
-  head = GUINT32_FROM_BE (*((guint32 *)GST_BUFFER_DATA (buf)));
+  if (gst_bytestream_peek (bs, &buf, 4) == 4) {
+    guint32 head = GUINT32_FROM_BE (*((guint32 *) GST_BUFFER_DATA (buf)));
 
-  if (head  == 0x664C6143)
-    return gst_caps_new ("flac_type_find", "application/x-flac", NULL);
-  else {
-    /* checks for existance of flac identification header in case
-     * there's an ID3 tag */
-    for (offset = 0; offset < size-4; offset++) {
-      if (data[offset]   == 'f' && 
-          data[offset+1] == 'L' && 
-          data[offset+2] == 'a' &&
-          data[offset+3] == 'C' ) {
-        return gst_caps_new ("flac_type_find", "application/x-flac", NULL);
-      }
+    if (head  == 0x664C6143) {
+      new = GST_CAPS_NEW ("flac_type_find",
+			  "application/x-flac",
+			    NULL);
     }
   }
 
-  return NULL;
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return new;
 }
 
 
@@ -110,10 +99,6 @@
   GstElementFactory *enc, *dec;
   GstTypeFactory *type;
   GstCaps *raw_caps, *flac_caps;
-
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   gst_plugin_set_longname (plugin, "The FLAC Lossless compressor Codec");
 
Index: gstflacdec.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/flac/gstflacdec.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- gstflacdec.h	27 Apr 2003 12:00:41 -0000	1.4
+++ gstflacdec.h	1 Oct 2003 13:14:43 -0000	1.5
@@ -24,7 +24,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #include <FLAC/all.h>
 
Index: vorbis.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ivorbis/vorbis.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- vorbis.c	24 Jul 2003 08:49:42 -0000	1.5
+++ vorbis.c	1 Oct 2003 13:14:44 -0000	1.6
@@ -21,7 +21,7 @@
 #include <gst/gst.h>
 #include <tremor/ivorbiscodec.h>
 #include <tremor/ivorbisfile.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 extern GType ivorbisfile_get_type(void);
 
@@ -131,10 +131,6 @@
   gst_element_factory_add_pad_template (file, gst_vorbisdec_src_template);
   
   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (file));
-
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   type = gst_type_factory_new (&vorbisdefinition);
   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
Index: vorbisfile.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ivorbis/vorbisfile.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- vorbisfile.c	16 Sep 2003 09:59:54 -0000	1.8
+++ vorbisfile.c	1 Oct 2003 13:14:44 -0000	1.9
@@ -24,7 +24,7 @@
 #include <gst/gst.h>
 #include <tremor/ivorbiscodec.h>
 #include <tremor/ivorbisfile.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #define GST_TYPE_IVORBISFILE \
   (ivorbisfile_get_type())
Index: gstffmpeg.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ffmpeg/gstffmpeg.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- gstffmpeg.c	6 Jul 2003 20:49:15 -0000	1.9
+++ gstffmpeg.c	1 Oct 2003 13:14:43 -0000	1.10
@@ -46,9 +46,6 @@
   avcodec_register_all ();
   av_register_all ();
 
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
-
   gst_ffmpegenc_register (plugin);
   gst_ffmpegdec_register (plugin);
   /*gst_ffmpegdemux_register (plugin);*/
Index: gstffmpegdemux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ffmpeg/gstffmpegdemux.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- gstffmpegdemux.c	16 Sep 2003 09:59:53 -0000	1.10
+++ gstffmpegdemux.c	1 Oct 2003 13:14:43 -0000	1.11
@@ -161,24 +161,27 @@
 }
 
 static GstCaps*
-gst_ffmpegdemux_typefind (GstBuffer *buffer,
-			  gpointer   priv)
+gst_ffmpegdemux_typefind (GstByteStream *bs,
+			  gpointer       priv)
 {
   GstFFMpegDemuxClassParams *params;
   AVInputFormat *in_plugin;
   gint res = 0;
   gint required = AVPROBE_SCORE_MAX * 0.8; /* 80% certainty enough? */
+  gint size_required = 4096;
+  GstBuffer *buf = NULL;
   
   params = g_hash_table_lookup (typefind, priv);
 
   in_plugin = params->in_plugin;
 
-  if (in_plugin->read_probe) {
+  if (in_plugin->read_probe &&
+      gst_bytestream_peek (bs, &buf, size_required) == size_required) {
     AVProbeData probe_data;
 
     probe_data.filename = "";
-    probe_data.buf = GST_BUFFER_DATA (buffer);
-    probe_data.buf_size = GST_BUFFER_SIZE (buffer);
+    probe_data.buf = GST_BUFFER_DATA (buf);
+    probe_data.buf_size = GST_BUFFER_SIZE (buf);
 
     res = in_plugin->read_probe (&probe_data);
     if (res >= required) {
@@ -186,10 +189,15 @@
       caps = GST_PAD_TEMPLATE_CAPS (params->sinktempl);
       /* make sure we still hold a refcount to this caps */
       gst_caps_ref (caps);
+      gst_buffer_unref (buf);
       return caps;
     }
   }
-	
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
   return NULL;
 }
 
Index: gstffmpegprotocol.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ffmpeg/gstffmpegprotocol.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- gstffmpegprotocol.c	8 Jun 2003 14:35:32 -0000	1.5
+++ gstffmpegprotocol.c	1 Oct 2003 13:14:43 -0000	1.6
@@ -27,7 +27,7 @@
 #endif
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 
 typedef struct _GstProtocolInfo GstProtocolInfo;
Index: gstmad.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/mad/gstmad.c,v
retrieving revision 1.70
retrieving revision 1.71
diff -u -d -r1.70 -r1.71
--- gstmad.c	16 Sep 2003 09:59:54 -0000	1.70
+++ gstmad.c	1 Oct 2003 13:14:44 -0000	1.71
@@ -139,6 +139,7 @@
     "mad_sink",
     "audio/mpeg",
       /* we don't need channel/rate ... */
+      "mpegversion", GST_PROPS_INT (1),
       "layer", GST_PROPS_INT_RANGE (1, 3)
   )
 )
@@ -1184,15 +1185,13 @@
 	                          mad->stream.bufend - mad->stream.this_frame);
 
 	  if (tagsize > mad->tempsize) {
-            GST_INFO (
-		      "mad: got partial id3 tag in buffer, skipping");
+            GST_INFO ("mad: got partial id3 tag in buffer, skipping");
 	  }
 	  else if (tagsize > 0) {
 	    struct id3_tag *tag;
 	    id3_byte_t const *data;
 
-            GST_INFO (
-		      "mad: got ID3 tag size %ld", tagsize);
+            GST_INFO ("mad: got ID3 tag size %ld", tagsize);
 
 	    data = mad->stream.this_frame;
 
Index: gstladspa.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ladspa/gstladspa.c,v
retrieving revision 1.37
retrieving revision 1.38
diff -u -d -r1.37 -r1.38
--- gstladspa.c	16 Sep 2003 09:59:54 -0000	1.37
+++ gstladspa.c	1 Oct 2003 13:14:44 -0000	1.38
@@ -993,9 +993,6 @@
 
   LADSPAPluginSearch(ladspa_describe_plugin);
 
-  if (! gst_library_load ("gstbytestream"))
-    return FALSE;
-  
   /* initialize dparam support library */
   gst_control_init(NULL,NULL);
   
Index: gstladspa.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/ladspa/gstladspa.h,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- gstladspa.h	16 Jul 2003 16:08:12 -0000	1.6
+++ gstladspa.h	1 Oct 2003 13:14:44 -0000	1.7
@@ -26,7 +26,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #include "ladspa.h"
 
Index: gstmplex.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/mplex/gstmplex.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- gstmplex.h	25 Oct 2002 20:46:12 -0000	1.3
+++ gstmplex.h	1 Oct 2003 13:14:45 -0000	1.4
@@ -26,7 +26,7 @@
 #include <stdlib.h>
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #include "outputstream.hh"
 #include "bits.hh"
Index: gstmatroska-io.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/matroska/gstmatroska-io.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- gstmatroska-io.h	14 Jul 2003 17:37:05 -0000	1.1
+++ gstmatroska-io.h	1 Oct 2003 13:14:45 -0000	1.2
@@ -21,7 +21,7 @@
 #define __GST_MATROSKA_IO_H__
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include <IOCallback.h>
 
 using namespace std;
Index: gstmatroskademux.cpp
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/matroska/gstmatroskademux.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- gstmatroskademux.cpp	12 Sep 2003 11:36:24 -0000	1.6
+++ gstmatroskademux.cpp	1 Oct 2003 13:14:45 -0000	1.7
@@ -74,8 +74,8 @@
   "(C) 2003",
 };
 
-static GstCaps * gst_matroska_type_find (GstBuffer *buf,
-					 gpointer   priv);
+static GstCaps * gst_matroska_type_find (GstByteStream *bs,
+					 gpointer      priv);
 
 /* typefactory for 'matroska' */
 static GstTypeDefinition matroskadefinition = {
@@ -251,23 +251,28 @@
 }
 
 static GstCaps *
-gst_matroska_type_find (GstBuffer *buf,
-			gpointer   priv)
+gst_matroska_type_find (GstByteStream *bs,
+			gpointer       priv)
 {
-  guint8 header[16] = { 0x1A, 0x45, 0xDF, 0xA3, 0x93, 0x42, 0x82, 0x88,
-			'm', 'a', 't', 'r', 'o', 's', 'k', 'a' };
-  GST_DEBUG ("matroska_demux: typefind");
+  GstBuffer *buf = NULL;
+  GstCaps *newc = NULL;
 
-  if (GST_BUFFER_SIZE (buf) >= 16 &&
-      memcmp(GST_BUFFER_DATA (buf), header, 16) == 0) {
-    GST_DEBUG ("matroska type found!");
-    return GST_CAPS_NEW ("matroska_type",
-			 "video/x-matroska",
-			   NULL);
+  if (gst_bytestream_peek (bs, &buf, 16) == 16) {
+    guint8 header[16] = { 0x1A, 0x45, 0xDF, 0xA3, 0x93, 0x42, 0x82, 0x88,
+			  'm', 'a', 't', 'r', 'o', 's', 'k', 'a' };
+
+    if (!memcmp(GST_BUFFER_DATA (buf), header, 16)) {
+      newc = GST_CAPS_NEW ("matroska_type",
+			   "video/x-matroska",
+			     NULL);
+    }
   }
 
-  /* nope */
-  return NULL;
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return newc;
 }
 
 static void
@@ -335,15 +340,18 @@
 {
   EbmlElement *child = NULL;
 
-  if (demux->last_level != 0) {
-    g_assert (demux->last_level > 0);
+  if (demux->last_level > 0) {
+    //g_assert (demux->last_level > 0);
     child = demux->last_el;
     demux->last_el = NULL;
     demux->last_level--;
-  } else if (demux->io->eos != TRUE) {
-    g_assert (demux->last_el == NULL);
-    child = demux->str->FindNextElement (parent->Generic ().Context,
-					 demux->last_level, ~0, true, 5);
+  } else {
+    demux->last_level = 0;
+    if (demux->io->eos != TRUE) {
+      //g_assert (demux->last_el == NULL);
+      child = demux->str->FindNextElement (parent->Generic ().Context,
+					   demux->last_level, ~0, true, 5);
+    }
   }
 
   return child;
@@ -1681,7 +1689,8 @@
       res = FALSE;
       break;
     } else if (demux->last_level != 0) {
-      g_assert (0); /* cannot happen, this *is* the top level */
+      //g_assert (0); /* cannot happen, this *is* the top level */
+      demux->last_level = 0;
     }
 
     /* well, cases don't work here since these aren't constants...
Index: gstmatroskademux.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/matroska/gstmatroskademux.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- gstmatroskademux.h	29 Jul 2003 20:55:58 -0000	1.2
+++ gstmatroskademux.h	1 Oct 2003 13:14:45 -0000	1.3
@@ -21,7 +21,7 @@
 #define __GST_MATROSKA_DEMUX_H__
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include "gstmatroska-io.h"
 
 using namespace std;
Index: vorbis.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/vorbis/vorbis.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- vorbis.c	19 Jul 2003 23:25:26 -0000	1.13
+++ vorbis.c	1 Oct 2003 13:14:45 -0000	1.14
@@ -25,7 +25,7 @@
 extern GstElementDetails vorbisfile_details;
 extern GstElementDetails vorbisenc_details;
 
-static GstCaps* 	vorbis_type_find 	(GstBuffer *buf, gpointer private);
+static GstCaps* 	vorbis_type_find 	(GstByteStream *bs, gpointer private);
 
 GstPadTemplate *gst_vorbisdec_src_template, *gst_vorbisdec_sink_template; 
 GstPadTemplate *gst_vorbisenc_src_template, *gst_vorbisenc_sink_template;
@@ -81,40 +81,26 @@
 };
 
 static GstCaps*
-vorbis_type_find (GstBuffer *buf, gpointer private)
+vorbis_type_find (GstByteStream *bs, gpointer private)
 {
-  guint32 head;
-  gint offset;
-  guint8 *data;
-  gint size;
-
-  data = GST_BUFFER_DATA (buf);
-  size = GST_BUFFER_SIZE (buf);
-
-  if (size < sizeof(guint32))
-    return NULL;
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
-  head = GUINT32_FROM_BE (*((guint32 *)data));
+  if (gst_bytestream_peek (bs, &buf, 4) == 4) {
+    guint32 head = GUINT32_FROM_BE (*((guint32 *) GST_BUFFER_DATA (buf)));
 
-  if (head  == 0x4F676753) {
-    return gst_caps_new ("vorbis_type_find", "application/ogg", NULL);
-  } else {
-    /* checks for existance of vorbis identification header in case
-     * there's an ID3 tag */
-    for (offset = 0; offset < size-7; offset++) {
-      if (data[offset] == 0x01 && 
-          data[offset+1] == 'v' && 
-          data[offset+2] == 'o' &&
-          data[offset+3] == 'r' && 
-          data[offset+4] == 'b' &&
-          data[offset+5] == 'i' && 
-          data[offset+6] == 's' ) {
-        return gst_caps_new ("vorbis_type_find", "application/ogg", NULL);
-      }
+    if (head == 0x4F676753) {
+      new = GST_CAPS_NEW ("vorbis_type_find",
+			  "application/ogg",
+			    NULL);
     }
   }
 
-  return NULL;
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return new;
 }
 
 
@@ -171,10 +157,6 @@
   gst_element_factory_add_pad_template (file, gst_vorbisdec_src_template);
   
   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (file));
-
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   type = gst_type_factory_new (&vorbisdefinition);
   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
Index: vorbisfile.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/ext/vorbis/vorbisfile.c,v
retrieving revision 1.38
retrieving revision 1.39
diff -u -d -r1.38 -r1.39
--- vorbisfile.c	16 Sep 2003 09:59:56 -0000	1.38
+++ vorbisfile.c	1 Oct 2003 13:14:45 -0000	1.39
@@ -24,7 +24,7 @@
 #include <gst/gst.h>
 #include <vorbis/codec.h>
 #include <vorbis/vorbisfile.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #define GST_TYPE_VORBISFILE \
   (vorbisfile_get_type())
Index: gstadder.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/adder/gstadder.c,v
retrieving revision 1.34
retrieving revision 1.35
diff -u -d -r1.34 -r1.35
--- gstadder.c	16 Sep 2003 09:59:56 -0000	1.34
+++ gstadder.c	1 Oct 2003 13:14:45 -0000	1.35
@@ -606,9 +606,6 @@
   factory = gst_element_factory_new ("adder", GST_TYPE_ADDER, &adder_details);
   g_return_val_if_fail (factory != NULL, FALSE);
 
-  if (! gst_library_load ("gstbytestream"))
-    return FALSE;
-
   gst_element_factory_add_pad_template (factory,
     GST_PAD_TEMPLATE_GET (gst_adder_src_template_factory));
   gst_element_factory_add_pad_template (factory,
Index: gstadder.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/adder/gstadder.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- gstadder.h	19 Jul 2003 23:16:25 -0000	1.5
+++ gstadder.h	1 Oct 2003 13:14:45 -0000	1.6
@@ -24,7 +24,7 @@
 #define __GST_ADDER_H__
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #ifdef __cplusplus
 extern "C" {
Index: gstauparse.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/auparse/gstauparse.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -d -r1.19 -r1.20
--- gstauparse.c	16 Sep 2003 09:59:57 -0000	1.19
+++ gstauparse.c	1 Oct 2003 13:14:46 -0000	1.20
@@ -42,16 +42,23 @@
 };
 
 static GstCaps*
-au_type_find (GstBuffer *buf, gpointer private)
+au_type_find (GstByteStream *bs, gpointer private)
 {
+  GstBuffer *buf = NULL;
   GstCaps *new = NULL;
-  gulong *head = (gulong *) GST_BUFFER_DATA (buf);
 
-  if (GST_BUFFER_SIZE (buf) < 4)
-    return NULL;
+  if (gst_bytestream_peek (bs, &buf, 4) == 4) {
+    guint32 head = * (guint32 *) GST_BUFFER_DATA (buf);
+    if (head == 0x2e736e64 || head == 0x646e732e) {
+      new = gst_caps_new ("au_type_find",
+			  "audio/x-au",
+			    NULL);
+    }
+  }
 
-  if (*head == 0x2e736e64 || *head == 0x646e732e)
-    new = gst_caps_new ("au_type_find", "audio/x-au", NULL);
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
 
   return new;
 }
Index: gstasfdemux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/asfdemux/gstasfdemux.c,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- gstasfdemux.c	16 Sep 2003 09:59:56 -0000	1.21
+++ gstasfdemux.c	1 Oct 2003 13:14:46 -0000	1.22
@@ -35,123 +35,41 @@
   "(C) 2002",
 };
 
-static GstCaps* asf_asf_type_find (GstBuffer *buf, gpointer private);
-static GstCaps* asf_wma_type_find (GstBuffer *buf, gpointer private);
-static GstCaps* asf_wax_type_find (GstBuffer *buf, gpointer private);
-static GstCaps* asf_wmv_type_find (GstBuffer *buf, gpointer private);
-static GstCaps* asf_wvx_type_find (GstBuffer *buf, gpointer private);
-static GstCaps* asf_wm_type_find (GstBuffer *buf, gpointer private);
+static GstCaps* asf_type_find (GstByteStream *bs, gpointer private);
 
 /* typefactory for 'asf' */
-static GstTypeDefinition asf_type_definitions[] = {
-  { "asfdemux_video/asf",
-    "video/x-ms-asf",
-    ".asf .asx",
-    asf_asf_type_find },
-  { "asfdemux_video/wma",
-    "video/x-ms-wma",
-    ".wma",
-    asf_wma_type_find },
-  { "asfdemux_video/wax",
-    "video/x-ms-wax",
-    ".wax",
-    asf_wax_type_find },
-  { "asfdemux_video/wmv",
-    "video/x-ms-wmv",
-    ".wmv",
-    asf_wmv_type_find },
-  { "asfdemux_video/wvx",
-    "video/x-ms-wvx",
-    ".wvx",
-    asf_wvx_type_find },
-  { "asfdemux_video/wm",
-    "video/x-ms-wm",
-    ".wm",
-    asf_wm_type_find },
-  { NULL, NULL, NULL, NULL }
+static GstTypeDefinition asf_type_definition = {
+  "asfdemux_video/asf",
+  "video/x-ms-asf",
+  /* note: asx/wax/wmx are XML files, we don't handle them */
+  ".asf .wma .wmv .wm",
+  asf_type_find,
 };
 
 static GstCaps*
-asf_asf_type_find (GstBuffer *buf, gpointer private)
-{
-  GstCaps *new;
-
-  new = gst_caps_new (
-                  "asf_type_find",
-                  "video/x-ms-asf",
-                  gst_props_new ("asfversion",
-				 GST_PROPS_INT (1),
-				 NULL));
-  return new;
-}
-
-static GstCaps*
-asf_wma_type_find (GstBuffer *buf, gpointer private)
-{
-  GstCaps *new;
-
-  new = gst_caps_new (
-                  "asf_type_find",
-                  "video/x-ms-asf",
-                  gst_props_new ("asfversion",
-				 GST_PROPS_INT (1),
-				 NULL));
-  return new;
-}
-
-static GstCaps*
-asf_wax_type_find (GstBuffer *buf, gpointer private)
-{
-  GstCaps *new;
-
-  new = gst_caps_new (
-                  "asf_type_find",
-                  "video/x-ms-asf",
-                  gst_props_new ("asfversion",
-				 GST_PROPS_INT (1),
-				 NULL));
-  return new;
-}
-
-static GstCaps*
-asf_wmv_type_find (GstBuffer *buf, gpointer private)
+asf_type_find (GstByteStream *bs, gpointer private)
 {
-  GstCaps *new;
-
-  new = gst_caps_new (
-                  "asf_type_find",
-                  "video/x-ms-asf",
-                  gst_props_new ("asfversion",
-				 GST_PROPS_INT (1),
-				 NULL));
-  return new;
-}
+  GstCaps *new = NULL;
+  GstBuffer *buf = NULL;
 
-static GstCaps*
-asf_wvx_type_find (GstBuffer *buf, gpointer private)
-{
-  GstCaps *new;
+  if (gst_bytestream_peek (bs, &buf, 16) == 16) {
+    guint32 uid1 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[0]),
+	    uid2 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[1]),
+	    uid3 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[2]),
+	    uid4 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[3]);
 
-  new = gst_caps_new (
-                  "asf_type_find",
-                  "video/x-ms-asf",
-                  gst_props_new ("asfversion",
-				 GST_PROPS_INT (1),
-				 NULL));
-  return new;
-}
+    if (uid1 == 0x75B22630 && uid2 == 0x11CF668E &&
+        uid3 == 0xAA00D9A6 && uid4 == 0x6CCE6200) {
+      new = GST_CAPS_NEW ("asf_type_find",
+			  "video/x-ms-asf",
+			    NULL);
+    }
+  }
 
-static GstCaps*
-asf_wm_type_find (GstBuffer *buf, gpointer private)
-{
-  GstCaps *new;
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
 
-  new = gst_caps_new (
-                  "asf_type_find",
-                  "video/x-ms-asf",
-                  gst_props_new ("asfversion",
-				 GST_PROPS_INT (1),
-				 NULL));
   return new;
 }
 
@@ -1644,6 +1562,7 @@
 plugin_init (GModule *module, GstPlugin *plugin)
 {
   GstElementFactory *factory;
+  GstTypeFactory *type;
   gint i = 0;
   GstCaps *audcaps = NULL, *vidcaps = NULL, *temp;
   guint32 vid_list[] = {
@@ -1670,23 +1589,13 @@
     -1 /* end */
   };
 
-  /* this filter needs bytestream */
-  if (!gst_library_load ("gstbytestream")) {
-    GST_INFO ("asfdemux: could not load support library: 'gstbytestream'\n");
-    return FALSE;
-  }
-  
   /* create an elementfactory for the asf_demux element */
   factory = gst_element_factory_new ("asfdemux",GST_TYPE_ASF_DEMUX,
                                     &gst_asf_demux_details);
 
-  while (asf_type_definitions[i].name) {
-    GstTypeFactory *type;
-
-    type = gst_type_factory_new (&asf_type_definitions[i]);
-    //gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
-    i++;
-  }
+  /* type finding */
+  type = gst_type_factory_new (&asf_type_definition);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
 
   g_return_val_if_fail (factory != NULL, FALSE);
   gst_element_factory_set_rank (factory, GST_ELEMENT_RANK_NONE);
Index: gstasfdemux.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/asfdemux/gstasfdemux.h,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- gstasfdemux.h	31 Jan 2003 21:41:07 -0000	1.6
+++ gstasfdemux.h	1 Oct 2003 13:14:46 -0000	1.7
@@ -24,7 +24,7 @@
 #include <config.h>
 #include <gst/gst.h>
 #include <gst/riff/riff.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include "asfheaders.h"
 
 G_BEGIN_DECLS
Index: gstasfmux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/asfdemux/gstasfmux.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- gstasfmux.c	9 Sep 2003 20:01:31 -0000	1.4
+++ gstasfmux.c	1 Oct 2003 13:14:46 -0000	1.5
@@ -414,6 +414,7 @@
   return GST_PAD_LINK_REFUSED;
 
 done:
+  stream->bitrate = 1024 * 1024;
   stream->header.video.format.size = stream->header.video.stream.size;
   stream->header.video.format.width = stream->header.video.stream.width;
   stream->header.video.format.height = stream->header.video.stream.height;
@@ -465,7 +466,6 @@
 
     stream->header.audio.sample_rate = rate;
     stream->header.audio.channels    = channels;
-    stream->bitrate = 0; /* TODO */
 
     if (!strcmp (mimetype, "audio/x-raw-int")) {
       gint block, size;
@@ -507,7 +507,7 @@
       }
 
       stream->header.audio.block_align = 1;
-      stream->header.audio.byte_rate   = 0;
+      stream->header.audio.byte_rate   = 8 * 1024;
       stream->header.audio.word_size   = 16;
       stream->header.audio.size        = 0;
 
@@ -521,6 +521,7 @@
   return GST_PAD_LINK_REFUSED;
 
 done:
+  stream->bitrate = stream->header.audio.byte_rate * 8;
   return GST_PAD_LINK_OK;
 }
 
@@ -632,9 +633,11 @@
   const GstEventMask *masks = gst_pad_get_event_masks (GST_PAD_PEER (asfmux->srcpad));
 
   /* this is for stream or file-storage */
-  while (masks->type != 0) {
+  while (masks != NULL && masks->type != 0) {
     if (masks->type == GST_EVENT_SEEK) {
       return TRUE;
+    } else {
+      masks++;
     }
   }
 
@@ -724,7 +727,7 @@
 		       guint8    *data,
 		       guint      length)
 {
-  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) > length) {
+  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= length) {
     guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
     memcpy (pos, data, length);
     GST_BUFFER_SIZE (packet) += length;
@@ -737,7 +740,7 @@
 gst_asfmux_put_byte (GstBuffer *packet,
 		     guint8     data)
 {
-  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) > sizeof (data)) {
+  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
     guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
     * (guint8 *) pos = data;
     GST_BUFFER_SIZE (packet) += 1;
@@ -750,7 +753,7 @@
 gst_asfmux_put_le16 (GstBuffer *packet,
 		     guint16    data)
 {
-  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) > sizeof (data)) {
+  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
     guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
     * (guint16 *) pos = GUINT16_TO_LE (data);
     GST_BUFFER_SIZE (packet) += 2;
@@ -763,7 +766,7 @@
 gst_asfmux_put_le32 (GstBuffer *packet,
 		     guint32    data)
 {
-  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) > sizeof (data)) {
+  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
     guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
     * (guint32 *) pos = GUINT32_TO_LE (data);
     GST_BUFFER_SIZE (packet) += 4;
@@ -776,7 +779,7 @@
 gst_asfmux_put_le64 (GstBuffer *packet,
 		     guint64    data)
 {
-  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) > sizeof (data)) {
+  if ((GST_BUFFER_MAXSIZE (packet) - GST_BUFFER_SIZE (packet)) >= sizeof (data)) {
     guint8 *pos = GST_BUFFER_DATA (packet) + GST_BUFFER_SIZE (packet);
     * (guint64 *) pos = GUINT64_TO_LE (data);
     GST_BUFFER_SIZE (packet) += 8;
Index: gstavidemux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/avi/gstavidemux.c,v
retrieving revision 1.78
retrieving revision 1.79
diff -u -d -r1.78 -r1.79
--- gstavidemux.c	16 Sep 2003 09:59:57 -0000	1.78
+++ gstavidemux.c	1 Oct 2003 13:14:46 -0000	1.79
@@ -38,7 +38,7 @@
   "(C) 1999",
 };
 
-static GstCaps* avi_type_find (GstBuffer *buf, gpointer private);
+static GstCaps* avi_type_find (GstByteStream *bs, gpointer private);
 
 /* typefactory for 'avi' */
 static GstTypeDefinition avidefinition = {
@@ -173,25 +173,29 @@
 }
 
 static GstCaps*
-avi_type_find (GstBuffer *buf,
-              gpointer private)
+avi_type_find (GstByteStream *bs,
+               gpointer       private)
 {
-  gchar *data = GST_BUFFER_DATA (buf);
-  GstCaps *new;
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
   GST_DEBUG ("avi_demux: typefind");
 
-  if (GST_BUFFER_SIZE (buf) < 12)
-    return NULL;
+  if (gst_bytestream_peek (bs, &buf, 12) == 12) {
+    guint32 head1 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[0]),
+	    head2 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[2]);
 
-  if (GUINT32_FROM_LE (((guint32 *)data)[0]) != GST_RIFF_TAG_RIFF)
-    return NULL;
-  if (GUINT32_FROM_LE (((guint32 *)data)[2]) != GST_RIFF_RIFF_AVI)
-    return NULL;
+    if (head1 == GST_RIFF_TAG_RIFF && head2 == GST_RIFF_RIFF_AVI) {
+      new = GST_CAPS_NEW ("avi_type_find",
+			  "video/avi", 
+			    NULL);
+    }
+  }
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
 
-  new = GST_CAPS_NEW ("avi_type_find",
-		      "video/avi", 
-		        NULL);
   return new;
 }
 
@@ -1960,10 +1964,6 @@
     GST_RIFF_WAVE_FORMAT_MULAW,
     -1 /* end */
   };
-
-  /* this filter needs the riff parser */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   if (!gst_library_load ("gstriff"))
     return FALSE;
Index: gstavidemux.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/avi/gstavidemux.h,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- gstavidemux.h	31 Jan 2003 19:37:26 -0000	1.14
+++ gstavidemux.h	1 Oct 2003 13:14:47 -0000	1.15
@@ -24,7 +24,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include <gst/riff/riff.h>
 
 #ifdef __cplusplus
Index: gstfestival.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/festival/gstfestival.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- gstfestival.c	24 Jul 2003 08:49:43 -0000	1.6
+++ gstfestival.c	1 Oct 2003 13:14:47 -0000	1.7
@@ -80,7 +80,7 @@
 static void		gst_festival_class_init		(GstFestivalClass *klass);
 static void		gst_festival_init		(GstFestival *festival);
 
-static GstCaps*		text_type_find			(GstBuffer *buf, gpointer private);
+static GstCaps*		text_type_find			(GstByteStream *bs, gpointer private);
 
 static void		gst_festival_chain		(GstPad *pad, GstBuffer *buf);
 static GstElementStateReturn 
@@ -198,21 +198,35 @@
 }
 
 static GstCaps*
-text_type_find (GstBuffer *buf, gpointer private)
+text_type_find (GstByteStream *bs, gpointer private)
 {
-  gchar *data = GST_BUFFER_DATA (buf);
-  gint i;
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
-  /* 20 is arbitrary.  4 is definitely too small. */
-  if (GST_BUFFER_SIZE (buf) < 20)
-    return NULL;
+#define TEXT_SIZE 32
 
-  for (i=0; i<GST_BUFFER_SIZE (buf); i++) {
-    if (!isprint(data[i]) && data[i]!='\n')
-      return NULL;
+  /* read arbitrary number and see if it's textual */
+  if (gst_bytestream_peek (bs, &buf, TEXT_SIZE) == TEXT_SIZE) {
+    gchar *data = GST_BUFFER_DATA (buf);
+    gint i;
+
+    for (i = 0; i < TEXT_SIZE; i++) {
+      if (!isprint (data[i]) && data[i] != '\n') {
+        break;
+      }
+    }
+
+    /* well, we found something that looks like text... */
+    new = gst_caps_new ("text_type_find",
+			"text/plain",
+			  NULL);
   }
 
-  return gst_caps_new ("text_type_find", "text/plain", NULL);
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return new;
 }
 
 
Index: gstcdxaparse.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/cdxaparse/gstcdxaparse.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- gstcdxaparse.c	24 Jul 2003 08:49:43 -0000	1.8
+++ gstcdxaparse.c	1 Oct 2003 13:14:47 -0000	1.9
@@ -50,7 +50,7 @@
   "(C) 2002",
 };
 
-static GstCaps* cdxa_type_find (GstBuffer *buf, gpointer private);
+static GstCaps* cdxa_type_find (GstByteStream *bs, gpointer private);
 
 /* typefactory for 'cdxa' */
 static GstTypeDefinition cdxadefinition = {
@@ -159,25 +159,28 @@
 }
 
 static GstCaps*
-cdxa_type_find (GstBuffer *buf,
-              gpointer private)
+cdxa_type_find (GstByteStream *bs,
+		gpointer       private)
 {
-  gchar *data = GST_BUFFER_DATA (buf);
-  GstCaps *new;
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
   GST_DEBUG ("cdxa_parse: typefind");
 
-  if (GST_BUFFER_SIZE (buf) < 12)
-    return NULL;
+  if (gst_bytestream_peek (bs, &buf, 12) == 12) {
+    guint32 head1 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[0]),
+	    head2 = GUINT32_FROM_LE (((guint32 *) GST_BUFFER_DATA (buf))[2]);
 
-  if (GUINT32_FROM_LE (((guint32 *)data)[0]) != GST_RIFF_TAG_RIFF)
-    return NULL;
-  if (GUINT32_FROM_LE (((guint32 *)data)[2]) != GST_RIFF_RIFF_CDXA)
-    return NULL;
+    if (head1 == GST_RIFF_TAG_RIFF && head2 == GST_RIFF_RIFF_CDXA) {
+      new = GST_CAPS_NEW ("cdxa_type_find",
+			  "video/x-cdxa", 
+			    NULL);
+    }
+  }
 
-  new = GST_CAPS_NEW ("cdxa_type_find",
-		      "video/x-cdxa", 
-		        NULL);
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
 
   return new;
 }
@@ -341,10 +344,6 @@
 {
   GstElementFactory *factory;
   GstTypeFactory *type;
-
-  /* this filter needs the riff parser */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   /* create an elementfactory for the cdxa_parse element */
   factory = gst_element_factory_new ("cdxaparse", GST_TYPE_CDXA_PARSE,
Index: gstcdxaparse.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/cdxaparse/gstcdxaparse.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- gstcdxaparse.h	20 Apr 2002 21:42:29 -0000	1.1
+++ gstcdxaparse.h	1 Oct 2003 13:14:47 -0000	1.2
@@ -24,7 +24,7 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #ifdef __cplusplus
 extern "C" {
Index: gstflxdec.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/flx/gstflxdec.c,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -d -r1.26 -r1.27
--- gstflxdec.c	16 Sep 2003 09:59:58 -0000	1.26
+++ gstflxdec.c	1 Oct 2003 13:14:47 -0000	1.27
@@ -28,7 +28,7 @@
 
 #define JIFFIE  (GST_SECOND/70)
 
-static GstCaps* flxdec_type_find(GstBuffer *buf, gpointer private);
+static GstCaps* flxdec_type_find (GstByteStream *bs, gpointer private);
 
 /* flx element information */
 static GstElementDetails flxdec_details = {
@@ -113,27 +113,33 @@
 static GstElementClass *parent_class = NULL;
 
 static GstCaps* 
-flxdec_type_find (GstBuffer *buf, gpointer private)
+flxdec_type_find (GstByteStream *bs, gpointer private)
 {
-  guchar *data = GST_BUFFER_DATA(buf);
-  GstCaps *new;
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
-  if (GST_BUFFER_SIZE(buf) < 134){
-    return NULL;
-  }
+  if (gst_bytestream_peek (bs, &buf, 134) == 134) {
+    guint8 *data = GST_BUFFER_DATA (buf);
 
-  /* check magic */
-  if ((data[4] == 0x11 || data[4] == 0x12
-       || data[4] == 0x30 || data[4] == 0x44) && data[5] == 0xaf) {
+    /* check magic */
+    if ((data[4] == 0x11 || data[4] == 0x12 ||
+         data[4] == 0x30 || data[4] == 0x44) &&
+        data[5] == 0xaf) {
       /* check the frame type of the first frame */
       if ((data[132] == 0x00 || data[132] == 0xfa) && data[133] == 0xf1) {
         GST_DEBUG ("GstFlxDec: found supported flx format");
-        new = gst_caps_new("flxdec_type_find","video/x-fli", NULL);
-        return new;
+        new = gst_caps_new ("flxdec_type_find",
+			    "video/x-fli",
+			      NULL);
       }
+    }
   }
-  
-  return NULL; 
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return new;
 }
 
 
@@ -683,10 +689,6 @@
 {
   GstElementFactory *factory;
   GstTypeFactory *type;
-
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   factory = gst_element_factory_new("flxdec", GST_TYPE_FLXDEC, &flxdec_details);
   g_return_val_if_fail(factory != NULL, FALSE);
Index: gstflxdec.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/flx/gstflxdec.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- gstflxdec.h	20 Mar 2002 21:44:50 -0000	1.4
+++ gstflxdec.h	1 Oct 2003 13:14:47 -0000	1.5
@@ -23,7 +23,7 @@
 #include <gst/gst.h>
 
 #include "flx_color.h"
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 
 #ifdef __cplusplus
Index: gstfloat2int.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/intfloat/gstfloat2int.c,v
retrieving revision 1.43
retrieving revision 1.44
diff -u -d -r1.43 -r1.44
--- gstfloat2int.c	30 Sep 2003 12:47:48 -0000	1.43
+++ gstfloat2int.c	1 Oct 2003 13:14:48 -0000	1.44
@@ -522,9 +522,6 @@
 {
   GstElementFactory *factory;
   
-  if (! gst_library_load ("gstbytestream"))
-    return FALSE;
-
   factory = gst_element_factory_new ("float2int", GST_TYPE_FLOAT2INT,
                                      &float2int_details);
   g_return_val_if_fail(factory != NULL, FALSE);
Index: gstfloat2int.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/intfloat/gstfloat2int.h,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- gstfloat2int.h	30 Sep 2003 12:47:48 -0000	1.13
+++ gstfloat2int.h	1 Oct 2003 13:14:48 -0000	1.14
@@ -27,7 +27,6 @@
 
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
 
 
 #define GST_TYPE_FLOAT2INT \
Index: mixmatrix.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mixmatrix/mixmatrix.c,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- mixmatrix.c	25 Jul 2003 10:50:47 -0000	1.12
+++ mixmatrix.c	1 Oct 2003 13:14:48 -0000	1.13
@@ -22,7 +22,7 @@
 #endif
 #include <config.h>
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 #include <gst/audio/audio.h>
 #include <string.h>
 
@@ -499,10 +499,6 @@
 plugin_init (GModule *module, GstPlugin *plugin)
 {
   GstElementFactory *factory;
-
-  /* this filter needs the bytestream package */
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   factory = gst_element_factory_new ("mixmatrix", GST_TYPE_MIXMATRIX, 
                                      &mixmatrix_details);

CVS Root:       /cvsroot/gstreamer
Module:         gst-plugins
Changes by:     rbultje
Date:           Wed Oct 01 2003  06:15:24 PDT

Log message:
New typefind system:
* bytestream is now part of the core
* all plugins have been modified to use this new typefind system
* asf typefinding added
* mpeg video stream typefiding removed because it's broken
* duplicate typefind entries removed
* extra id3 typefinding added, because we've seen 4 types of files
(riff/wav, flac, vorbis, mp3) with id3 headers and each of these needs
to work. Instead, I've added an id3 element and let it redo typefiding
after the id3 header. this needs a hack because spider only typefinds
once. We can remove this hack once spider supports multiple typefinds.
* with all this, mp3 typefinding is semi-rewritten
* id3 typefinding in flac/vorbis is removed, it's no longer needed
* fixed spider and gst-typefind to use this, too.
* Other general cleanups

Modified files:
    gst/mpegtypes   : Makefile.am
Added files:
    gst/mpegtypes   : gstmpegtypes.c
Removed files:
    gst/mpegtypes   : gstmpeg1types.c gstmpeg2types.c

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegtypes/Makefile.am.diff?r1=1.9&r2=1.10
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegtypes/gstmpeg1types.c
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegtypes/gstmpeg2types.c
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/mpegtypes/gstmpegtypes.c?rev=1.1&content-type=text/vnd.viewcvs-markup

====Begin Diffs====
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/mpegtypes/Makefile.am,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- Makefile.am	11 Sep 2003 19:57:58 -0000	1.9
+++ Makefile.am	1 Oct 2003 13:14:50 -0000	1.10
@@ -1,12 +1,7 @@
 
-plugin_LTLIBRARIES = libgstmpeg2types.la libgstmpeg1types.la
-
-libgstmpeg2types_la_SOURCES = gstmpeg2types.c
-libgstmpeg2types_la_CFLAGS = $(GST_CFLAGS)
-libgstmpeg2types_la_LIBADD =
-libgstmpeg2types_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+plugin_LTLIBRARIES = libgstmpegtypes.la
 
-libgstmpeg1types_la_SOURCES = gstmpeg1types.c
-libgstmpeg1types_la_CFLAGS = $(GST_CFLAGS)
-libgstmpeg1types_la_LIBADD =
-libgstmpeg1types_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+libgstmpegtypes_la_SOURCES = gstmpegtypes.c
+libgstmpegtypes_la_CFLAGS = $(GST_CFLAGS)
+libgstmpegtypes_la_LIBADD =
+libgstmpegtypes_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
--- gstmpeg1types.c DELETED ---
--- gstmpeg2types.c DELETED ---
--- NEW FILE: gstmpegtypes.c ---
/* GStreamer
 * Copyright (C) <1999> Erik Walthinsen <omega@...>
 *
 * 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 DEBUG_ENABLED*/
#include <gst/gst.h>

static GstCaps* mpegsystem_type_find (GstByteStream *bs, gpointer private);
#if 0
static GstCaps* mpegvideo_type_find (GstByteStream *bs, gpointer private);
#endif

static GstTypeDefinition mpegtype_definitions[] = {
  { "mpegtypes_video/mpeg;system", "video/mpeg",
    ".mpg .mpeg .mpe", mpegsystem_type_find },
#if 0
  { "mpegtypes_video/mpeg", "video/mpeg",
    ".mpg .mpeg .mpe", mpegvideo_type_find },
#endif
  { NULL, NULL, NULL, NULL },
};

static GstCaps *
mpegsystem_type_find (GstByteStream *bs, gpointer private) 
{
  GstBuffer *buf = NULL;
  GstCaps *new = NULL;

  if (gst_bytestream_peek (bs, &buf, 5) == 5) {
    guint32 head1 = GUINT32_FROM_BE (*((guint32 *) GST_BUFFER_DATA (buf)));

    if (head1 == 0x000001ba &&
	(GST_BUFFER_DATA (buf)[4] & 0xC0) == 0x40) {
      new = GST_CAPS_NEW ("mpegsystem_type_find",
			  "video/mpeg",
        	            "systemstream", GST_PROPS_BOOLEAN (TRUE));
    }
  }

  if (buf != NULL) {
    gst_buffer_unref (buf);
  }

  return new;
}

#if 0
static GstCaps *
mpegvideo_type_find (GstByteStream *bs, gpointer private) 
{
  GstBuffer *buf = NULL;
  GstCaps *new = NULL;

  if (gst_bytestream_peek (bs, &buf, 4) == 4) {
    guint32 head = GUINT32_FROM_BE (*((guint32 *) GST_BUFFER_DATA (buf)));

    if (head == 0x000001b3) {
      new = GST_CAPS_NEW ("mpegvideo_type_find",
			  "video/mpeg",
			    "mpegversion",  GST_PROPS_INT (2 | 1), /* FIXME */
			    "systemstream", GST_PROPS_BOOLEAN (FALSE));
    }
  }
  return new;
}
#endif

static gboolean
plugin_init (GModule *module, GstPlugin *plugin)
{
  gint i=0;

  while (mpegtype_definitions[i].name) {
    GstTypeFactory *type;

    type = gst_type_factory_new (&mpegtype_definitions[i]);
    gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
    i++;
  }

  return TRUE;
}

GstPluginDesc plugin_desc = {
  GST_VERSION_MAJOR,
  GST_VERSION_MINOR,
  "mpeg2types",
  plugin_init
};

CVS Root:       /cvsroot/gstreamer
Module:         gst-plugins
Changes by:     rbultje
Date:           Wed Oct 01 2003  06:15:05 PDT

Log message:
New typefind system:
* bytestream is now part of the core
* all plugins have been modified to use this new typefind system
* asf typefinding added
* mpeg video stream typefiding removed because it's broken
* duplicate typefind entries removed
* extra id3 typefinding added, because we've seen 4 types of files
(riff/wav, flac, vorbis, mp3) with id3 headers and each of these needs
to work. Instead, I've added an id3 element and let it redo typefiding
after the id3 header. this needs a hack because spider only typefinds
once. We can remove this hack once spider supports multiple typefinds.
* with all this, mp3 typefinding is semi-rewritten
* id3 typefinding in flac/vorbis is removed, it's no longer needed
* fixed spider and gst-typefind to use this, too.
* Other general cleanups

Modified files:
    gst/realmedia   : rmdemux.c rmdemux.h
    gst/wavparse    : gstwavparse.c
Added files:
    gst/id3         : Makefile.am gstid3types.c gstid3types.h

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/id3/Makefile.am?rev=1.1&content-type=text/vnd.viewcvs-markup
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/id3/gstid3types.c?rev=1.1&content-type=text/vnd.viewcvs-markup
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/id3/gstid3types.h?rev=1.1&content-type=text/vnd.viewcvs-markup
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/realmedia/rmdemux.c.diff?r1=1.5&r2=1.6
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/realmedia/rmdemux.h.diff?r1=1.2&r2=1.3
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gst-plugins/gst/wavparse/gstwavparse.c.diff?r1=1.34&r2=1.35

====Begin Diffs====
--- NEW FILE: Makefile.am ---
plugin_LTLIBRARIES = libgstid3types.la

libgstid3types_la_SOURCES = gstid3types.c
libgstid3types_la_CFLAGS = $(GST_CFLAGS)
if USE_MAD
libgstid3types_la_LIBADD = -lid3tag
else
libgstid3types_la_LIBADD =
endif
libgstid3types_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)

noinst_HEADERS = gstid3types.h
--- NEW FILE: gstid3types.c ---
/* GStreamer
 * Copyright (C) <1999> Erik Walthinsen <omega@...>
 *
 * 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.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef HAVE_MAD
#include <id3tag.h>
#endif

#include <string.h>
#include "gstid3types.h"

/* elementfactory information */
static GstElementDetails id3types_details = {
  "ID3v1/v2 tag parser",
  "Codec/Parser",
#ifdef HAVE_MAD
  "GPL", /* grmbl, where's a good C LGPL ID3v1/2 reader? */
#else
  "LGPL",
#endif
  "Parses ID3v1 and ID3v2 tags",
  VERSION,
  "Erik Walthinsen <omega@..."
  "Ronald Bultje <rbultje@...>",
  "(C) 1999-2003",
};

GST_PAD_TEMPLATE_FACTORY (sink_templ,
  "sink",
  GST_PAD_SINK,
  GST_PAD_ALWAYS,
  GST_CAPS_NEW (
    "id3types_sink",
    "audio/x-id3",
      "id3version", GST_PROPS_INT_RANGE (1, 2)
  )
);

GST_PAD_TEMPLATE_FACTORY (src_templ,
  "src",
  GST_PAD_SRC,
  GST_PAD_SOMETIMES,
  NULL
);

static GstCaps* id3_type_find (GstByteStream *bs, gpointer private);

static GstTypeDefinition id3type_definition = {
  "id3_audio/x-id3",
  "audio/x-id3",
  ".mp3 .mp2 .mp1 .mpga .ogg .flac", /* probably more... *sigh* */
  id3_type_find,
};

/* signals */
enum {
  /* FILL ME */
  LAST_SIGNAL,
};

/* args */
enum {
  ARG_0,
  ARG_METADATA,
  /* FILL ME */
};


static void	gst_id3types_class_init		(GstID3TypesClass *klass);
static void	gst_id3types_init		(GstID3Types  *mp3parse);

static const GstEventMask *
		gst_id3types_event_mask		(GstPad       *pad);
static gboolean	gst_id3types_event		(GstPad       *pad,
						 GstEvent     *event);

static const GstQueryType *
		gst_id3types_get_query_types	(GstPad       *pad);
static gboolean gst_id3types_handle_query 	(GstPad       *pad,
						 GstQueryType  type, 
						 GstFormat    *format,
						 gint64       *value);

static void	gst_id3types_chain		(GstPad       *pad,
						 GstBuffer    *buf);
static void	gst_id3types_loop		(GstElement   *element);

static void	gst_id3types_get_property	(GObject      *object,
						 guint         prop_id,
						 GValue       *value,
						 GParamSpec   *pspec);
static GstElementStateReturn
		gst_id3types_change_state	(GstElement   *element);

static GstElementClass *parent_class = NULL;
/*static guint gst_id3types_signals[LAST_SIGNAL] = { 0 };*/

GType
gst_id3types_get_type (void)
{
  static GType id3types_type = 0;

  if (!id3types_type) {
    static const GTypeInfo id3types_info = {
      sizeof (GstID3TypesClass),
      NULL,
      NULL,
      (GClassInitFunc) gst_id3types_class_init,
      NULL,
      NULL,
      sizeof (GstID3Types),
      0,
      (GInstanceInitFunc) gst_id3types_init,
    };

    id3types_type = g_type_register_static (GST_TYPE_ELEMENT,
					    "GstID3Types",
					    &id3types_info, 0);
  }

  return id3types_type;
}

static gboolean
gst_id3types_detect (GstByteStream *bs,
		     guint         *version,
		     guint         *size)
{
  gboolean res = FALSE;
  GstBuffer *buf = NULL;

  if (gst_bytestream_peek (bs, &buf, 10) == 10) {
    guint8 *data = GST_BUFFER_DATA (buf);

    /* gracefully ripped from libid3 */
    if (data[0] == 'T' && data[1] == 'A' && data[2] == 'G') {
      /* ID3v1 tags */
      res = TRUE;
      if (size)
        *size = 128;
      if (version)
        *version = 1;
    } else if (data[0] == 'I' && data[1] == 'D' && data[2] == '3') {
      /* ID3v2 tags */
      if (data[3] < 0xff && data[4] < 0xff &&
	  data[6] < 0x80 && data[7] < 0x80 &&
	  data[8] < 0x80 && data[9] < 0x80) {
        guint32 skip = ((data[6] & 0x7f) << 21) |
		       ((data[7] & 0x7f) << 14) |
		       ((data[8] & 0x7f) << 7) |
		       ((data[9] & 0x7f) << 0);

        /* include size of header */
        skip += 10;

        /* footer present? (only available since version 4) */
        if (data[3] >= 4 && (data[5] & 0x10))
          skip += 10;

        res = TRUE;
        if (size)
          *size = skip;
        if (version)
          *version = 2;
      }
    }
  }

  if (buf != NULL) {
    gst_buffer_unref (buf);
  }

  return res;
}

static GstCaps *
id3_type_find (GstByteStream *bs,
	       gpointer       private) 
{
  GstCaps *new = NULL;
  guint version, size;

  if (gst_id3types_detect (bs, &version, &size)) {
    switch (version) {
      case 1: case 2:
        /* ID3v1/v2 tags */
        GST_DEBUG ("id3typefind: detected ID3 Tag V%d", version);
        new = GST_CAPS_NEW ("id3_type_find",
			    "audio/x-id3",
			      "id3version", GST_PROPS_INT (version));
        break;
      default:
        break;
    }
  }

  return new;
}

static void
gst_id3types_class_init (GstID3TypesClass *klass)
{
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;
  gstelement_class = (GstElementClass *) klass;

  g_object_class_install_property (gobject_class, ARG_METADATA,
    g_param_spec_boxed ("metadata", "Metadata", "Metadata",
                        GST_TYPE_CAPS, G_PARAM_READABLE));

  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);

  gobject_class->get_property = gst_id3types_get_property;

  gstelement_class->change_state = gst_id3types_change_state;
}

static inline void
gst_id3types_start (GstID3Types *id3)
{
  id3->pass_through = FALSE;
  id3->id3_tag_size = 0;
  id3->metadata = NULL;
}

static inline void
gst_id3types_cont (GstID3Types *id3)
{
  id3->pass_through = TRUE;
}

static inline void
gst_id3types_stop (GstID3Types *id3)
{
  gst_caps_replace (&id3->metadata, NULL);
  id3->pass_through = TRUE;
}

static void
gst_id3types_init (GstID3Types *id3)
{
  GST_FLAG_SET (id3, GST_ELEMENT_EVENT_AWARE);

  id3->sinkpad = gst_pad_new_from_template (GST_PAD_TEMPLATE_GET (sink_templ),
					    "sink");
  gst_element_set_loop_function (GST_ELEMENT (id3), gst_id3types_loop);
  gst_pad_set_event_function (id3->sinkpad, gst_id3types_event);
  gst_pad_set_event_mask_function (id3->sinkpad, gst_id3types_event_mask);
  gst_id3types_start (id3);
  gst_element_add_pad (GST_ELEMENT (id3), id3->sinkpad);

  id3->metadata = NULL;
  id3->id3_tag_size = 0;
}

static const GstEventMask *
gst_id3types_event_mask (GstPad *pad)
{
  GstID3Types *id3 = GST_ID3TYPES (gst_pad_get_parent (pad));
  const GstEventMask *masks = NULL;

  if (pad == id3->sinkpad) {
    static const GstEventMask my_masks[] = {
      { GST_EVENT_DISCONTINUOUS, 0 },
      { 0, }
    };
    masks = my_masks;
  } else if (pad == id3->srcpad) {
    static const GstEventMask my_masks[] = {
      { GST_EVENT_SEEK, GST_SEEK_METHOD_SET },
      { 0, }
    };
    masks = my_masks;
  } else {
    g_assert (0);
  }

  return masks;
}

static gboolean
gst_id3types_event (GstPad   *pad,
		    GstEvent *event)
{
  GstID3Types *id3 = GST_ID3TYPES (gst_pad_get_parent (pad));
  gboolean res = TRUE;

  switch (GST_EVENT_TYPE (event)) {
    case GST_EVENT_DISCONTINUOUS: {
      /* comes from the sink pad */
      GstEvent *new = NULL;
      guint64 offset = 0;
      gint n;

      /* get new offset in bytes */
      for (n = 0; n < GST_EVENT_DISCONT_OFFSET_LEN (event); n++) {
        GstFormatValue *value = &GST_EVENT_DISCONT_OFFSET (event, n);
        if (value->format == GST_FORMAT_BYTES) {
          offset = value->value;
          break;
        }
      }

      if (GST_EVENT_DISCONT_NEW_MEDIA (event) ||
	  offset < id3->id3_tag_size) {
        gst_id3types_stop (id3);
        gst_id3types_start (id3);
        new = gst_event_new_discontinuous (GST_EVENT_DISCONT_NEW_MEDIA (event),
					   GST_FORMAT_BYTES, 0, 0);
      } else {
        gst_id3types_cont (id3);
        new = gst_event_new_discontinuous (FALSE, GST_FORMAT_BYTES,
					   offset - id3->id3_tag_size, 0);
      }
      gst_pad_event_default (pad, new);
      break;
    }
    case GST_EVENT_SEEK:
      /* comes from the src pad... */
      switch (GST_EVENT_SEEK_FORMAT (event)) {
        case GST_FORMAT_BYTES: {
          gint64 offset = GST_EVENT_SEEK_OFFSET (event);
          GstEvent *new = gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES,
					      offset + id3->id3_tag_size);

          gst_pad_send_event (GST_PAD_PEER (id3->sinkpad), new);
          break;
        }
        default:
          g_warning ("Non-bytes seek event in id3types");
          res = FALSE;
          break;
      }
      break;
    default:
      res = FALSE;
      break;
  }

  gst_event_unref (event);

  return res;
}

static const GstQueryType *
gst_id3types_get_query_types (GstPad *pad)
{
  static const GstQueryType types[] = {
    GST_QUERY_TOTAL,
    GST_QUERY_POSITION,
    0
  };

  return types;
}

static gboolean
gst_id3types_handle_query (GstPad       *pad,
			   GstQueryType  type, 
			   GstFormat    *format,
			   gint64       *value)
{
  GstID3Types *id3 = GST_ID3TYPES (gst_pad_get_parent (pad));

  g_return_val_if_fail (type == GST_QUERY_TOTAL ||
			type == GST_QUERY_POSITION, FALSE);

  if (*format == GST_FORMAT_BYTES) {
    gst_pad_query (id3->sinkpad, type, format, value);

    if (*value >= id3->id3_tag_size)
      *value -= id3->id3_tag_size;
    else
      *value = 0;

    return TRUE;
  }

  return FALSE;
}

static void
gst_id3types_chain (GstPad    *pad,
		    GstBuffer *buf)
{
  GstID3Types *id3 = GST_ID3TYPES (gst_pad_get_parent (pad));

  if (GST_IS_EVENT (buf)) {
    gst_id3types_event (id3->sinkpad, GST_EVENT (buf));
  } else {
    /* passthrough mode */
    gst_pad_push (id3->srcpad, buf);
  }
}

#ifdef HAVE_MAD
/* gracefuly ripped from madplay */
static GstCaps *
id3_to_caps (struct id3_tag const *tag)
{
  unsigned int i;
  struct id3_frame const *frame;
  id3_ucs4_t const *ucs4;
  id3_utf8_t *utf8;
  GstProps *props;
  GstPropsEntry *entry;
  GstCaps *caps;
  GList *values;

  struct {
    char const *id;
    char const *name;
  } const info[] = {
    { ID3_FRAME_TITLE,   "Title"        },
    { "TIT3",            "Subtitle"     },
    { "TCOP",            "Copyright"    },
    { "TPRO",            "Produced"     },
    { "TCOM",            "Composer"     },
    { ID3_FRAME_ARTIST,  "Artist"       },
    { "TPE2",            "Orchestra"    },
    { "TPE3",            "Conductor"    },
    { "TEXT",            "Lyricist"     },
    { ID3_FRAME_ALBUM,   "Album"        },
    { ID3_FRAME_YEAR,    "Year"         },
    { ID3_FRAME_TRACK,   "Track"        },
    { "TPUB",            "Publisher"    },
    { ID3_FRAME_GENRE,   "Genre"        },
    { "TRSN",            "Station"      },
    { "TENC",            "Encoder"      },
  };

  /* text information */
  props = gst_props_empty_new ();

  for (i = 0; i < sizeof(info) / sizeof(info[0]); ++i) {
    union id3_field const *field;
    unsigned int nstrings, namelen, j;
    char const *name;

    frame = id3_tag_findframe(tag, info[i].id, 0);
    if (frame == 0)
      continue;

    field    = &frame->fields[1];
    nstrings = id3_field_getnstrings(field);

    name = info[i].name;

    if (name) {
      namelen = name ? strlen(name) : 0;

      values = NULL;
      for (j = 0; j < nstrings; ++j) {
        ucs4 = id3_field_getstrings(field, j);
        g_assert(ucs4);

        if (strcmp(info[i].id, ID3_FRAME_GENRE) == 0)
	  ucs4 = id3_genre_name(ucs4);

        utf8 = id3_ucs4_utf8duplicate(ucs4);
        if (utf8 == 0)
	  goto fail;

        entry = gst_props_entry_new (name, GST_PROPS_STRING_TYPE, utf8);
	values = g_list_prepend (values, entry);
        free(utf8);
      }
      if (values) {
        values = g_list_reverse (values);

        if (g_list_length (values) == 1) {
          gst_props_add_entry (props, (GstPropsEntry *) values->data);
        }
        else {
          entry = gst_props_entry_new(name, GST_PROPS_GLIST_TYPE, values);
          gst_props_add_entry (props, (GstPropsEntry *) entry);
        }
        g_list_free (values);
      }
    }
  }

  values = NULL;
  i = 0;
  while ((frame = id3_tag_findframe(tag, ID3_FRAME_COMMENT, i++))) {
    ucs4 = id3_field_getstring(&frame->fields[2]);
    g_assert(ucs4);

    if (*ucs4)
      continue;

    ucs4 = id3_field_getfullstring(&frame->fields[3]);
    g_assert(ucs4);

    utf8 = id3_ucs4_utf8duplicate(ucs4);
    if (utf8 == 0)
      goto fail;

    entry = gst_props_entry_new ("Comment", GST_PROPS_STRING_TYPE, utf8);
    values = g_list_prepend (values, entry);
    free(utf8);
  }
  if (values) {
    values = g_list_reverse (values);

    if (g_list_length (values) == 1) {
      gst_props_add_entry (props, (GstPropsEntry *) values->data);
    }
    else {
      entry = gst_props_entry_new("Comment", GST_PROPS_GLIST_TYPE, values);
      gst_props_add_entry (props, (GstPropsEntry *) entry);
    }
    g_list_free (values);
  }

  gst_props_debug (props);

  caps = gst_caps_new ("mad_metadata",
		       "application/x-gst-metadata",
		       props);
  if (0) {
fail:
    g_warning ("mad: could not parse ID3 tag");

    return NULL;
  }

  return caps;
}
#endif

static void
gst_id3types_loop (GstElement *element)
{
  const GList *type_list = gst_type_get_list ();
  GstID3Types *id3;
  GstByteStream *bs;
  GstBuffer *buf = NULL;
  guint size = 0, version = 0;
#ifdef HAVE_MAD
  struct id3_tag *tag = NULL;
#endif

  g_return_if_fail (GST_IS_ID3TYPES (element));
  id3 = GST_ID3TYPES (element);

  if (id3->pass_through) {
    gst_id3types_chain (id3->sinkpad, gst_pad_pull (id3->sinkpad));
    return;
  }

  bs = gst_bytestream_new (id3->sinkpad);

  /* first loop... */
  if (!gst_id3types_detect (bs, &version, &size)) {
    gst_element_error (element,
		       "No ID3 tag detected");
    goto error;
  }

  /* OK: so we've now got a ID3 tag of that size, let's read it */
  if (gst_bytestream_peek (bs, &buf, size) != size) {
    gst_element_error (element,
		       "Failed to read ID3 tag - hard disk on fire?");
    goto error;
  }
  gst_bytestream_flush (bs, size);

#ifdef HAVE_MAD
  /* here, we should parse the ID3 header and notify the app */
  if (!(tag = id3_tag_parse (GST_BUFFER_DATA (buf), size))) {
    gst_element_error (element,
		       "Failed to parse ID3v1/2 tags");
    goto error;
  } else {
    gst_caps_replace_sink (&id3->metadata, id3_to_caps (tag));
    id3_tag_delete (tag);
    g_object_notify (G_OBJECT (id3), "metadata");
  }
#endif

  /* done */
  id3->id3_tag_size = size;

  /* this will help us detecting the media stream type after
   * this id3 thingy... Please note that this is a cruel hack
   * for as long as spider doesn't support multi-type-finding.
   */
  while (type_list) {
    GSList *factories;
    GstType *type = (GstType *) type_list->data;

    factories = type->factories;

    while (factories) {
      GstTypeFactory *factory = GST_TYPE_FACTORY (factories->data);
      GstTypeFindFunc typefindfunc = (GstTypeFindFunc) factory->typefindfunc;
      GstCaps *caps;

      if (typefindfunc && (caps = typefindfunc (bs, factory))) {
        GST_DEBUG ("found type: %d \"%s\" \"%s\"\n",
		   caps->id, type->mime, gst_caps_get_name (caps));

        id3->srcpad = gst_pad_new_from_template (GST_PAD_TEMPLATE_GET (src_templ),
						 "src");
        gst_pad_set_event_function (id3->srcpad, gst_id3types_event);
        gst_pad_set_event_mask_function (id3->srcpad, gst_id3types_event_mask);
        gst_pad_set_query_type_function (id3->srcpad, gst_id3types_get_query_types);
        gst_pad_set_query_function (id3->srcpad, gst_id3types_handle_query);
        gst_pad_try_set_caps (id3->srcpad, caps);
        gst_element_add_pad (GST_ELEMENT (id3), id3->srcpad);
        goto tf_done;
      }
      factories = g_slist_next (factories);
    }
    type_list = g_list_next (type_list);
  }
  gst_element_error (element,
		     "Media stream type not detected after id3v1/2 header");
  goto error;

tf_done:
  if (bs->listavail) {
    gst_bytestream_read (bs, &buf, bs->listavail);
    gst_pad_push (id3->srcpad, buf);
  }
  gst_id3types_cont (id3);
error:
#ifdef HAVE_MAD
  if (tag) {
    id3_tag_delete (tag);
  }
#endif
  gst_bytestream_destroy (bs);
}

static void
gst_id3types_get_property (GObject    *object,
			   guint       prop_id,
			   GValue     *value,
			   GParamSpec *pspec)
{
  GstID3Types *id3;

  /* it's not null if we got it, but it might not be ours */
  g_return_if_fail (GST_IS_ID3TYPES (object));
  id3 = GST_ID3TYPES (object);

  switch (prop_id) {
    case ARG_METADATA:
      g_value_set_boxed (value, id3->metadata);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static GstElementStateReturn 
gst_id3types_change_state (GstElement *element) 
{
  GstID3Types *id3;

  g_return_val_if_fail (GST_IS_ID3TYPES (element), GST_STATE_FAILURE);
  id3 = GST_ID3TYPES (element);

  switch (GST_STATE_TRANSITION (element)) {
    case GST_STATE_READY_TO_PAUSED:
      gst_id3types_start (id3);
      break;
    case GST_STATE_PAUSED_TO_READY:
      gst_id3types_stop (id3);
      break;
    default:
      break;
  }

  if (GST_ELEMENT_CLASS (parent_class)->change_state)
    return GST_ELEMENT_CLASS (parent_class)->change_state (element);

  return GST_STATE_SUCCESS;
}

static gboolean
plugin_init (GModule *module, GstPlugin *plugin)
{
  GstTypeFactory *type;
  GstElementFactory *factory;

  /* create an elementfactory for the id3types element */
  factory = gst_element_factory_new ("id3types",
		                     GST_TYPE_ID3TYPES,
                                     &id3types_details);
  g_return_val_if_fail (factory != NULL, FALSE);
  gst_element_factory_set_rank (factory, GST_ELEMENT_RANK_PRIMARY);

  gst_element_factory_add_pad_template (factory,
	GST_PAD_TEMPLATE_GET (sink_templ));
  gst_element_factory_add_pad_template (factory,
	GST_PAD_TEMPLATE_GET (src_templ));

  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));

  /* and typefinding */
  type = gst_type_factory_new (&id3type_definition);
  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));

  return TRUE;
}

GstPluginDesc plugin_desc = {
  GST_VERSION_MAJOR,
  GST_VERSION_MINOR,
  "id3types",
  plugin_init
};
--- NEW FILE: gstid3types.h ---
/* GStreamer
 * Copyright (C) <1999> Erik Walthinsen <omega@...>
 *
 * 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 __ID3TYPES_H__
#define __ID3TYPES_H__

#include <glib.h>
#include <gst/gst.h>

G_BEGIN_DECLS

#define GST_TYPE_ID3TYPES \
  (gst_id3types_get_type ())
#define GST_ID3TYPES(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_ID3TYPES, GstID3Types))
#define GST_ID3TYPES_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_ID3TYPES, GstID3Types))
#define GST_IS_ID3TYPES(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_ID3TYPES))
#define GST_IS_ID3TYPES_CLASS(obj) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_ID3TYPES))

typedef struct _GstID3Types GstID3Types;
typedef struct _GstID3TypesClass GstID3TypesClass;

struct _GstID3Types {
  GstElement element;

  GstPad *sinkpad, *srcpad;

  GstCaps *metadata;
  guint id3_tag_size;
  gboolean pass_through;
};

struct _GstID3TypesClass {
  GstElementClass parent_class;
};

GType gst_id3types_get_type (void);

G_END_DECLS

#endif /* __ID3TYPES_H__ */
Index: rmdemux.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/realmedia/rmdemux.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- rmdemux.c	24 Jul 2003 08:49:44 -0000	1.5
+++ rmdemux.c	1 Oct 2003 13:14:50 -0000	1.6
@@ -87,7 +87,7 @@
   "(C) 2003",
 };
 
-static GstCaps* realmedia_type_find (GstBuffer *buf, gpointer private);
+static GstCaps* realmedia_type_find (GstByteStream *bs, gpointer private);
 
 static GstTypeDefinition realmediadefinition = {
   "rmdemux_video/realmedia",
@@ -195,21 +195,26 @@
 }
 
 static GstCaps*
-realmedia_type_find (GstBuffer *buf, gpointer private)
+realmedia_type_find (GstByteStream *bs, gpointer private)
 {
-  gchar *data = GST_BUFFER_DATA (buf);
+  GstBuffer *buf = NULL;
+  GstCaps *new = NULL;
 
-  g_return_val_if_fail (data != NULL, NULL);
-  
-  if(GST_BUFFER_SIZE(buf) < 4){
-    return NULL;
+  if (gst_bytestream_peek (bs, &buf, 4) == 4) {
+    gchar *data = GST_BUFFER_DATA (buf);
+
+    if (!strncmp (data, ".RMF", 4)) {
+      new = GST_CAPS_NEW ("realmedia_type_find",
+			  "application/vnd.rn-realmedia", 
+			    NULL);
+    }
   }
-  if (strncmp (data, ".RMF", 4)==0) {
-    return gst_caps_new ("realmedia_type_find",
-		         "application/vnd.rn-realmedia", 
-			 NULL);
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
   }
-  return NULL;
+
+  return new;
 }
 
 static gboolean
@@ -217,9 +222,6 @@
 {
   GstElementFactory *factory;
   GstTypeFactory *type;
-
-  if (!gst_library_load ("gstbytestream"))
-    return FALSE;
 
   factory = gst_element_factory_new ("rmdemux", GST_TYPE_RMDEMUX,
                                      &gst_rmdemux_details);
Index: rmdemux.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/realmedia/rmdemux.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- rmdemux.h	24 Jun 2003 08:05:12 -0000	1.2
+++ rmdemux.h	1 Oct 2003 13:14:51 -0000	1.3
@@ -22,7 +22,7 @@
 #define __GST_RMDEMUX_H__
 
 #include <gst/gst.h>
-#include <gst/bytestream/bytestream.h>
+#include <gst/gstbytestream.h>
 
 #ifdef __cplusplus
 extern "C" {
Index: gstwavparse.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst/wavparse/gstwavparse.c,v
retrieving revision 1.34
retrieving revision 1.35
diff -u -d -r1.34 -r1.35
--- gstwavparse.c	16 Sep 2003 10:00:01 -0000	1.34
+++ gstwavparse.c	1 Oct 2003 13:14:52 -0000	1.35
@@ -31,7 +31,8 @@
 static GstElementStateReturn
 			gst_wavparse_change_state 	(GstElement *element);
 
-static GstCaps*		wav_type_find			(GstBuffer *buf, gpointer private);
+static GstCaps*		wav_type_find			(GstByteStream *bs,
+							 gpointer private);
 
 static const GstFormat*	gst_wavparse_get_formats	(GstPad *pad);
 static const GstQueryType *
@@ -213,15 +214,27 @@
 }
 
 static GstCaps*
-wav_type_find (GstBuffer *buf, gpointer private)
+wav_type_find (GstByteStream *bs, gpointer private)
 {
-  gchar *data = GST_BUFFER_DATA (buf);
+  GstCaps *new = NULL;
+  GstBuffer *buf = NULL;
 
-  if (GST_BUFFER_SIZE (buf) < 12) return NULL;
-  if (strncmp (&data[0], "RIFF", 4)) return NULL;
-  if (strncmp (&data[8], "WAVE", 4)) return NULL;
+  if (gst_bytestream_peek (bs, &buf, 12) == 12) {
+    gchar *data = GST_BUFFER_DATA (buf);
 
-  return gst_caps_new ("wav_type_find", "audio/x-wav", NULL);
+    if (!strncmp (&data[0], "RIFF", 4) &&
+        !strncmp (&data[8], "WAVE", 4)) {
+      new = GST_CAPS_NEW ("wav_type_find",
+			  "audio/x-wav",
+			    NULL);
+    }
+  }
+
+  if (buf != NULL) {
+    gst_buffer_unref (buf);
+  }
+
+  return new;
 }
 
 static void wav_new_chunk_callback(GstRiffChunk *chunk, gpointer data)

CVS Root:       /cvsroot/gstreamer
Module:         gstreamer
Changes by:     rbultje
Date:           Wed Oct 01 2003  06:12:24 PDT

Log message:
New typefind system:
* bytestream is now part of the core
* all plugins have been modified to use this new typefind system
* asf typefinding added
* mpeg video stream typefiding removed because it's broken
* duplicate typefind entries removed
* extra id3 typefinding added, because we've seen 4 types of files
(riff/wav, flac, vorbis, mp3) with id3 headers and each of these needs
to work. Instead, I've added an id3 element and let it redo typefiding
after the id3 header. this needs a hack because spider only typefinds
once. We can remove this hack once spider supports multiple typefinds.
* with all this, mp3 typefinding is semi-rewritten
* id3 typefinding in flac/vorbis is removed, it's no longer needed
* fixed spider and gst-typefind to use this, too.
* Other general cleanups

Modified files:
    .               : configure.ac
    docs/random     : interfaces

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/configure.ac.diff?r1=1.225&r2=1.226
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/docs/random/interfaces.diff?r1=1.6&r2=1.7

====Begin Diffs====
Index: configure.ac
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/configure.ac,v
retrieving revision 1.225
retrieving revision 1.226
diff -u -d -r1.225 -r1.226
--- configure.ac	21 Aug 2003 04:38:27 -0000	1.225
+++ configure.ac	1 Oct 2003 13:11:42 -0000	1.226
@@ -568,7 +568,6 @@
 gst/registries/Makefile
 libs/Makefile
 libs/gst/Makefile
-libs/gst/bytestream/Makefile
 libs/gst/getbits/Makefile
 libs/gst/control/Makefile
 libs/ext/Makefile
Index: interfaces
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/docs/random/interfaces,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- interfaces	13 Sep 2003 10:17:49 -0000	1.6
+++ interfaces	1 Oct 2003 13:11:42 -0000	1.7
@@ -210,17 +210,6 @@
 So the application would just tread it with the known macro, and
 everything would look extremely simple to the end user.
 
-Also some convenience function to set the element:
-
-void
-gst_interface_set_element (GstInterface *iface,
-			   GstElement   *element)
-{
-  g_return_if_fail (GST_IS_INTERFACE (iface));
-
-  iface->element = element;
-}
-
 4a) mixer
 ---------
 A mixer is a way of controlling volume and input/output channels.
@@ -317,7 +306,7 @@
 			     XID                xid);
 } GstOverlayClass;
 
-That's all!
+That's all! It would look similar for FB & co.
 
 4c) user input
 --------------
@@ -335,8 +324,9 @@
 
 5) Status of this document
 ==========================
-This is a proposal, nothing more. Nothing is implemented. Target
-release is 0.8.0 or any 0.7.x version.
+The interfaces are implemented, more (for metadata, framebuffer-
+overlay, video balancing (brightness), user input etc. are all
+pending.
 
 6) Copyright and blabla
 =======================

CVS Root:       /cvsroot/gstreamer
Module:         gstreamer
Changes by:     rbultje
Date:           Wed Oct 01 2003  06:11:57 PDT

Log message:
New typefind system:
* bytestream is now part of the core
* all plugins have been modified to use this new typefind system
* asf typefinding added
* mpeg video stream typefiding removed because it's broken
* duplicate typefind entries removed
* extra id3 typefinding added, because we've seen 4 types of files
(riff/wav, flac, vorbis, mp3) with id3 headers and each of these needs
to work. Instead, I've added an id3 element and let it redo typefiding
after the id3 header. this needs a hack because spider only typefinds
once. We can remove this hack once spider supports multiple typefinds.
* with all this, mp3 typefinding is semi-rewritten
* id3 typefinding in flac/vorbis is removed, it's no longer needed
* fixed spider and gst-typefind to use this, too.
* Other general cleanups

Modified files:
    gst             : Makefile.am gsttype.c gsttype.h gsttypefind.c
                      gsttypefind.h
    gst/autoplug    : Makefile.am gstsearchfuncs.c gstspideridentity.c
    gst/registries  : gstxmlregistry.c
    libs/gst        : Makefile.am
Added files:
    gst             : gstbytestream.c gstbytestream.h
Removed files:
    libs/gst/bytestream: Makefile.am bstest.c bytestream.c
                      bytestream.h

Links:
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/Makefile.am.diff?r1=1.138&r2=1.139
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/gstbytestream.c?rev=1.1&content-type=text/vnd.viewcvs-markup
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/gstbytestream.h?rev=1.1&content-type=text/vnd.viewcvs-markup
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/gsttype.c.diff?r1=1.42&r2=1.43
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/gsttype.h.diff?r1=1.18&r2=1.19
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/gsttypefind.c.diff?r1=1.36&r2=1.37
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/gsttypefind.h.diff?r1=1.12&r2=1.13
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/autoplug/Makefile.am.diff?r1=1.16&r2=1.17
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/autoplug/gstsearchfuncs.c.diff?r1=1.17&r2=1.18
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/autoplug/gstspideridentity.c.diff?r1=1.40&r2=1.41
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/gst/registries/gstxmlregistry.c.diff?r1=1.32&r2=1.33
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/libs/gst/Makefile.am.diff?r1=1.3&r2=1.4
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/libs/gst/bytestream/Makefile.am
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/libs/gst/bytestream/bstest.c
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/libs/gst/bytestream/bytestream.c
http://cvs.sf.net/cgi-bin/viewcvs.cgi/gstreamer/gstreamer/libs/gst/bytestream/bytestream.h

====Begin Diffs====
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/Makefile.am,v
retrieving revision 1.138
retrieving revision 1.139
diff -u -d -r1.138 -r1.139
--- Makefile.am	13 Sep 2003 01:10:11 -0000	1.138
+++ Makefile.am	1 Oct 2003 13:11:43 -0000	1.139
@@ -16,13 +16,13 @@
 endif
 
 if GST_DISABLE_TYPEFIND
-GST_TYPEFIND_SRC = 
+GST_TYPEFIND_SRC =
 else
 GST_TYPEFIND_SRC = gsttypefind.c
 endif
 
 if GST_DISABLE_AUTOPLUG
-GST_AUTOPLUG_SRC = 
+GST_AUTOPLUG_SRC =
 GST_AUTOPLUG_DIRS =
 else
 GST_AUTOPLUG_SRC = gstautoplug.c
@@ -91,11 +91,12 @@
 	gstmarshal.c		\
 	$(GST_ENUMTYPES_SRC)	\
 	gstobject.c		\
-	$(GST_AUTOPLUG_SRC)	\
 	gstatomic.c		\
+	$(GST_AUTOPLUG_SRC)	\
 	gstbin.c		\
 	gstbuffer.c		\
 	gstbufferpool-default.c	\
+	gstbytestream.c		\
 	gstcaps.c		\
 	gstclock.c		\
 	gstcpu.c		\
@@ -157,6 +158,7 @@
 	gstbin.h		\
 	gstbuffer.h		\
 	gstbufferpool-default.h \
+	gstbytestream.h		\
 	gstcaps.h		\
 	gstclock.h		\
 	gstcompat.h		\
--- NEW FILE: gstbytestream.c ---
/* GStreamer
 * Copyright (C) 2001 Erik Walthinsen <omega@...>
 *
 * gstbytestream.c: adds a convenient bytestream based API to a pad.
 *
 * 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.
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <gst/gstinfo.h>
#include <gst/gstbytestream.h>

GST_DEBUG_CATEGORY_STATIC(debug_bs);
#define GST_CAT_DEFAULT debug_bs

static guint8 *gst_bytestream_assemble (GstByteStream * bs, guint32 len);

static inline void
gst_bytestream_init (GstByteStream *bs)
{
  bs->event = NULL;
  bs->buflist = NULL;
  bs->headbufavail = 0;
  bs->listavail = 0;
  bs->assembled = NULL;
  bs->offset = 0LL;
  bs->in_seek = FALSE;
}
static inline void
gst_bytestream_exit (GstByteStream *bs)
{
  GSList *walk;

  if (bs->event)
    gst_event_unref (bs->event);
  
  walk = bs->buflist;
  while (walk) {
    gst_buffer_unref (GST_BUFFER (walk->data));
    walk = g_slist_next (walk);
  }
  g_slist_free (bs->buflist);

  g_free (bs->assembled);
}
/**
 * gst_bytestream_new:
 * @pad: the pad to attach the bytestream to
 *
 * creates a bytestream from the given pad
 *
 * Returns: a new #GstByteStream object
 */
GstByteStream *
gst_bytestream_new (GstPad * pad)
{
  GstByteStream *bs = g_new (GstByteStream, 1);

  GST_DEBUG_CATEGORY_INIT (debug_bs, "bytestream", 0, "bytestream library");

  bs->pad = pad;
  gst_bytestream_init (bs);

  return bs;
}

/**
 * gst_bytestream_destroy:
 * @bs: the bytestream object to destroy
 *
 * destroy the bytestream object and free its resources.
 */
void
gst_bytestream_destroy (GstByteStream * bs)
{
  gst_bytestream_exit (bs);
  g_free (bs);
}
void
gst_bytestream_reset (GstByteStream *bs)
{
  /* free all data */
  gst_bytestream_exit (bs);
  /* reset data to clean state */
  gst_bytestream_init (bs);
}
/* HOW THIS WORKS:
 *
 * The fundamental structure is a singly-linked list of buffers.  The
 * buffer on the front is the oldest, and thus the first to read data
 * from.  The number of bytes left to be read in this buffer is stored
 * in bs->headbufavail.  The number of bytes available in the entire
 * list (including the head buffer) is in bs->listavail.
 *
 * When a request is made for data (peek), _fill_bytes is called with
 * the number of bytes needed, but only if the listavail indicates
 * that there aren't already enough.  This calls _get_next_buf until
 * the listavail is sufficient to satisfy the demand.
 *
 * _get_next_buf pulls a buffer from the pad the bytestream is attached
 * to, and shoves it in the list.  There are actually two things it can
 * do.  If there's already a buffer in the list, and the _is_span_fast()
 * test returns true, it will merge it with that last buffer.  Otherwise
 * it will simply tack it onto the end of the list.
 *
 * The _peek itself first checks the simple case of the request fitting
 * within the head buffer, and if so creates a subbuffer and returns.
 * Otherwise, it creates a new buffer and allocates space for the request
 * and calls _assemble to fill it.  We know we have to copy because this
 * case only happens when the _merge wasn't feasible during _get_next_buf.
 *
 * The _flush method repeatedly inspects the head buffer and flushes as
 * much data from it as it needs to, up to the size of the buffer.  If
 * the flush decimates the buffer, it's stripped, unref'd, and removed.
 */


/* get the next buffer
 * if the buffer can be merged with the head buffer, do so
 * else add it onto the head of the 
 */
static gboolean
gst_bytestream_get_next_buf (GstByteStream *bs)
{
  GstBuffer *nextbuf, *lastbuf, *headbuf;
  GSList *end;

  /* if there is an event pending, return FALSE */
  if (bs->event)
    return FALSE;

  GST_DEBUG ("get_next_buf: pulling buffer");
  nextbuf = gst_pad_pull (bs->pad);

  if (!nextbuf)
    return FALSE;

  if (GST_IS_EVENT (nextbuf)) {
    bs->event = GST_EVENT (nextbuf);
    return FALSE;
  }

  if (GST_BUFFER_TIMESTAMP_IS_VALID (nextbuf))
    bs->last_ts = GST_BUFFER_TIMESTAMP (nextbuf);

  GST_DEBUG ("get_next_buf: got buffer of %d bytes", GST_BUFFER_SIZE (nextbuf));

  /* first see if there are any buffers in the list at all */
  if (bs->buflist) {
    GST_DEBUG ("gst_next_buf: there is at least one buffer in the list");
    /* now find the end of the list */
    end = g_slist_last (bs->buflist);
    /* get the buffer that's there */
    lastbuf = GST_BUFFER (end->data);

    /* see if we can marge cheaply */
    if (gst_buffer_is_span_fast (lastbuf, nextbuf)) {
      GST_DEBUG ("get_next_buf: merging new buffer with last buf on list");
      /* it is, let's merge them (this is really an append, but...) */
      end->data = gst_buffer_merge (lastbuf, nextbuf);
      /* add to the length of the list */
      bs->listavail += GST_BUFFER_SIZE (nextbuf);

      /* have to check to see if we merged with the head buffer */
      if (end == bs->buflist) {
	bs->headbufavail += GST_BUFFER_SIZE (nextbuf);
      }

      gst_buffer_unref (lastbuf);
      gst_buffer_unref (nextbuf);

      /* if we can't, we just append this buffer */
    }
    else {
      GST_DEBUG ("get_next_buf: adding new buffer to the end of the list");
      end = g_slist_append (end, nextbuf);
      /* also need to increment length of list and buffer count */
      bs->listavail += GST_BUFFER_SIZE (nextbuf);
    }

    /* if there are no buffers in the list */
  }
  else {
    GST_DEBUG ("get_next_buf: buflist is empty, adding new buffer to list");
    /* put this on the end of the list */
    bs->buflist = g_slist_append (bs->buflist, nextbuf);
    /* and increment the number of bytes in the list */
    bs->listavail = GST_BUFFER_SIZE (nextbuf);
    /* set the head buffer avail to the size */
    bs->headbufavail = GST_BUFFER_SIZE (nextbuf);
  }

  /* a zero offset is a indication that we might need to set the timestamp */ 
  if (bs->offset == 0LL){
    headbuf = GST_BUFFER (bs->buflist->data);
    bs->offset = GST_BUFFER_OFFSET(headbuf);
  }
  
  return TRUE;
}

static gboolean
gst_bytestream_fill_bytes (GstByteStream *bs, guint32 len)
{
  /* as long as we don't have enough, we get more buffers */
  while (bs->listavail < len) {
    GST_DEBUG ("fill_bytes: there are %d bytes in the list, we need %d", bs->listavail, len);
    if (!gst_bytestream_get_next_buf (bs))
      return FALSE;
  }

  return TRUE;
}

/**
 * gst_bytestream_peek:
 * @bs: the bytestream to peek
 * @buf: pointer to a variable that can hold a buffer pointer.
 * @len: the number of bytes to peek
 *
 * Peeks len bytes into the bytestream, the result is returned as
 * a #GstBuffer. Unref the buffer after usage.
 * This function can return less bytes than requested. In that case,
 * an event might have happened which you can retrieve with
 * gst_bytestream_get_status().
 *
 * Returns: The number of bytes successfully peeked.
 */
guint32
gst_bytestream_peek (GstByteStream *bs, GstBuffer **buf, guint32 len)
{
  GstBuffer *headbuf, *retbuf = NULL;

  g_return_val_if_fail (bs != NULL, 0);
  g_return_val_if_fail (len > 0, 0);

  GST_DEBUG ("peek: asking for %d bytes", len);

  /* make sure we have enough */
  GST_DEBUG ("peek: there are %d bytes in the list", bs->listavail);
  if (len > bs->listavail) {
    if (!gst_bytestream_fill_bytes (bs, len)) {
      /* we must have an event coming up */
      if (bs->listavail > 0) {
        /* we have some data left, len will be shrunk to the amount of data available */
        len = bs->listavail;
      }
      else {
        /* there is no data */
        *buf = retbuf;
        return 0;
      }
    }
    GST_DEBUG ("peek: there are now %d bytes in the list", bs->listavail);
  }
  gst_bytestream_print_status (bs);

  /* extract the head buffer */
  headbuf = GST_BUFFER (bs->buflist->data);

  /* if the requested bytes are in the current buffer */
  GST_DEBUG ("peek: headbufavail is %d", bs->headbufavail);
  if (len <= bs->headbufavail) {
    GST_DEBUG ("peek: there are enough bytes in headbuf (need %d, have %d)", len, bs->headbufavail);
    /* create a sub-buffer of the headbuf */
    retbuf = gst_buffer_create_sub (headbuf, GST_BUFFER_SIZE (headbuf) - bs->headbufavail, len);
    GST_BUFFER_OFFSET (retbuf) = GST_BUFFER_OFFSET (headbuf) + GST_BUFFER_SIZE (headbuf) - bs->headbufavail;

  }
  /* otherwise we need to figure out how to assemble one */
  else {
    GST_DEBUG ("peek: current buffer is not big enough for len %d", len);

    retbuf = gst_buffer_new ();
    GST_BUFFER_SIZE (retbuf) = len;
    GST_BUFFER_DATA (retbuf) = gst_bytestream_assemble (bs, len);
    GST_BUFFER_TIMESTAMP (retbuf) = bs->last_ts;
  }

  *buf = retbuf;
  return len;
}

/**
 * gst_bytestream_peek_bytes:
 * @bs: the bytestream to peek
 * @data: pointer to a variable that can hold a guint8 pointer.
 * @len: the number of bytes to peek
 *
 * Peeks len bytes into the bytestream, the result is returned as
 * a pointer to a guint8*. The data pointed to be data should not
 * be freed and will become invalid after performing the next bytestream
 * operation.
 * This function can return less bytes than requested. In that case,
 * an event might have happened which you can retrieve with
 * gst_bytestream_get_status().
 *
 * Returns: The number of bytes successfully peeked.
 */
guint32
gst_bytestream_peek_bytes (GstByteStream *bs, guint8** data, guint32 len)
{
  GstBuffer *headbuf;

  g_return_val_if_fail (bs != NULL, 0);
  g_return_val_if_fail (len > 0, 0);

  GST_DEBUG ("peek_bytes: asking for %d bytes", len);
  if (bs->assembled) {
    if (bs->assembled_len >= len) {
      *data = bs->assembled;
      return len;
    }
    g_free (bs->assembled);
    bs->assembled = NULL;
  }

  /* make sure we have enough */
  GST_DEBUG ("peek_bytes: there are %d bytes in the list", bs->listavail);
  if (len > bs->listavail) {
    if (!gst_bytestream_fill_bytes (bs, len)){
      /* we must have an event coming up */
      if (bs->listavail > 0){
        /* we have some data left, len will be shrunk to the amount of data available */
        len = bs->listavail;
      }
      else {
        /* there is no data */
        *data = NULL;
        return 0;
      }
    }
    GST_DEBUG ("peek_bytes: there are now %d bytes in the list", bs->listavail);
  }
  gst_bytestream_print_status (bs);

  /* extract the head buffer */
  headbuf = GST_BUFFER (bs->buflist->data);

  /* if the requested bytes are in the current buffer */
  GST_DEBUG ("peek_bytes: headbufavail is %d", bs->headbufavail);
  if (len <= bs->headbufavail) {
    GST_DEBUG ("peek_bytes: there are enough bytes in headbuf (need %d, have %d)", len, bs->headbufavail);
    /* create a sub-buffer of the headbuf */
    *data = GST_BUFFER_DATA (headbuf) + (GST_BUFFER_SIZE (headbuf) - bs->headbufavail);

  }
  /* otherwise we need to figure out how to assemble one */
  else {
    GST_DEBUG ("peek_bytes: current buffer is not big enough for len %d", len);

    *data = gst_bytestream_assemble (bs, len);
    bs->assembled = *data;
    bs->assembled_len = len;
  }

  return len;
}

static guint8*
gst_bytestream_assemble (GstByteStream *bs, guint32 len)
{
  guint8 *data = g_malloc (len);
  GSList *walk;
  guint32 copied = 0;
  GstBuffer *buf;

  /* copy the data from the curbuf */
  buf = GST_BUFFER (bs->buflist->data);
  GST_DEBUG ("assemble: copying %d bytes from curbuf at %d to *data", bs->headbufavail,
	    GST_BUFFER_SIZE (buf) - bs->headbufavail);
  memcpy (data, GST_BUFFER_DATA (buf) + GST_BUFFER_SIZE (buf) - bs->headbufavail, bs->headbufavail);
  copied += bs->headbufavail;

  /* asumption is made that the buffers all exist in the list */
  walk = g_slist_next (bs->buflist);
  while (copied < len) {
    buf = GST_BUFFER (walk->data);
    if (GST_BUFFER_SIZE (buf) < (len - copied)) {
      GST_DEBUG ("assemble: copying %d bytes from buf to output offset %d", GST_BUFFER_SIZE (buf), copied);
      memcpy (data + copied, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
      copied += GST_BUFFER_SIZE (buf);
    }
    else {
      GST_DEBUG ("assemble: copying %d bytes from buf to output offset %d", len - copied, copied);
      memcpy (data + copied, GST_BUFFER_DATA (buf), len - copied);
      copied = len;
    }
    walk = g_slist_next (walk);
  }

  return data;
}

/**
 * gst_bytestream_flush:
 * @bs: the bytestream to flush
 * @len: the number of bytes to flush
 *
 * Flush len bytes from the bytestream. 
 * This function can return FALSE when the number of
 * bytes could not be flushed due to an event. In that case,
 * you can get the number of available bytes before the event
 * with gst_bytestream_get_status().
 *
 * Returns: TRUE if the number of bytes could be flushed.
 */
gboolean
gst_bytestream_flush (GstByteStream *bs, guint32 len)
{
  GST_DEBUG ("flush: flushing %d bytes", len);

  if (len == 0)
    return TRUE;

  /* make sure we have enough */
  GST_DEBUG ("flush: there are %d bytes in the list", bs->listavail);
  if (len > bs->listavail) {
    if (!gst_bytestream_fill_bytes (bs, len)) {
      return FALSE;
    }
    GST_DEBUG ("flush: there are now %d bytes in the list", bs->listavail);
  }

  gst_bytestream_flush_fast (bs, len);

  return TRUE;
}

/**
 * gst_bytestream_flush_fast:
 * @bs: the bytestream to flush
 * @len: the number of bytes to flush
 *
 * Flushes len bytes from the bytestream. This function
 * is faster than gst_bytestream_flush() but only works
 * when you have recently peeked no less than len bytes
 * with gst_bytestream_peek() or gst_bytestream_peek_bytes().
 */
void
gst_bytestream_flush_fast (GstByteStream *bs, guint32 len)
{
  GstBuffer *headbuf;

  if (len == 0)
    return;
		  
  g_assert (len <= bs->listavail);

  if (bs->assembled) {
    g_free (bs->assembled);
    bs->assembled = NULL;
  }

  /* update the byte offset */
  bs->offset += len;

  /* repeat until we've flushed enough data */
  while (len > 0) {
    headbuf = GST_BUFFER (bs->buflist->data);

    GST_DEBUG ("flush: analyzing buffer that's %d bytes long, offset %" G_GUINT64_FORMAT, GST_BUFFER_SIZE (headbuf),
	      GST_BUFFER_OFFSET (headbuf));

    /* if there's enough to complete the flush */
    if (bs->headbufavail > len) {
      /* just trim it off */
      GST_DEBUG ("flush: trimming %d bytes off end of headbuf", len);
      bs->headbufavail -= len;
      bs->listavail -= len;
      len = 0;

      /* otherwise we have to trim the whole buffer */
    }
    else {
      GST_DEBUG ("flush: removing head buffer completely");
      /* remove it from the list */
      bs->buflist = g_slist_delete_link (bs->buflist, bs->buflist);
      /* trim it from the avail size */
      bs->listavail -= bs->headbufavail;
      /* record that we've trimmed this many bytes */
      len -= bs->headbufavail;
      /* unref it */
      gst_buffer_unref (headbuf);

      /* record the new headbufavail */
      if (bs->buflist) {
	bs->headbufavail = GST_BUFFER_SIZE (GST_BUFFER (bs->buflist->data));
	GST_DEBUG ("flush: next headbuf is %d bytes", bs->headbufavail);
      }
      else {
	GST_DEBUG ("flush: no more bytes at all");
      }
    }

    GST_DEBUG ("flush: bottom of while(), len is now %d", len);
  }
}

/**
 * gst_bytestream_seek:
 * @bs: the bytestream to seek
 * @offset: the byte offset to seek to
 * @method: the seek method.
 *
 * Perform a seek on the bytestream to the given offset.
 * The method can be one of GST_SEEK_METHOD_CUR, GST_SEEK_METHOD_SET,
 * GST_SEEK_METHOD_END.
 * This seek will also flush any pending data in the bytestream or
 * peer elements.
 *
 * Returns: TRUE when the seek succeeded.
 */
gboolean
gst_bytestream_seek (GstByteStream *bs, gint64 offset, GstSeekType method)
{
  GstRealPad *peer;
  
  g_return_val_if_fail (bs != NULL, FALSE);
  
  peer = GST_RPAD_PEER (bs->pad);

  GST_DEBUG ("bs: send event\n");
  if (gst_pad_send_event (GST_PAD (peer), gst_event_new_seek (
			  GST_FORMAT_BYTES | 
			  (method & GST_SEEK_METHOD_MASK) | 
			  GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE, 
			  offset))) 
  {
    gst_bytestream_flush_fast (bs, bs->listavail);

    /* we set the seek flag here. We cannot pull the pad here
     * bacause a seek might occur outisde of the pads cothread context */
    bs->in_seek = TRUE;
    
    return TRUE;
  }
  GST_DEBUG ("bs: send event failed\n");
  return FALSE;
}

/**
 * gst_bytestream_tell
 * @bs: a bytestream
 *
 * Get the current byteoffset in the bytestream.
 *
 * Returns: the offset or -1 on error.
 */
guint64
gst_bytestream_tell (GstByteStream *bs)
{
  GstFormat format;
  gint64 value;
  
  g_return_val_if_fail (bs != NULL, -1);

  format = GST_FORMAT_BYTES;

  if (gst_pad_query (GST_PAD_PEER (bs->pad), GST_QUERY_POSITION, &format, &value)) {
    return value - bs->listavail;
  }
  
  return -1;
}

/**
 * gst_bytestream_length
 * @bs: a bytestream
 *
 * Get the total length of the bytestream.
 *
 * Returns: the total length or -1 on error.
 */
guint64
gst_bytestream_length (GstByteStream *bs)
{
  GstFormat format;
  gint64 value;
  
  g_return_val_if_fail (bs != NULL, -1);

  format = GST_FORMAT_BYTES;

  if (gst_pad_query (GST_PAD_PEER (bs->pad), GST_QUERY_TOTAL, &format, &value)) 
    return value;
  
  return -1;
}

/**
 * gst_bytestream_read:
 * @bs: the bytestream to read
 * @buf: pointer to a variable that can hold a buffer pointer.
 * @len: the number of bytes to read
 *
 * Read len bytes from the bytestream, the result is returned as
 * a #GstBuffer. Unref the buffer after usage.
 * This function can return less bytes than requested. In that case,
 * an event might have happened which you can retrieve with
 * gst_bytestream_get_status().
 *
 * Returns: The number of bytes successfully read.
 */
guint32
gst_bytestream_read (GstByteStream *bs, GstBuffer** buf, guint32 len)
{
  guint32 len_peeked;

  g_return_val_if_fail (bs != NULL, -1);
  
  len_peeked = gst_bytestream_peek (bs, buf, len);
  if (len_peeked == 0)
    return 0;

  gst_bytestream_flush_fast (bs, len_peeked);

  return len_peeked;
}

/**
 * gst_bytestream_size_hint
 * @bs: a bytestream
 * @size: the size to hint
 *
 * Give a hint that we are going to read chunks of the given size.
 * Giving size hints to the peer element might improve performance
 * since less buffers need to be merged.
 *
 * Returns: TRUE if the hint was accepted
 */
gboolean
gst_bytestream_size_hint (GstByteStream *bs, guint32 size)
{
  GstEvent *event;

  g_return_val_if_fail (bs != NULL, FALSE);

  event = gst_event_new_size (GST_FORMAT_BYTES, size);

  return gst_pad_send_event (GST_PAD_PEER (bs->pad), event);
}

/**
 * gst_bytestream_get_status
 * @bs: a bytestream
 * @avail_out: total number of bytes buffered
 * @event_out: an event
 *
 * When an event occurs, the bytestream operations return a value less
 * than the requested length. You must retrieve the event using this API 
 * before reading more bytes from the stream.
 */
void
gst_bytestream_get_status (GstByteStream *bs,
			   guint32 	 *avail_out,
			   GstEvent 	**event_out)
{
  if (avail_out)
    *avail_out = bs->listavail;

  if (event_out) {
    *event_out = bs->event;
    bs->event = NULL;
  }
}

/**
 * gst_bytestream_get_timestamp
 * @bs: a bytestream
 *
 * Get the timestamp of the first data in the bytestream.  If no data
 * exists 1 byte is read to load a new buffer.
 *
 * This function will not check input buffer boundries.  It is  possible
 * the next read could span two or more input buffers with different
 * timestamps.
 *
 * Returns: a timestamp
 */
guint64
gst_bytestream_get_timestamp (GstByteStream *bs)
{
  GstBuffer *headbuf;

  g_return_val_if_fail (bs != NULL, 0);

  GST_DEBUG ("get_timestamp: getting timestamp");

  /* make sure we have a buffer */
  if (bs->listavail == 0) {
    GST_DEBUG ("gst_timestamp: fetching a buffer");
    if (!gst_bytestream_fill_bytes (bs, 1))
      return 0;
  }

  /* extract the head buffer */
  headbuf = GST_BUFFER (bs->buflist->data);

  return GST_BUFFER_TIMESTAMP (headbuf);
}

/**
 * gst_bytestream_print_status
 * @bs: a bytestream
 *
 * Print the current status of the bytestream object. mainly
 * used for debugging purposes.
 */
void
gst_bytestream_print_status (GstByteStream * bs)
{
  GSList *walk;
  GstBuffer *buf;

  GST_DEBUG ("STATUS: head buffer has %d bytes available", bs->headbufavail);
  GST_DEBUG ("STATUS: list has %d bytes available", bs->listavail);
  walk = bs->buflist;
  while (walk) {
    buf = GST_BUFFER (walk->data);
    walk = g_slist_next (walk);

    GST_DEBUG ("STATUS: buffer starts at %" G_GUINT64_FORMAT " and is %d bytes long", 
	      GST_BUFFER_OFFSET (buf), GST_BUFFER_SIZE (buf));
  }
}
--- NEW FILE: gstbytestream.h ---
/* GStreamer
 * Copyright (C) 2001 Erik Walthinsen <omega@...>
 *
 * 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_BYTESTREAM_H__
#define __GST_BYTESTREAM_H__

#include <glib.h>
#include <gst/gstpad.h>
#include <gst/gstevent.h>

G_BEGIN_DECLS

typedef struct _GstByteStream GstByteStream;

struct _GstByteStream {
  GstPad 	*pad;

  GstEvent 	*event;

  GSList 	*buflist;
  guint32 	 headbufavail;
  guint32 	 listavail;

  /* we keep state of assembled pieces */
  guint8	*assembled;
  guint32	 assembled_len; /* only valid when assembled != NULL */

  /* this is needed for gst_bytestream_tell */
  guint64	 offset;
  guint64	 last_ts;

  /* if we are in the seek state (waiting for DISCONT) */
  gboolean	 in_seek;
};

GstByteStream*		gst_bytestream_new		(GstPad *pad);
void			gst_bytestream_destroy		(GstByteStream *bs);

void			gst_bytestream_reset		(GstByteStream *bs);
guint32			gst_bytestream_read		(GstByteStream *bs, GstBuffer** buf, guint32 len);
guint64			gst_bytestream_tell		(GstByteStream *bs);
guint64			gst_bytestream_length		(GstByteStream *bs);
gboolean		gst_bytestream_size_hint	(GstByteStream *bs, guint32 size);
gboolean		gst_bytestream_seek		(GstByteStream *bs, gint64 offset, GstSeekType type);
guint32			gst_bytestream_peek		(GstByteStream *bs, GstBuffer** buf, guint32 len);
guint32			gst_bytestream_peek_bytes	(GstByteStream *bs, guint8** data, guint32 len);
gboolean		gst_bytestream_flush		(GstByteStream *bs, guint32 len);
void                    gst_bytestream_flush_fast       (GstByteStream *bs, guint32 len);
void                    gst_bytestream_get_status	(GstByteStream *bs, guint32 *avail_out, GstEvent **event_out);
guint64			gst_bytestream_get_timestamp	(GstByteStream *bs);

void 			gst_bytestream_print_status	(GstByteStream *bs);

G_END_DECLS

#endif /* __GST_BYTESTREAM_H__ */
Index: gsttype.c
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/gsttype.c,v
retrieving revision 1.42
retrieving revision 1.43
diff -u -d -r1.42 -r1.43
--- gsttype.c	29 Jun 2003 14:05:43 -0000	1.42
+++ gsttype.c	1 Oct 2003 13:11:43 -0000	1.43
@@ -29,6 +29,7 @@
 
 #include "gst_private.h"
 
+#include "gstbytestream.h"
 #include "gsttype.h"
 #include "gstregistrypool.h"
 #include "gstobject.h"
@@ -42,9 +43,7 @@
 static void 		gst_type_factory_class_init 	(GstTypeFactoryClass *klass);
 static void 		gst_type_factory_init 		(GstTypeFactory *factory);
 
-static GstCaps*		gst_type_type_find_dummy		(GstBuffer *buffer, gpointer priv);
-
-static void 		gst_type_factory_unload_thyself 	(GstPluginFeature *feature);
+static void 		gst_type_factory_unload_thyself	(GstPluginFeature *feature);
 
 static GstPluginFeatureClass *parent_class = NULL;
 /* static guint gst_type_factory_signals[LAST_SIGNAL] = { 0 }; */
@@ -315,8 +314,8 @@
     factory->typefindfunc = gst_type_type_find_dummy;
 }
 
-static GstCaps*
-gst_type_type_find_dummy (GstBuffer *buffer, gpointer priv)
+GstCaps*
+gst_type_type_find_dummy (GstByteStream *bs, gpointer priv)
 {
   GstCaps *res = NULL;
   GstTypeFactory *factory = (GstTypeFactory *)priv;
@@ -329,7 +328,7 @@
       g_warning ("could not load valid typefind function for %s\n", factory->mime);
     }
     else if (factory->typefindfunc) {
-      res = factory->typefindfunc (buffer, factory);
+      res = factory->typefindfunc (bs, priv);
     }
   }
 
Index: gsttype.h
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/gsttype.h,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -d -r1.18 -r1.19
--- gsttype.h	19 Dec 2002 21:31:02 -0000	1.18
+++ gsttype.h	1 Oct 2003 13:11:43 -0000	1.19
@@ -24,14 +24,14 @@
 #ifndef __GST_TYPE_H__
 #define __GST_TYPE_H__
 
-#include <gst/gstbuffer.h>
 #include <gst/gstcaps.h>
 #include <gst/gstpluginfeature.h>
+#include <gst/gstbytestream.h>
 
 G_BEGIN_DECLS
 
 /* type of function used to check a stream for equality with type */
-typedef GstCaps*	(*GstTypeFindFunc) 	(GstBuffer *buf, gpointer priv);
+typedef GstCaps*	(*GstTypeFindFunc) 	(GstByteStream *bs, gpointer priv);
 
 typedef struct _GstType GstType;
 typedef struct _GstTypeDefinition GstTypeDefinition;
@@ -74,7 +74,7 @@
 struct _GstTypeFactoryClass {
   GstPluginFeatureClass parent;
 
-  gpointer		 dummy[8];
+  gpointer		dummy[8];
 };
 
 
@@ -97,6 +97,9 @@
 
 /* get the list of registered types (returns list of GstType!) */
 const GList*		gst_type_get_list		(void);
+
+/* dummy typefind function */
+GstCaps*		gst_type_type_find_dummy	(GstByteStream *bs, gpointer priv);
 
 G_END_DECLS
 
Index: gsttypefind.c
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/gsttypefind.c,v
retrieving revision 1.36
retrieving revision 1.37
diff -u -d -r1.36 -r1.37
--- gsttypefind.c	16 Sep 2003 09:57:30 -0000	1.36
+++ gsttypefind.c	1 Oct 2003 13:11:43 -0000	1.37
@@ -26,8 +26,6 @@
 #include "gstinfo.h"
 #include "gsttypefind.h"
 
-#define DEFAULT_MAX_BUFFERS	1
-
 GstElementDetails gst_type_find_details = {
   "TypeFind",
   "Generic",
@@ -39,6 +37,13 @@
   "(C) 1999",
 };
 
+/* generic templates */
+GST_PAD_TEMPLATE_FACTORY (type_find_sink_factory,
+  "sink",
+  GST_PAD_SINK,
+  GST_PAD_ALWAYS,
+  NULL
+);
 
 /* TypeFind signals and args */
 enum {
@@ -49,7 +54,6 @@
 enum {
   ARG_0,
   ARG_CAPS,
-  ARG_MAX_BUFFERS,
 };
 
 
@@ -63,7 +67,7 @@
 						 GValue *value, 
 						 GParamSpec *pspec);
 
-static void	gst_type_find_chain		(GstPad *pad, GstBuffer *buf);
+static void	gst_type_find_loopfunc		(GstElement *element);
 static GstElementStateReturn
 		gst_type_find_change_state 	(GstElement *element);
 
@@ -88,7 +92,9 @@
       (GInstanceInitFunc)gst_type_find_init,
       NULL
     };
-    typefind_type = g_type_register_static (GST_TYPE_ELEMENT, "GstTypeFind", &typefind_info, 0);
+    typefind_type = g_type_register_static (GST_TYPE_ELEMENT,
+					    "GstTypeFind",
+					    &typefind_info, 0);
   }
   return typefind_type;
 }
@@ -106,11 +112,6 @@
 
   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CAPS,
     g_param_spec_pointer ("caps", "Caps", "Found capabilities", G_PARAM_READABLE));
-  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MAX_BUFFERS,
-    g_param_spec_int ("max_buffers", 
-	    	      "Max Buffers", 
-		      "Maximal amount of buffers before giving en error (0 == unlimited)", 
-		      0, G_MAXINT, DEFAULT_MAX_BUFFERS, G_PARAM_READWRITE));
 
   gst_type_find_signals[HAVE_TYPE] =
       g_signal_new ("have_type", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
@@ -127,12 +128,13 @@
 static void
 gst_type_find_init (GstTypeFind *typefind)
 {
-  typefind->sinkpad = gst_pad_new ("sink", GST_PAD_SINK);
+  typefind->sinkpad = gst_pad_new_from_template (
+		GST_PAD_TEMPLATE_GET (type_find_sink_factory), "sink");
   gst_element_add_pad (GST_ELEMENT (typefind), typefind->sinkpad);
-  gst_pad_set_chain_function (typefind->sinkpad, gst_type_find_chain);
 
-  typefind->num_buffer = 0;
-  typefind->max_buffers = DEFAULT_MAX_BUFFERS;
+  gst_element_set_loop_function (GST_ELEMENT (typefind),
+				 gst_type_find_loopfunc);
+
   typefind->caps = NULL;
 }
 
@@ -147,9 +149,6 @@
   typefind = GST_TYPE_FIND (object);
 
   switch (prop_id) {
-    case ARG_MAX_BUFFERS:
-      typefind->max_buffers = g_value_get_int (value);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -170,9 +169,6 @@
     case ARG_CAPS:
       g_value_set_pointer (value, typefind->caps);
       break;
-    case ARG_MAX_BUFFERS:
-      g_value_set_int (value, typefind->max_buffers);
-      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
@@ -180,18 +176,16 @@
 }
 
 static void
-gst_type_find_chain (GstPad *pad, GstBuffer *buf)
+gst_type_find_loopfunc (GstElement *element)
 {
   GstTypeFind *typefind;
   const GList *type_list;
   GstType *type;
 
-  g_return_if_fail (GST_IS_PAD (pad));
-
-  typefind = GST_TYPE_FIND (GST_OBJECT_PARENT (pad));
+  typefind = GST_TYPE_FIND (element);
 
-  GST_DEBUG ("got buffer of %d bytes in '%s'",
-        GST_BUFFER_SIZE (buf), GST_OBJECT_NAME (typefind));
+  GST_DEBUG ("Started typefinding loop in '%s'",
+	     GST_OBJECT_NAME (typefind));
 
   type_list = gst_type_get_list ();
 
@@ -203,42 +197,34 @@
 
     while (factories) {
       GstTypeFactory *factory = GST_TYPE_FACTORY (factories->data);
-      GstTypeFindFunc typefindfunc = (GstTypeFindFunc)factory->typefindfunc;
+      GstTypeFindFunc typefindfunc = (GstTypeFindFunc) factory->typefindfunc;
       GstCaps *caps;
 
       GST_CAT_DEBUG (GST_CAT_TYPES, "try type (%p) :%d \"%s\" %p", 
 		 factory, type->id, type->mime, typefindfunc);
-      if (typefindfunc && (caps = typefindfunc (buf, factory))) {
+      if (typefindfunc && (caps = typefindfunc (typefind->bs, factory))) {
         GST_CAT_DEBUG (GST_CAT_TYPES, "found type: %d \"%s\" \"%s\"", 
 		   caps->id, type->mime, gst_caps_get_name (caps));
-	typefind->caps = caps;
+	gst_caps_replace (&typefind->caps, caps);
 
-	if (gst_pad_try_set_caps (pad, caps) <= 0) {
+	if (gst_pad_try_set_caps (typefind->sinkpad, caps) <= 0) {
           g_warning ("typefind: found type but peer didn't accept it");
 	}
 
-	{
-	  gst_object_ref (GST_OBJECT (typefind));
-          g_signal_emit (G_OBJECT (typefind), gst_type_find_signals[HAVE_TYPE], 0,
-	                      typefind->caps);
-	  gst_object_unref (GST_OBJECT (typefind));
-          goto end;
-	}
+	gst_object_ref (GST_OBJECT (typefind));
+	g_signal_emit (G_OBJECT (typefind), gst_type_find_signals[HAVE_TYPE],
+		       0, typefind->caps);
+	gst_object_unref (GST_OBJECT (typefind));
+        return;
       }
       factories = g_slist_next (factories);
     }
     type_list = g_list_next (type_list);
   }
 
-  typefind->num_buffer++;
-
-end:
-  gst_buffer_unref (buf);
-
-  if (typefind->max_buffers && typefind->num_buffer >= typefind->max_buffers) {
-    gst_element_error (GST_ELEMENT (typefind), 
-		    "typefind could not determine type after %d buffers", typefind->num_buffer);
-  }
+  /* if we get here, nothing worked... :'(. */
+  gst_element_error (GST_ELEMENT (typefind), 
+		     "media type could not be detected");
 }
 
 static GstElementStateReturn
@@ -250,17 +236,14 @@
   typefind = GST_TYPE_FIND (element);
 
   switch (GST_STATE_TRANSITION (element)) {
-    case GST_STATE_NULL_TO_READY:
-      break;
     case GST_STATE_READY_TO_PAUSED:
-      typefind->num_buffer = 0;
-      gst_caps_unref (typefind->caps);
-      typefind->caps = NULL;
+      typefind->bs = gst_bytestream_new (typefind->sinkpad);
       break;
-    case GST_STATE_PAUSED_TO_PLAYING:
-    case GST_STATE_PLAYING_TO_PAUSED:
     case GST_STATE_PAUSED_TO_READY:
-    case GST_STATE_READY_TO_NULL:
+      gst_bytestream_destroy (typefind->bs);
+      gst_caps_replace (&typefind->caps, NULL);
+      break;
+    default:
       break;
   }
   
Index: gsttypefind.h
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/gsttypefind.h,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- gsttypefind.h	26 May 2003 06:15:27 -0000	1.12
+++ gsttypefind.h	1 Oct 2003 13:11:43 -0000	1.13
@@ -27,6 +27,7 @@
 #ifndef GST_DISABLE_TYPE_FIND
 
 #include <gst/gstelement.h>
+#include <gst/gstbytestream.h>
 
 G_BEGIN_DECLS
 
@@ -46,11 +47,9 @@
   GstElement 	 element;
 
   GstPad 	*sinkpad;
+  GstByteStream *bs;
 
   GstCaps 	*caps;
-
-  gint 		 num_buffer;
-  gint 		 max_buffers;
 };
 
 struct _GstTypeFindClass {
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/autoplug/Makefile.am,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -d -r1.16 -r1.17
--- Makefile.am	8 Dec 2002 14:39:35 -0000	1.16
+++ Makefile.am	1 Oct 2003 13:11:43 -0000	1.17
@@ -27,13 +27,15 @@
 libgstautoplugger_la_LIBADD =
 libgstautoplugger_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
 
-libgstspider_la_SOURCES = gstspider.c gstspideridentity.c gstsearchfuncs.c
+libgstspider_la_SOURCES = \
+	gstspider.c gstspideridentity.c \
+	gstsearchfuncs.c
 libgstspider_la_CFLAGS = $(GST_CFLAGS)
 libgstspider_la_LIBADD =
 libgstspider_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
 
 noinst_HEADERS = gststaticautoplug.h gststaticautoplugrender.h \
-	gstspider.h gstspideridentity.h gstsearchfuncs.h
+	gstspider.h gstspideridentity.h gstsearchfuncs.h 
 
 noinst_PROGRAMS = autoplugtest spidertest
 
Index: gstsearchfuncs.c
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/autoplug/gstsearchfuncs.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- gstsearchfuncs.c	18 Aug 2003 21:14:16 -0000	1.17
+++ gstsearchfuncs.c	1 Oct 2003 13:11:43 -0000	1.18
@@ -250,11 +250,12 @@
   GList *ret = NULL;
   GstElementFactory *factory;
   GList *templs;
-  
+
   while (factories)
   {
     factory = (GstElementFactory *) factories->data;
     templs = factory->padtemplates;
+
     if (GST_PLUGIN_FEATURE (factory)->rank > 0){
       gboolean have_src = FALSE;
       gboolean have_sink = FALSE;
@@ -341,6 +342,7 @@
   
   GST_INFO ("attempting to autoplug via shortest path from %s to %s", 
 	    gst_caps_get_mime (srccaps), gst_caps_get_mime (sinkcaps));
+
   gst_caps_debug (srccaps, "source caps");
   gst_caps_debug (sinkcaps, "sink caps");
   /* wrap all factories as GstAutoplugNode 
Index: gstspideridentity.c
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/autoplug/gstspideridentity.c,v
retrieving revision 1.40
retrieving revision 1.41
diff -u -d -r1.40 -r1.41
--- gstspideridentity.c	16 Sep 2003 09:57:30 -0000	1.40
+++ gstspideridentity.c	1 Oct 2003 13:11:43 -0000	1.41
@@ -413,61 +413,22 @@
 static void
 gst_spider_identity_sink_loop_type_finding (GstSpiderIdentity *ident)
 {
-  GstBuffer *buf=NULL;
-  GstBuffer *typefindbuf = NULL;
-  gboolean getmorebuf = TRUE;
+  GstBuffer *buf = NULL;
   GList *type_list;
   GstCaps *caps;
+  GstByteStream *bs;
 
-  /* this should possibly be a property */
-  guint bufsizelimit = 4096;
-  
   g_return_if_fail (GST_IS_SPIDER_IDENTITY (ident));
 
-  while (getmorebuf){
-
-    /* check if our buffer is big enough to do a typefind */
-    if (typefindbuf && GST_BUFFER_SIZE(typefindbuf) >= bufsizelimit){
-      getmorebuf = FALSE;
-      break;
-    }
-    buf = gst_pad_pull (ident->sink);
-  
-    /* if it's an event... */
-    while (GST_IS_EVENT (buf)) {
-      switch (GST_EVENT_TYPE (GST_EVENT (buf))){
-      case GST_EVENT_EOS:
-        getmorebuf = FALSE;
-	/* FIXME Notify the srcs that EOS has happened */
-        gst_pad_event_default (ident->sink, GST_EVENT (buf));
-	break;
-      default:
-        gst_pad_event_default (ident->sink, GST_EVENT (buf));
-        buf = gst_pad_pull (ident->sink);
-        break;
-      }
-      /* handle DISCONT events, please */
-    }
-
-    typefindbuf = buf;
-    getmorebuf = FALSE;
-    /* FIXME merging doesn't work for some reason so 
-     * we'll just typefind with the first element
-    if (!typefindbuf){
-      typefindbuf = buf;
-      gst_buffer_ref(buf);
-    }
-    else {
-      GstBuffer *oldbuf = typefindbuf;
-      typefindbuf = gst_buffer_merge(typefindbuf, buf);
-      gst_buffer_unref(oldbuf);
-      gst_buffer_unref(buf);
-    }
-    */
-  }
-  
-  if (!typefindbuf){
+  /* get a bytestream object */
+  bs = gst_bytestream_new (ident->sink);
+  if (gst_bytestream_peek (bs, &buf, 1) != 1 || !buf) {
+    buf = NULL;
+    g_warning ("Failed to read fake buffer - serious idiocy going on here");
     goto end;
+  } else {
+    gst_buffer_unref (buf);
+    buf = NULL;
   }
 
   /* maybe there are already valid caps now? */
@@ -487,7 +448,7 @@
       GstTypeFindFunc typefindfunc = (GstTypeFindFunc)factory->typefindfunc;
 
       GST_DEBUG ("trying typefind function %s", GST_PLUGIN_FEATURE_NAME (factory));
-      if (typefindfunc && (caps = typefindfunc (buf, factory))) {
+      if (typefindfunc && (caps = typefindfunc (bs, factory))) {
         GST_INFO ("typefind function %s found caps", GST_PLUGIN_FEATURE_NAME (factory));
         if (gst_pad_try_set_caps (ident->src, caps) <= 0) {
           g_warning ("typefind: found type but peer didn't accept it");
@@ -501,7 +462,6 @@
     type_list = g_list_next (type_list);
   }
   gst_element_error(GST_ELEMENT(ident), "Could not find media type", NULL);
-  gst_buffer_unref(buf);
   buf = GST_BUFFER (gst_event_new (GST_EVENT_EOS));
 
 end:
@@ -512,15 +472,19 @@
   
   /* push the buffer */
   gst_spider_identity_chain (ident->sink, buf);
+
+  /* bytestream no longer needed */
+  gst_bytestream_destroy (bs);
   
   return;
 
 plug:
-
   gst_caps_debug (caps, "spider starting caps");
   gst_caps_sink (caps);
 
-  gst_spider_identity_plug (ident);  
+  gst_spider_identity_plug (ident);
+
+  gst_bytestream_read (bs, &buf, bs->listavail);
 
   goto end;
 }
Index: gstxmlregistry.c
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/gst/registries/gstxmlregistry.c,v
retrieving revision 1.32
retrieving revision 1.33
diff -u -d -r1.32 -r1.33
--- gstxmlregistry.c	27 Sep 2003 18:51:16 -0000	1.32
+++ gstxmlregistry.c	1 Oct 2003 13:11:44 -0000	1.33
@@ -711,29 +711,6 @@
   return TRUE;
 }
 
-static GstCaps*
-gst_type_type_find_dummy (GstBuffer *buffer, gpointer priv)
-{
-  GstTypeFactory *factory = (GstTypeFactory *)priv;
-
-  GST_CAT_DEBUG (GST_CAT_TYPES,"gsttype: need to load typefind function for %s", factory->mime);
-
-  if (gst_plugin_feature_ensure_loaded (GST_PLUGIN_FEATURE (factory))) {
-    if (factory->typefindfunc) {
-      if (factory->typefindfunc == gst_type_type_find_dummy) {
-	GST_CAT_WARNING (GST_CAT_TYPES, "GstTypeFactory %s for mime %s exts %s does not install a valid typefindfunc",
-			 factory->feature.name, factory->mime, factory->exts);
-      } else {
-	GstCaps *res = factory->typefindfunc (buffer, factory);
-	if (res)
-	  return res;
-      }
-    }
-  }
-  return NULL;
-}
-
-
 static gboolean
 gst_xml_registry_parse_type_factory (GMarkupParseContext *context, const gchar *tag, const gchar *text,
                                      gsize text_len, GstXMLRegistry *registry, GError **error)
Index: Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gstreamer/libs/gst/Makefile.am,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- Makefile.am	6 Aug 2003 01:06:30 -0000	1.3
+++ Makefile.am	1 Oct 2003 13:11:44 -0000	1.4
@@ -1,3 +1,3 @@
-SUBDIRS = bytestream control getbits
+SUBDIRS = control getbits
 
-DIST_SUBDIRS = bytestream control getbits
+DIST_SUBDIRS = control getbits
--- Makefile.am DELETED ---
--- bstest.c DELETED ---
--- bytestream.c DELETED ---
--- bytestream.h DELETED ---