Initial revision

Original commit message from CVS:
Initial revision

69 files changed, 12465 insertions, 0 deletions

diff --git a/gst/chart/.gitignore b/gst/chart/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/chart/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/chart/Makefile.am b/gst/chart/Makefile.am
new file mode 100644
index 00000000..c85c60af
--- /dev/null
+++ b/gst/chart/Makefile.am
@@ -0,0 +1,4 @@
+filterdir = $(libdir)/gst
+filter_LTLIBRARIES = libchart.la
+libchart_la_SOURCES = gstchart.c
+libchart_la_CFLAGS = $(GST_CFLAGS)
diff --git a/gst/chart/gstchart.c b/gst/chart/gstchart.c
new file mode 100644
index 00000000..1ec25970
--- /dev/null
+++ b/gst/chart/gstchart.c
@@ -0,0 +1,456 @@
+/* gstchart.c: implementation of chart drawing element
+ * Copyright (C) <2001> Richard Boulton <richard@tartarus.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <gst/gst.h>
+
+#define GST_TYPE_CHART (gst_chart_get_type())
+#define GST_CHART(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CHART,GstChart))
+#define GST_CHART_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CHART,GstChart))
+#define GST_IS_CHART(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CHART))
+#define GST_IS_CHART_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CHART))
+
+typedef struct _GstChart GstChart;
+typedef struct _GstChartClass GstChartClass;
+
+struct _GstChart {
+  GstElement element;
+
+  /* pads */
+  GstPad *sinkpad,*srcpad;
+  GstBufferPool *peerpool;
+
+  // the timestamp of the next frame
+  guint64 next_time;
+
+  // video state
+  gint bpp;
+  gint depth;
+  gint width;
+  gint height;
+
+  gint samplerate;
+  gint framerate; // desired frame rate
+  gint samples_between_frames; // number of samples between start of successive frames
+  gint samples_since_last_frame; // number of samples between start of successive frames
+};
+
+struct _GstChartClass {
+  GstElementClass parent_class;
+};
+
+GType gst_chart_get_type(void);
+
+
+/* elementfactory information */
+static GstElementDetails gst_chart_details = {
+  "chart drawer",
+  "Filter/Visualization",
+  "Takes frames of data and outputs video frames of a chart of data",
+  VERSION,
+  "Richard Boulton <richard@tartarus.org>",
+  "(C) 2001",
+};
+
+/* signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+static GstPadTemplate*
+src_template_factory (void) 
+{
+  static GstPadTemplate *template = NULL;
+  
+  if (!template) {
+    template = gst_padtemplate_new (
+  	"src",
+  	GST_PAD_SRC,
+  	GST_PAD_ALWAYS,
+  	gst_caps_new (
+  	  "chartsrc",
+    	  "video/raw",
+	  /*gst_props_new (
+    	    "format",	GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R','G','B',' ')),
+	    "bpp",	GST_PROPS_INT (32),
+	    "depth",	GST_PROPS_INT (32),
+	    "endianness", GST_PROPS_INT (G_BYTE_ORDER),
+	    "red_mask",   GST_PROPS_INT (0xff0000),
+	    "green_mask", GST_PROPS_INT (0xff00),
+	    "blue_mask",  GST_PROPS_INT (0xff),
+    	    "width",	GST_PROPS_INT_RANGE (16, 4096),
+    	    "height",	GST_PROPS_INT_RANGE (16, 4096),
+	    NULL),*/
+	  gst_props_new (
+    	    "format",	GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R','G','B',' ')),
+	    "bpp",	GST_PROPS_INT (16),
+	    "depth",	GST_PROPS_INT (16),
+	    "endianness", GST_PROPS_INT (G_BYTE_ORDER),
+	    "red_mask",   GST_PROPS_INT (0xf800),
+	    "green_mask", GST_PROPS_INT (0x07e0),
+	    "blue_mask",  GST_PROPS_INT (0x001f),
+    	    "width",	GST_PROPS_INT_RANGE (16, 4096),
+    	    "height",	GST_PROPS_INT_RANGE (16, 4096),
+	    NULL)
+	),
+	NULL);
+  }
+  return template;
+}
+
+static GstPadTemplate*
+sink_template_factory (void)
+{
+  static GstPadTemplate *template = NULL;
+
+  if (!template) {
+    template = gst_padtemplate_new (
+  	"sink",					/* the name of the pads */
+  	GST_PAD_SINK,				/* type of the pad */
+  	GST_PAD_ALWAYS,				/* ALWAYS/SOMETIMES */
+  	gst_caps_new (
+     	  "chartsink",				/* the name of the caps */
+     	  "audio/raw",				/* the mime type of the caps */
+	  gst_props_new (
+     	    /* Properties follow: */
+            "format",       GST_PROPS_STRING ("int"),
+              "law",        GST_PROPS_INT (0),
+              "endianness", GST_PROPS_INT (G_BYTE_ORDER),
+              "signed",     GST_PROPS_BOOLEAN (TRUE),
+              "width",      GST_PROPS_INT (16),
+	      "depth",      GST_PROPS_INT (16),
+	      "rate",       GST_PROPS_INT_RANGE (8000, 96000),
+     	      "channels",   GST_PROPS_INT (1),
+	      NULL)
+  	),
+  	NULL);
+  }
+
+  return template;
+}
+
+
+
+
+static void	gst_chart_class_init	(GstChartClass *klass);
+static void	gst_chart_init		(GstChart *chart);
+
+static void	gst_chart_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void	gst_chart_get_property	(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static void	gst_chart_chain		(GstPad *pad, GstBuffer *buf);
+
+static GstElementClass *parent_class = NULL;
+
+static void gst_chart_newsinkcaps (GstPad *pad, GstCaps *caps);
+static void gst_chart_newsrccaps (GstPad *pad, GstCaps *caps);
+
+GType
+gst_chart_get_type (void)
+{
+  static GType type = 0;
+
+  if (!type) {
+    static const GTypeInfo info = {
+      sizeof(GstChartClass),      NULL,      NULL,      (GClassInitFunc)gst_chart_class_init,
+      NULL,
+      NULL,
+      sizeof(GstChart),
+      0,
+      (GInstanceInitFunc)gst_chart_init,
+    };
+    type = g_type_register_static(GST_TYPE_ELEMENT, "GstChart", &info, 0);
+  }
+  return type;
+}
+
+static void
+gst_chart_class_init(GstChartClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  gobject_class->set_property = gst_chart_set_property;
+  gobject_class->get_property = gst_chart_get_property;
+}
+
+static void
+gst_chart_init (GstChart *chart)
+{
+  /* create the sink and src pads */
+  chart->sinkpad = gst_pad_new_from_template (sink_template_factory (), "sink");
+  chart->srcpad = gst_pad_new_from_template (src_template_factory (), "src");
+  gst_element_add_pad (GST_ELEMENT (chart), chart->sinkpad);
+  gst_element_add_pad (GST_ELEMENT (chart), chart->srcpad);
+
+  gst_pad_set_chain_function (chart->sinkpad, gst_chart_chain);
+  gst_pad_set_newcaps_function (chart->sinkpad, gst_chart_newsinkcaps);
+  gst_pad_set_newcaps_function (chart->srcpad, gst_chart_newsrccaps);
+
+
+  chart->next_time = 0;
+  chart->peerpool = NULL;
+
+  // reset the initial video state
+  chart->bpp = 16;
+  chart->depth = 16;
+  chart->width = -1;
+  chart->height = -1;
+
+  chart->samplerate = -1;
+  chart->framerate = 25; // desired frame rate
+  chart->samples_between_frames = 0; // number of samples between start of successive frames
+  chart->samples_since_last_frame = 0;
+}
+
+static void
+gst_chart_newsinkcaps (GstPad *pad, GstCaps *caps)
+{
+  GstChart *chart;
+  chart = GST_CHART (gst_pad_get_parent (pad));
+
+  chart->samplerate = gst_caps_get_int (caps, "rate");
+  chart->samples_between_frames = chart->samplerate / chart->framerate;
+
+  GST_DEBUG (0, "CHART: new sink caps: rate %d\n",
+	     chart->samplerate);
+  //gst_chart_sync_parms (chart);
+}
+
+static void
+gst_chart_newsrccaps (GstPad *pad, GstCaps *caps)
+{
+  GstChart *chart;
+  chart = GST_CHART (gst_pad_get_parent (pad));
+
+  chart->bpp = gst_caps_get_int (caps, "bpp");
+  chart->depth = gst_caps_get_int (caps, "depth");
+  chart->width = gst_caps_get_int (caps, "width");
+  chart->height = gst_caps_get_int (caps, "height");
+
+  GST_DEBUG (0, "CHART: new src caps: bpp %d, depth %d, width %d, height %d\n",
+	     chart->bpp, chart->depth, chart->width, chart->height);
+  //gst_chart_sync_parms (chart);
+}
+
+static void
+gst_chart_free (GstChart *chart)
+{
+  g_free (chart);
+}
+
+static void
+draw_chart_16bpp(guchar * output, gint width, gint height,
+		 gint16 * src_data, gint src_size)
+{
+    gint i;
+    guint16 *colstart;
+    gint16 * in;
+
+    GST_DEBUG (0, "CHART: drawing frame to %p, width = %d, height = %d, src_data = %p, src_size = %d\n",
+	       output, width, height, src_data, src_size);
+    
+    for (colstart = (guint16 *)output, in = (gint16 *)src_data, i = 0;
+	 i < width;
+	 colstart++, in++, i++) {
+	guint16 * pos = colstart;
+	gint h1;
+
+	h1 = (((gint)(*in)) * height / (1 << 16)) + height / 2;
+	if (h1 >= height) h1 = height;
+
+	if (h1 < height / 2) {
+	    while (pos < colstart + h1 * width) {
+		*pos = 0x0000;
+		pos += width;
+	    }
+	    while (pos < colstart + height / 2 * width) {
+		*pos = 0x07e0;
+		pos += width;
+	    }
+	    while (pos < colstart + height * width) {
+		*pos = 0x0000;
+		pos += width;
+	    }
+	} else {
+	    while (pos < colstart + height / 2 * width) {
+		*pos = 0x0000;
+		pos += width;
+	    }
+	    while (pos < colstart + h1 * width) {
+		*pos = 0x07e0;
+		pos += width;
+	    }
+	    while (pos < colstart + height * width) {
+		*pos = 0x0000;
+		pos += width;
+	    }
+	}
+    }
+}
+
+static void
+gst_chart_chain (GstPad *pad, GstBuffer *bufin)
+{
+  GstChart *chart;
+  GstBuffer *bufout;
+  guint32 samples_in;
+  guint32 sizeout;
+  gint16 *datain;
+  guchar *dataout;
+
+  g_return_if_fail (bufin != NULL);
+  g_return_if_fail (pad != NULL);
+  g_return_if_fail (GST_IS_PAD(pad));
+  g_return_if_fail (GST_IS_CHART(GST_OBJECT_PARENT(pad)));
+  chart = GST_CHART(GST_OBJECT_PARENT (pad));
+  g_return_if_fail (chart != NULL);
+
+  GST_DEBUG (0, "CHART: chainfunc called\n");
+
+  samples_in = GST_BUFFER_SIZE (bufin) / sizeof(gint16);
+  datain = (gint16 *) (GST_BUFFER_DATA (bufin));
+  GST_DEBUG (0, "input buffer has %d samples\n", samples_in);
+  if (chart->next_time <= GST_BUFFER_TIMESTAMP (bufin)) {
+    chart->next_time = GST_BUFFER_TIMESTAMP (bufin);
+    GST_DEBUG (0, "in:  %lld\n", GST_BUFFER_TIMESTAMP (bufin));
+  }
+
+  chart->samples_since_last_frame += samples_in;
+  if (chart->samples_between_frames <= chart->samples_since_last_frame) {
+      chart->samples_since_last_frame = 0;
+
+      // Check if we need to renegotiate size.
+      if (chart->width == -1 || chart->height == -1) {
+	  chart->width = 256;
+	  chart->height = 128;
+	  GST_DEBUG (0, "making new pad\n");
+	  gst_pad_set_caps (chart->srcpad,
+			    gst_caps_new (
+					  "chartsrc",
+					  "video/raw",
+					  gst_props_new (
+							 "format",	GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R','G','B',' ')),
+							 "bpp",		GST_PROPS_INT (chart->bpp),
+							 "depth",	GST_PROPS_INT (chart->depth),
+							 "endianness",	GST_PROPS_INT (G_BYTE_ORDER),
+							 "red_mask",	GST_PROPS_INT (0xf800),
+							 "green_mask",	GST_PROPS_INT (0x07e0),
+							 "blue_mask",	GST_PROPS_INT (0x001f),
+							 "width",	GST_PROPS_INT (chart->width),
+							 "height",	GST_PROPS_INT (chart->height),
+							 NULL)));
+      }
+
+      // get data to draw into buffer
+      if (samples_in >= chart->width) {
+	  // make a new buffer for the output
+	  bufout = gst_buffer_new ();
+	  sizeout = chart->bpp / 8 * chart->width * chart->height;
+	  dataout = g_malloc (sizeout);
+	  GST_BUFFER_SIZE(bufout) = sizeout;
+	  GST_BUFFER_DATA(bufout) = dataout;
+	  GST_DEBUG (0, "CHART: made new buffer: size %d, width %d, height %d\n",
+		     sizeout, chart->width, chart->height);
+
+	  // take data and draw to new buffer
+	  // FIXME: call different routines for different properties
+	  draw_chart_16bpp(dataout, chart->width, chart->height, (gint16 *)datain, samples_in);
+
+	  // set timestamp
+	  GST_BUFFER_TIMESTAMP (bufout) = chart->next_time;
+
+	  GST_DEBUG (0, "CHART: outputting buffer\n");
+	  // output buffer
+	  GST_BUFFER_FLAG_SET (bufout, GST_BUFFER_READONLY);
+	  gst_pad_push (chart->srcpad, bufout);
+      }
+  } else {
+      GST_DEBUG (0, "CHART: skipping buffer\n");
+  }
+
+  gst_buffer_unref(bufin);
+  GST_DEBUG (0, "CHART: exiting chainfunc\n");
+}
+
+static void
+gst_chart_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstChart *chart;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail (GST_IS_CHART (object));
+  chart = GST_CHART (object);
+
+  switch (prop_id) {
+    default:
+      break;
+  }
+}
+
+static void
+gst_chart_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstChart *chart;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail (GST_IS_CHART (object));
+  chart = GST_CHART (object);
+
+  switch (prop_id) {
+    default:
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* create an elementfactory for the chart element */
+  factory = gst_elementfactory_new("chart",GST_TYPE_CHART,
+                                   &gst_chart_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+
+  gst_elementfactory_add_padtemplate (factory, src_template_factory ());
+  gst_elementfactory_add_padtemplate (factory, sink_template_factory ());
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "chart",
+  plugin_init
+};
diff --git a/gst/deinterlace/.gitignore b/gst/deinterlace/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/deinterlace/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/deinterlace/Makefile.am b/gst/deinterlace/Makefile.am
new file mode 100644
index 00000000..eafa47d5
--- /dev/null
+++ b/gst/deinterlace/Makefile.am
@@ -0,0 +1,9 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstdeinterlace.la
+
+libgstdeinterlace_la_SOURCES = gstdeinterlace.c
+libgstdeinterlace_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstdeinterlace.h 
+
diff --git a/gst/deinterlace/gstdeinterlace.c b/gst/deinterlace/gstdeinterlace.c
new file mode 100644
index 00000000..99a70c84
--- /dev/null
+++ b/gst/deinterlace/gstdeinterlace.c
@@ -0,0 +1,390 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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.
+ */
+/* based on the Area Based Deinterlacer (for RGB frames)        */
+/* (a VirtualDub filter) from Gunnar Thalin <guth@home.se>      */
+
+#include <string.h>
+#include <gst/gst.h>
+#include "gstdeinterlace.h"
+
+static GstElementDetails deinterlace_details = {
+  "DeInterlace",
+  "Filter/Effect",
+  "Deinterlace video",
+  VERSION,
+  "Wim Taymans <wim.taymans@chello.be>",
+  "(C) 2001",
+};
+
+
+/* Filter signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_DI_ONLY,
+  ARG_BLEND,
+  ARG_THRESHOLD,
+  ARG_EDGE_DETECT,
+};
+
+GST_PADTEMPLATE_FACTORY (deinterlace_src_factory,
+  "src",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+   "deinterlace_src",
+   "video/raw",
+     "format",   GST_PROPS_FOURCC (GST_STR_FOURCC ("I420"))
+  )
+)
+
+GST_PADTEMPLATE_FACTORY (deinterlace_sink_factory,
+  "sink",
+  GST_PAD_SINK,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+   "deinterlace_src",
+   "video/raw",
+     "format",   GST_PROPS_FOURCC (GST_STR_FOURCC ("I420"))
+  )
+)
+
+static GType 		gst_deinterlace_get_type		(void);
+
+static void		gst_deinterlace_class_init		(GstDeInterlaceClass *klass);
+static void		gst_deinterlace_init			(GstDeInterlace *filter);
+
+static void		gst_deinterlace_set_property			(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void		gst_deinterlace_get_property			(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static void		gst_deinterlace_chain			(GstPad *pad, GstBuffer *buf);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_filter_signals[LAST_SIGNAL] = { 0 };
+
+static GstPadNegotiateReturn
+deinterlace_negotiate_src (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstDeInterlace* filter = GST_DEINTERLACE (gst_pad_get_parent (pad));
+  
+  if (*caps==NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad,filter->sinkpad,caps);
+}
+
+static GstPadNegotiateReturn
+deinterlace_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstDeInterlace* filter = GST_DEINTERLACE (gst_pad_get_parent (pad));
+  
+  if (*caps==NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad,filter->srcpad,caps);
+}		
+
+static GType
+gst_deinterlace_get_type(void) {
+  static GType deinterlace_type = 0;
+
+  if (!deinterlace_type) {
+    static const GTypeInfo deinterlace_info = {
+      sizeof(GstDeInterlaceClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_deinterlace_class_init,
+      NULL,
+      NULL,
+      sizeof(GstDeInterlace),
+      0,
+      (GInstanceInitFunc)gst_deinterlace_init,
+    };
+    deinterlace_type = g_type_register_static(GST_TYPE_ELEMENT, "GstDeInterlace", &deinterlace_info, 0);
+  }
+  return deinterlace_type;
+}
+
+static void
+gst_deinterlace_class_init (GstDeInterlaceClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DI_ONLY,
+    g_param_spec_boolean("di_area_only","di_area_only","di_area_only",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BLEND,
+    g_param_spec_boolean("blend","blend","blend",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_THRESHOLD,
+    g_param_spec_int("threshold","threshold","threshold",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_EDGE_DETECT,
+    g_param_spec_int("edge_detect","edge_detect","edge_detect",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+
+  gobject_class->set_property = gst_deinterlace_set_property;
+  gobject_class->get_property = gst_deinterlace_get_property;
+}
+
+static void
+gst_deinterlace_newcaps (GstPad *pad, GstCaps *caps)
+{
+  GstDeInterlace *filter;
+
+  filter = GST_DEINTERLACE(gst_pad_get_parent (pad));
+
+  filter->width = gst_caps_get_int (caps, "width");
+  filter->height = gst_caps_get_int (caps, "height");
+
+  if (filter->picsize != (filter->width*filter->height)) {
+    if (filter->src) 
+      g_free(filter->src);
+    filter->picsize = filter->width*filter->height;
+    filter->src = g_malloc(filter->picsize);
+  }
+}
+
+static void
+gst_deinterlace_init (GstDeInterlace *filter)
+{
+  filter->sinkpad = gst_pad_new_from_template(deinterlace_sink_factory (),"sink");
+  gst_pad_set_negotiate_function(filter->sinkpad,deinterlace_negotiate_sink);
+  gst_pad_set_chain_function(filter->sinkpad,gst_deinterlace_chain);
+  gst_pad_set_newcaps_function(filter->sinkpad,gst_deinterlace_newcaps);
+  gst_element_add_pad(GST_ELEMENT(filter),filter->sinkpad);
+
+  filter->srcpad = gst_pad_new_from_template(deinterlace_src_factory (),"src");
+  gst_pad_set_negotiate_function(filter->srcpad,deinterlace_negotiate_src);
+  gst_element_add_pad(GST_ELEMENT(filter),filter->srcpad);
+
+  filter->show_deinterlaced_area_only = FALSE;
+  filter->blend = FALSE;
+  //filter->threshold_blend = 0; 
+  filter->threshold = 50;
+  filter->edge_detect = 25;
+
+  filter->src = NULL;
+  filter->picsize = 0;
+}
+
+static void
+gst_deinterlace_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstDeInterlace *filter;
+  gint y0, y1, y2, y3;
+  guchar *psrc1, *psrc2, *psrc3, *pdst1, *yuvptr, *src;
+  gint iInterlaceValue0, iInterlaceValue1, iInterlaceValue2;
+  gint x, y;
+  gint y_line;
+  guchar *y_dst, *y_src;
+  gboolean bBlend;
+  gint iThreshold;
+  gint iEdgeDetect;
+  gint width, height;
+  gboolean bShowDeinterlacedAreaOnly;
+
+  g_return_if_fail (pad != NULL);
+  g_return_if_fail (GST_IS_PAD (pad));
+  g_return_if_fail (buf != NULL);
+
+  filter = GST_DEINTERLACE (gst_pad_get_parent (pad));
+
+  bBlend = filter->blend;
+  iThreshold = filter->threshold;
+  iEdgeDetect = filter->edge_detect;
+  width = filter->width;
+  height = filter->height;
+  src = filter->src;
+  yuvptr = GST_BUFFER_DATA (buf);
+  bShowDeinterlacedAreaOnly = filter->show_deinterlaced_area_only;
+
+  memcpy(filter->src, yuvptr, filter->picsize); 
+
+  y_dst = yuvptr;  // dst y pointer
+                   // we should not change u,v because one u, v value stands for
+                   // 2 pixels per 2 lines = 4 pixel and we don't want to change
+                   // the color of
+
+  y_line  = width;
+  y_src = src;
+
+  iThreshold = iThreshold * iThreshold * 4;
+  // We don't want an integer overflow in the  interlace calculation.
+  if (iEdgeDetect > 180)
+    iEdgeDetect = 180;
+  iEdgeDetect = iEdgeDetect * iEdgeDetect;
+
+  y1 = 0;		// Avoid compiler warning. The value is not used.
+  for (x = 0; x < width; x++) {
+    psrc3 = y_src + x;
+    y3    = *psrc3;
+    psrc2 = psrc3 + y_line;
+    y2 = *psrc2;
+    pdst1 = y_dst + x;
+    iInterlaceValue1 = iInterlaceValue2 = 0;
+    for (y = 0; y <= height; y++) {
+      psrc1 = psrc2;
+      psrc2 = psrc3;
+      psrc3 = psrc3 + y_line;
+      y0 = y1;
+      y1 = y2;
+      y2 = y3;
+      if (y < height - 1) {
+        y3 = *psrc3;
+      } else {
+        y3 = y1;
+      }
+
+      iInterlaceValue0 = iInterlaceValue1;
+      iInterlaceValue1 = iInterlaceValue2;
+
+      if (y < height)
+        iInterlaceValue2 = ((y1 - y2) * (y3 - y2) - 
+                                  ((iEdgeDetect * (y1 - y3) * (y1 - y3)) >> 12))*10;
+      else
+        iInterlaceValue2 = 0;
+
+      if (y > 0) {			
+        if (iInterlaceValue0 + 2 * iInterlaceValue1 + iInterlaceValue2 > iThreshold) {
+          if (bBlend) { 
+            *pdst1 = (unsigned char)((y0 + 2*y1 + y2) >> 2);
+          } else {
+            // this method seems to work better than blending if the
+            // quality is pretty bad and the half pics don't fit together
+            if ((y % 2)==1) {  // if odd simply copy the value
+              *pdst1 = *psrc1;
+              //*pdst1 = 0; // FIXME this is for adjusting an initial iThreshold
+            } else {        // even interpolate the even line (upper + lower)/2
+              *pdst1 = (unsigned char)((y0 + y2) >> 1);
+              //*pdst1 = 0; // FIXME this is for adjusting an initial iThreshold
+            }
+          } 
+        } else {
+          // so we went below the treshold and therefore we don't have to 
+          // change anything
+          if (bShowDeinterlacedAreaOnly) {
+                // this is for testing to see how we should tune the treshhold
+                // and shows as the things that haven't change because the 
+                // threshhold was to low?? (or shows that everything is ok :-)
+            *pdst1 = 0; // blank the point and so the interlac area
+          } else {
+            *pdst1 = *psrc1;
+          }
+        }
+        pdst1 = pdst1 + y_line;
+      }
+    }
+  }
+
+  gst_pad_push (filter->srcpad, buf);
+}
+
+static void
+gst_deinterlace_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstDeInterlace *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_DEINTERLACE(object));
+
+  filter = GST_DEINTERLACE(object);
+
+  switch (prop_id) 
+  {
+    case ARG_DI_ONLY:
+      filter->show_deinterlaced_area_only = g_value_get_boolean (value);
+      break;
+    case ARG_BLEND:
+      filter->blend = g_value_get_boolean (value);
+      break;
+    case ARG_THRESHOLD:
+      filter->threshold = g_value_get_int (value);
+      break;
+    case ARG_EDGE_DETECT:
+      filter->edge_detect = g_value_get_int (value);
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+gst_deinterlace_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstDeInterlace *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_DEINTERLACE(object));
+
+  filter = GST_DEINTERLACE(object);
+
+  switch (prop_id) {
+    case ARG_DI_ONLY:
+      g_value_set_boolean (value, filter->show_deinterlaced_area_only);
+      break;
+    case ARG_BLEND:
+      g_value_set_boolean (value, filter->blend);
+      break;
+    case ARG_THRESHOLD:
+      g_value_set_int (value, filter->threshold);
+      break;
+    case ARG_EDGE_DETECT:
+      g_value_set_int (value, filter->edge_detect);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  factory = gst_elementfactory_new("deinterlace",GST_TYPE_DEINTERLACE,
+                                   &deinterlace_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+  
+  gst_elementfactory_add_padtemplate (factory, 
+		  GST_PADTEMPLATE_GET (deinterlace_src_factory));
+  gst_elementfactory_add_padtemplate (factory, 
+		  GST_PADTEMPLATE_GET (deinterlace_sink_factory));
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "deinterlace",
+  plugin_init
+};
diff --git a/gst/deinterlace/gstdeinterlace.h b/gst/deinterlace/gstdeinterlace.h
new file mode 100644
index 00000000..c46c3af6
--- /dev/null
+++ b/gst/deinterlace/gstdeinterlace.h
@@ -0,0 +1,76 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_DEINTERLACE_H__
+#define __GST_DEINTERLACE_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+// #include <gst/meta/audioraw.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_DEINTERLACE \
+  (gst_deinterlace_get_type())
+#define GST_DEINTERLACE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DEINTERLACE,GstDeInterlace))
+#define GST_DEINTERLACE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstDeInterlace))
+#define GST_IS_DEINTERLACE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DEINTERLACE))
+#define GST_IS_DEINTERLACE_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DEINTERLACE))
+
+typedef struct _GstDeInterlace GstDeInterlace;
+typedef struct _GstDeInterlaceClass GstDeInterlaceClass;
+
+struct _GstDeInterlace {
+  GstElement element;
+
+  GstPad *sinkpad, *srcpad;
+
+  gint width, height;
+
+  gboolean show_deinterlaced_area_only;
+  gboolean blend;
+  gint threshold_blend; // here we start blending
+  gint threshold;         // here we start interpolating TODO FIXME
+  gint edge_detect;
+
+  gint picsize;
+  guchar *src;
+
+};
+
+struct _GstDeInterlaceClass {
+  GstElementClass parent_class;
+};
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_STEREO_H__ */
diff --git a/gst/flx/Makefile.am b/gst/flx/Makefile.am
new file mode 100644
index 00000000..79a6fba7
--- /dev/null
+++ b/gst/flx/Makefile.am
@@ -0,0 +1,9 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstflxdec.la
+
+libgstflxdec_la_SOURCES = gstflxdec.c flx_color.c
+libgstflxdec_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = flx_fmt.h flx_color.h gstflxdec.h
+
diff --git a/gst/flx/flx_color.c b/gst/flx/flx_color.c
new file mode 100644
index 00000000..c61052d0
--- /dev/null
+++ b/gst/flx/flx_color.c
@@ -0,0 +1,94 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <gst/gst.h>
+
+
+#include "flx_color.h"
+
+FlxColorSpaceConverter *
+flx_colorspace_converter_new(gint width, gint height)
+{
+  FlxColorSpaceConverter *new = g_malloc(sizeof(FlxColorSpaceConverter));
+
+  new->width = width;
+  new->height = height;
+
+  memset(new->palvec, 0, sizeof(new->palvec));  
+  return new;
+}
+
+void
+flx_colorspace_converter_destroy(FlxColorSpaceConverter *flxpal)
+{
+  g_return_if_fail(flxpal != NULL);
+
+  g_free(flxpal);
+}
+
+void
+flx_colorspace_convert(FlxColorSpaceConverter *flxpal, guchar *src, guchar *dest)
+{
+  guint size, col;
+
+  g_return_if_fail(flxpal != NULL);
+  g_return_if_fail(src != dest);
+
+
+  size = flxpal->width * flxpal->height;
+
+  while(size--) {
+    col     = (*src++ * 3);
+    *dest++ = flxpal->palvec[col+2];
+    *dest++ = flxpal->palvec[col+1];
+    *dest++ = flxpal->palvec[col];
+    *dest++ = 0;
+  }
+
+}
+
+
+void 
+flx_set_palette_vector(FlxColorSpaceConverter *flxpal, guint start, guint num, guchar *newpal)
+{
+  guint  grab;
+  
+  g_return_if_fail(flxpal != NULL);
+  g_return_if_fail(start < 0x100);
+
+  grab = ((start + num) > 0x100 ? 0x100 - start : num);
+
+  memcpy(&flxpal->palvec[start * 3], newpal, grab*3);
+
+}
+
+void
+flx_set_color(FlxColorSpaceConverter *flxpal, guint colr, guint red, guint green, guint blue)
+{
+  
+  g_return_if_fail(flxpal != NULL);
+  g_return_if_fail(colr < 0x100);
+
+  flxpal->palvec[(colr * 3)]     = red;
+  flxpal->palvec[(colr * 3) + 1] = green;
+  flxpal->palvec[(colr * 3) + 2] = blue;
+}
+
+
diff --git a/gst/flx/flx_color.h b/gst/flx/flx_color.h
new file mode 100644
index 00000000..5676c878
--- /dev/null
+++ b/gst/flx/flx_color.h
@@ -0,0 +1,43 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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.
+ */
+
+typedef enum {
+  FLX_COLORSPACE_RGB8,
+  FLX_COLORSPACE_RGB32,
+} FlxColorSpaceType;
+
+
+typedef struct _FlxColorSpaceConverter FlxColorSpaceConverter;
+
+struct _FlxColorSpaceConverter {
+  guint      width;
+  guint      height;
+  guchar      palvec[768];
+};
+
+
+void flx_colorspace_converter_destroy(FlxColorSpaceConverter *flxpal);
+void flx_colorspace_convert(FlxColorSpaceConverter *flxpal, guchar *src, guchar *dest);
+FlxColorSpaceConverter * flx_colorspace_converter_new(gint width, gint height);
+
+void flx_set_palette_vector(FlxColorSpaceConverter *flxpal, guint start, guint num, 
+          guchar *newpal);
+void flx_set_color(FlxColorSpaceConverter *flxpal, guint colr, guint red, guint green,
+          guint blue);
+
diff --git a/gst/flx/flx_fmt.h b/gst/flx/flx_fmt.h
new file mode 100644
index 00000000..5323de63
--- /dev/null
+++ b/gst/flx/flx_fmt.h
@@ -0,0 +1,136 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_FLX_FMT__H__
+#define __GST_FLX_FMT_H__
+
+#include <gst/gst.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+enum Flx_TypeChunk
+{
+	/* frame chunks */
+	FLX_PREFIX_TYPE	= 0xf100,
+	FLX_SCRIPT_CHUNK	= 0xf1e0,
+	FLX_FRAME_TYPE		= 0xf1fa,
+	FLX_SEGMENT_TABLE	= 0xf1fb,
+	FLX_HUFFMAN_TABLE	= 0xf1fc,
+
+	/* sub chunks */
+	FLX_CEL_DATA		= 3,
+	FLX_COLOR256		= 4,
+	FLX_SS2			= 7,
+        FLX_COLOR64		= 11,
+        FLX_LC			= 12,
+        FLX_BLACK		= 13,
+        FLX_BRUN		= 15,
+        FLX_COPY		= 16,
+        FLX_MINI		= 18,
+	FLX_DTA_RUN		= 25,
+	FLX_DTA_COPY		= 26,
+	FLX_DTA_LC		= 27,
+	FLX_LABEL		= 31,
+	FLX_BMP_MASK		= 32,
+	FLX_MLEV_MASK		= 33,
+	FLX_SEGMENT		= 34,
+	FLX_KEY_IMAGE		= 35,
+	FLX_KEY_PAL		= 36,
+	FLX_REGION		= 37,
+	FLX_WAVE		= 38,
+	FLX_USERSTRING		= 39,
+	FLX_RGN_MASK		= 40,
+
+};
+
+enum Flx_MagicHdr
+{
+	FLX_MAGICHDR_FLI	= 0xaf11,
+	FLX_MAGICHDR_FLC	= 0xaf12,
+	FLX_MAGICHDR_FLX	= 0xaf44,
+	FLX_MAGICHDR_HUFFBWT	= 0xaf30,
+};
+
+
+
+typedef struct _FlxHeader 
+{
+	guint32	size;
+	guint16 type;
+	guint16	frames;
+	guint16 width,height,depth,flags;
+	guint32 speed;
+	guint16 reserved1;
+	/* FLC */ 
+	guint32 created,creator,updated,updater;
+	guint16 aspect_dx, aspect_dy;
+	/* EGI */
+	guint16 ext_flags,keyframes,totalframes;
+	guint32 req_memory;
+	guint16 max_regions,transp_num;
+	guchar	reserved2[24];
+	/* FLC */
+	guint32 oframe1,oframe2;
+	guchar	reserved3[40];
+} FlxHeader;
+#define FlxHeaderSize 128
+
+typedef struct _FlxFrameChunk
+{
+	guint32	size;
+	guint16	id;
+} FlxFrameChunk;
+#define FlxFrameChunkSize 6
+
+typedef struct _FlxPrefixChunk
+{
+	guint16 chunks;
+	guchar  reserved[8];
+} FlxPrefixChunk;
+
+typedef struct _FlxSegmentTable
+{
+	guint16 segments;
+} FlxSegmentTable;
+
+typedef struct _FlxHuffmanTable
+{
+	guint16 codelength;
+	guint16 numcodes;
+	guchar	reserved[6];
+} FlxHuffmanTable;
+
+typedef struct _FlxFrameType
+{
+	guint16 chunks;
+	guint16 delay;
+	guchar	reserved[6];
+} FlxFrameType;
+#define FlxFrameTypeSize 10
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FLX_FMT_H__ */
diff --git a/gst/flx/gstflxdec.c b/gst/flx/gstflxdec.c
new file mode 100644
index 00000000..d6052bb6
--- /dev/null
+++ b/gst/flx/gstflxdec.c
@@ -0,0 +1,644 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+
+#include "flx_fmt.h"
+#include "gstflxdec.h"
+
+static GstCaps* flxdec_typefind(GstBuffer *buf, gpointer private);
+
+/* flx element information */
+static GstElementDetails flxdec_details = {
+  "FLX Decoder",
+  "flxdec",
+  "FLX decoder",
+  VERSION,
+  "Sepp Wijnands <mrrazz@garbage-coderz.net>"
+  "(C) 2001",
+};
+
+static GstTypeDefinition flxdec_definition = {
+  "flxdec_video/fli",
+  "video/fli",
+  ".flc .fli",
+  flxdec_typefind,
+};
+
+/* Flx signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0
+};
+
+/* input */
+GST_PADTEMPLATE_FACTORY (sink_factory,
+  "sink",          
+  GST_PAD_SINK, 
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "flxdec_sink",         
+    "video/fli",
+     NULL
+  )
+)
+
+/* output */
+GST_PADTEMPLATE_FACTORY (src_video_factory,
+  "src",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "src_video",
+    "video/raw",
+      "format",       GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R', 'G', 'B', ' ')),
+        "bpp",        GST_PROPS_INT (32),
+        "depth",      GST_PROPS_INT (32),
+        "endianness", GST_PROPS_INT (G_LITTLE_ENDIAN),
+        "red_mask",   GST_PROPS_INT (0x00ff0000),
+        "green_mask", GST_PROPS_INT (0x0000ff00),
+        "blue_mask",  GST_PROPS_INT (0x000000ff),
+        "width",      GST_PROPS_INT_RANGE(320, 1280), 
+        "height",     GST_PROPS_INT_RANGE(200, 1024)
+  )
+)
+
+
+static void	gst_flxdec_class_init	(GstFlxDecClass *klass);
+static void	gst_flxdec_init		(GstFlxDec *flxdec);
+
+static void	gst_flxdec_loop		(GstElement *element);
+
+static void	gst_flxdec_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void	gst_flxdec_get_property	(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+
+static void flx_decode_color(GstFlxDec *, guchar *, guchar *);
+static void flx_decode_brun(GstFlxDec *, guchar *, guchar *);
+static void flx_decode_delta_fli(GstFlxDec *, guchar *, guchar *);
+static void flx_decode_delta_flc(GstFlxDec *, guchar *, guchar *);
+
+#define rndalign(off) ((off) + ((off) % 2))
+
+static GstElementClass *parent_class = NULL;
+
+static GstCaps* 
+flxdec_typefind (GstBuffer *buf, gpointer private)
+{
+  guchar *data = GST_BUFFER_DATA(buf);
+  GstCaps *new;
+
+  // 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) {
+        g_print("GstFlxDec: found supported flx format\n");
+        new = gst_caps_new("flxdec_typefind","video/fli", NULL);
+        return new;
+      }
+  }
+  
+  return NULL; 
+}
+
+
+GType
+gst_flxdec_get_type(void) 
+{
+  static GType flxdec_type = 0;
+
+  if (!flxdec_type) {
+    static const GTypeInfo flxdec_info = {
+      sizeof(GstFlxDecClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_flxdec_class_init,
+      NULL,
+      NULL,
+      sizeof(GstFlxDec),
+      0,
+      (GInstanceInitFunc)gst_flxdec_init,
+    };
+    flxdec_type = g_type_register_static(GST_TYPE_ELEMENT, "GstFlxDec", &flxdec_info, 0);
+  }
+  return flxdec_type;
+}
+
+static void 
+gst_flxdec_class_init (GstFlxDecClass *klass) 
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  gobject_class->set_property = NULL;  
+  gobject_class->get_property = NULL;
+
+}
+
+
+  
+static void 
+gst_flxdec_init(GstFlxDec *flxdec) 
+{
+  flxdec->sinkpad = gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (sink_factory), "sink");
+  gst_element_add_pad(GST_ELEMENT(flxdec),flxdec->sinkpad);
+  gst_element_set_loop_function(GST_ELEMENT(flxdec),gst_flxdec_loop);
+
+  flxdec->srcpad = gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (src_video_factory), "src");
+  gst_element_add_pad(GST_ELEMENT(flxdec),flxdec->srcpad);
+
+  flxdec->buf = NULL;
+  flxdec->offset = 0;
+  flxdec->new_buf = TRUE;
+
+}
+
+static void
+flx_decode_chunks (GstFlxDec *flxdec , gulong count, gchar *data, gchar *dest)
+{
+  FlxFrameChunk  *hdr;
+
+  g_return_if_fail(data != NULL);
+
+  while (count--) {
+    hdr  = (FlxFrameChunk *) data;
+    data += FlxFrameChunkSize;
+
+    switch(hdr->id) 
+    {
+      case FLX_COLOR64:
+      case FLX_COLOR256:
+        flx_decode_color(flxdec, data, dest);
+        data += rndalign(hdr->size) - FlxFrameChunkSize;
+        break;
+
+      case FLX_BRUN:
+        flx_decode_brun(flxdec, data, dest);
+        data += rndalign(hdr->size) - FlxFrameChunkSize;
+        break;
+
+      case FLX_LC:
+        flx_decode_delta_fli(flxdec, data, dest);
+        data += rndalign(hdr->size) - FlxFrameChunkSize;
+        break;
+
+      case FLX_SS2:
+        flx_decode_delta_flc(flxdec, data, dest);
+        data += rndalign(hdr->size) - FlxFrameChunkSize;
+        break;
+
+      case FLX_BLACK:
+        memset(dest, 0, flxdec->size);
+        break;
+
+      case FLX_MINI:
+        data += rndalign(hdr->size) - FlxFrameChunkSize;
+        break;
+
+      default:
+        g_print("GstFlxDec: Unimplented chunk type: 0x%02x size: %d\n",
+                 hdr->id, hdr->size);
+        g_print("GstFlxDec: Skipping...\n");
+        data += rndalign(hdr->size) - FlxFrameChunkSize;
+        break;
+    }
+  }
+}
+
+
+static void
+flx_decode_color(GstFlxDec *flxdec, guchar *data, guchar *dest)
+{
+  guint packs, count, indx;
+
+  g_return_if_fail(flxdec != NULL);
+
+  packs = (data[0] + (data[1] << 8));
+
+  data += 2;
+  indx  = 0;
+
+  g_print("GstFlxDec: cmap packs: %d\n", packs);
+  while (packs--) {
+    /* color map index + skip count */
+    indx += *data++;
+
+    /* number of rgb triplets */
+    count = *data++ & 0xff;
+    if (count == 0)
+      count = 256;
+
+    g_print("GstFlxDec: cmap count: %d (indx: %d)\n", count, indx);
+    flx_set_palette_vector(flxdec->converter, indx, count, data);
+
+    data += (count * 3);
+  }
+}
+
+static void 
+flx_decode_brun(GstFlxDec *flxdec, guchar *data, guchar *dest)
+{
+  gulong  count, lines, row;
+  guchar  x;
+  
+  g_return_if_fail(flxdec != NULL);
+
+  lines = flxdec->hdr.height;
+  while(lines--) {
+    /* packet count.  
+     * should not be used anymore, since the flc format can
+     * contain more then 255 RLE packets. we use the frame 
+     * width instead. 
+     */
+    data++;
+
+    row = flxdec->hdr.width;
+    while(row) {
+      count = *data++;
+
+      if (count > 0x7f) { 
+        /* literal run */
+        count = 0x100 - count;
+        row -= count;
+
+        while(count--) 
+          *dest++ = *data++;
+        
+      } else {
+        /* replicate run */
+        row -= count;
+        x = *data++;
+
+        while(count--) 
+          *dest++ = x;
+      }
+    }
+  }
+}
+
+static void 
+flx_decode_delta_fli(GstFlxDec *flxdec, guchar *data, guchar *dest)
+{
+  gulong  count, packets, lines, start_line, start_l;
+  guchar  *start_p,  x;
+  
+  g_return_if_fail(flxdec != NULL);
+  g_return_if_fail(flxdec->delta != NULL);
+
+
+  /* use last frame for delta */
+  memcpy(dest, GST_BUFFER_DATA(flxdec->delta), 
+         GST_BUFFER_SIZE(flxdec->delta));
+
+  start_line = (data[0] + (data[1] << 8));
+  lines      = (data[2] + (data[3] << 8));
+  data    += 4;
+
+  /* start position of delta */
+  dest += (flxdec->hdr.width * start_line);
+  start_p = dest;
+  start_l = lines;
+
+  while(lines--) {
+    /* packet count */
+    packets = *data++;
+
+    dest = start_p + (flxdec->hdr.width * (start_l - lines));
+
+    while(packets--) {
+      /* skip count */
+      dest += *data++;
+
+      /* RLE count */
+      count = *data++;
+
+      if (count > 0x7f) { 
+        /* literal run */
+        count = 0x100 - count;
+        x = *data++;
+
+        while (count--)
+          *dest++ = x;
+
+      } else {
+        /* replicate run */
+        while (count--) 
+          *dest++ = *data++;
+      }
+    }
+  }                  
+}
+
+static void 
+flx_decode_delta_flc(GstFlxDec *flxdec, guchar *data, guchar *dest)
+{
+  gulong  count, lines, start_l, opcode;
+  guchar  *start_p;
+  
+  g_return_if_fail(flxdec != NULL);
+  g_return_if_fail(flxdec->delta != NULL);
+
+
+  /* use last frame for delta */
+  memcpy(dest, GST_BUFFER_DATA(flxdec->delta), 
+         GST_BUFFER_SIZE(flxdec->delta));
+
+  lines      = (data[0] + (data[1] << 8));
+  data    += 2;
+
+  start_p    = dest;
+  start_l    = lines;
+
+  while(lines--) {
+    dest = start_p + (flxdec->hdr.width * (start_l - lines));
+
+    /* process opcode(s) */
+    while ((opcode = (data[0] + (data[1] << 8))) & 0xc000) {
+      data += 2;
+      if ((opcode & 0xc000) == 0xc000) {
+        /* skip count */
+        start_l += (0x10000 - opcode);  
+        dest    += flxdec->hdr.width * (0x10000 - opcode);
+      } else {
+        /* last pixel */
+        dest    += flxdec->hdr.width;
+        *dest++  = (opcode & 0xff);
+      }        
+    }
+    data += 2;
+
+    /* last opcode is the packet count */
+    while(opcode--) {
+      /* skip count */
+      dest += *data++;
+  
+      /* RLE count */
+      count = *data++;
+      
+      if (count > 0x7f) {
+        /* replicate word run */
+        count = 0x100 - count;
+        while (count--) {
+          *dest++ = data[0];
+          *dest++ = data[1];
+        }
+        data += 2;
+      } else {
+        /* literal word run */
+        while (count--) {
+          *dest++ = *data++;
+          *dest++ = *data++;
+        }
+      }
+    }
+  }
+}
+          
+static GstBuffer*
+flx_get_data(GstFlxDec *flxdec, gulong size)
+{
+  GstBuffer *retbuf;
+
+  g_return_val_if_fail (flxdec != NULL, NULL);
+
+  if (flxdec->new_buf) {
+    retbuf = gst_pad_pullregion(flxdec->sinkpad, 
+        GST_REGION_OFFSET_LEN, 0, size);
+    flxdec->new_buf = FALSE;
+    flxdec->offset = size;
+  } else {
+    retbuf = gst_pad_pullregion(flxdec->sinkpad, GST_REGION_OFFSET_LEN, 
+        flxdec->offset, size);
+    flxdec->offset += size;
+  }
+
+  return retbuf;
+}
+
+
+static void 
+gst_flxdec_loop (GstElement *element) 
+{
+  GstBuffer  *buf;  
+  GstBuffer  *databuf;
+  guchar     *data, *chunk;
+
+  GstFlxDec         *flxdec;  
+  FlxHeader      *flxh;
+  FlxFrameChunk  *flxfh;
+  
+  g_return_if_fail (element != NULL);
+  g_return_if_fail (GST_IS_FLXDEC(element));
+
+  GST_DEBUG (0, "entering loop function\n");
+  
+  flxdec = GST_FLXDEC(element);
+
+  databuf = flx_get_data(flxdec, FlxHeaderSize);
+
+  g_return_if_fail (databuf != NULL);
+
+  data = GST_BUFFER_DATA(databuf);
+
+  memcpy((char *) &flxdec->hdr, data, sizeof(FlxHeader));
+
+  gst_buffer_unref (databuf);
+
+  flxh = &flxdec->hdr;
+
+  // check header
+  if (flxh->type != FLX_MAGICHDR_FLI &&
+      flxh->type != FLX_MAGICHDR_FLC &&
+      flxh->type != FLX_MAGICHDR_FLX) 
+      return;
+  
+  
+  g_print("GstFlxDec:       size      :  %d\n", flxh->size);
+  g_print("GstFlxDec:       frames    :  %d\n", flxh->frames);
+  g_print("GstFlxDec:       width     :  %d\n", flxh->width);
+  g_print("GstFlxDec:       height    :  %d\n", flxh->height);
+  g_print("GstFlxDec:       depth     :  %d\n", flxh->depth);
+  g_print("GstFlxDec:       speed     :  %d\n", flxh->speed);
+
+  gst_pad_set_caps (flxdec->srcpad,
+  		gst_caps_new (
+  	  	  "src_video",
+	  	  "video/raw",
+		  gst_props_new (
+		    "format",       GST_PROPS_FOURCC (GST_MAKE_FOURCC ('R', 'G', 'B', ' ')),
+		      "bpp",        GST_PROPS_INT (32),
+		      "depth",      GST_PROPS_INT (32),
+		      "endianness", GST_PROPS_INT (G_LITTLE_ENDIAN),
+		      "red_mask",   GST_PROPS_INT (0x00ff0000),
+		      "green_mask", GST_PROPS_INT (0x0000ff00),
+		      "blue_mask",  GST_PROPS_INT (0x000000ff),
+  		      "width",      GST_PROPS_INT (flxh->width), 
+  		      "height",     GST_PROPS_INT (flxh->height),
+		    NULL)));
+
+  if (flxh->depth <= 8) 
+    flxdec->converter = flx_colorspace_converter_new(flxh->width, flxh->height);
+
+  if (flxh->type == FLX_MAGICHDR_FLC || 
+      flxh->type == FLX_MAGICHDR_FLX) {
+    g_print("GstFlxDec: (FLC) aspect_dx :  %d\n", 
+      flxh->aspect_dx);
+    g_print("GstFlxDec: (FLC) aspect_dy :  %d\n", 
+      flxh->aspect_dy);
+    g_print("GstFlxDec: (FLC) oframe1   :  0x%08x\n", 
+      flxh->oframe1);
+    g_print("GstFlxDec: (FLC) oframe2   :  0x%08x\n", 
+      flxh->oframe2);
+  }
+
+  
+  flxdec->size = (flxh->width * flxh->height);
+  
+  // create delta and output frame 
+  flxdec->frame = gst_buffer_new();
+  flxdec->delta = gst_buffer_new();
+  GST_BUFFER_DATA(flxdec->frame) = g_malloc(flxdec->size);
+  GST_BUFFER_SIZE(flxdec->frame) = flxdec->size;
+  GST_BUFFER_DATA(flxdec->delta) = g_malloc(flxdec->size);
+  GST_BUFFER_SIZE(flxdec->delta) = flxdec->size;
+
+  do
+  {
+
+    databuf = flx_get_data(flxdec, FlxFrameChunkSize);
+
+    flxfh = (FlxFrameChunk *) GST_BUFFER_DATA(databuf);
+    
+    switch(flxfh->id)
+    {
+      case FLX_FRAME_TYPE:
+        buf = flx_get_data(flxdec, flxfh->size-FlxFrameChunkSize);
+ 
+        chunk = GST_BUFFER_DATA(buf);
+ 
+        if (((FlxFrameType *)chunk)->chunks == 0)
+          break;
+
+        // create 32 bits output frame
+        flxdec->out = gst_buffer_new();
+        GST_BUFFER_DATA(flxdec->out) = g_malloc(flxdec->size * 4);
+        GST_BUFFER_SIZE(flxdec->out) = flxdec->size * 4;
+
+
+        // decode chunks 
+        flx_decode_chunks(flxdec, 
+                         ((FlxFrameType *)chunk)->chunks, 
+                         GST_BUFFER_DATA(buf) + FlxFrameTypeSize,
+                         GST_BUFFER_DATA(flxdec->frame));
+ 
+        // destroy input buffer
+        gst_buffer_unref(buf);
+    
+        // save copy of the current frame for possible delta.
+        memcpy(GST_BUFFER_DATA(flxdec->delta), 
+               GST_BUFFER_DATA(flxdec->frame), 
+               GST_BUFFER_SIZE(flxdec->delta));
+
+        // convert current frame.
+        flx_colorspace_convert(flxdec->converter,
+             GST_BUFFER_DATA(flxdec->frame),
+             GST_BUFFER_DATA(flxdec->out));
+
+        //GST_BUFFER_FLAG_SET(flxdec->out, GST_BUFFER_FLUSH);
+        gst_pad_push(flxdec->srcpad, flxdec->out);
+        
+        break;
+    }
+
+    // destroy header buffer 
+    gst_buffer_unref(databuf);
+
+  }
+  while (!GST_ELEMENT_IS_COTHREAD_STOPPING (element));
+
+}
+
+static void 
+gst_flxdec_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) 
+{
+  GstFlxDec *flxdec;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_FLXDEC(object));
+  flxdec = GST_FLXDEC(object);
+
+  switch (prop_id) {
+    default:
+      break;
+  }
+}
+
+static void 
+gst_flxdec_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) 
+{
+  GstFlxDec *flxdec;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_FLXDEC(object));
+  flxdec = GST_FLXDEC(object);
+
+  switch (prop_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+  GstTypeFactory *type;
+
+  factory = gst_elementfactory_new("flxdec", GST_TYPE_FLXDEC, &flxdec_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (sink_factory));
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (src_video_factory));
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  type = gst_typefactory_new (&flxdec_definition);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "flxdec",
+  plugin_init
+};
diff --git a/gst/flx/gstflxdec.h b/gst/flx/gstflxdec.h
new file mode 100644
index 00000000..cc4c94db
--- /dev/null
+++ b/gst/flx/gstflxdec.h
@@ -0,0 +1,79 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_FLX_DECODER_H__
+#define __GST_FLX_DECODER_H__
+
+#include <gst/gst.h>
+
+#include "flx_color.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* Definition of structure storing data for this element. */
+typedef struct _GstFlxDec  GstFlxDec;
+struct _GstFlxDec {
+  GstElement element;
+
+  GstPad *sinkpad,*srcpad;
+
+  gboolean active, new_meta, new_buf;
+
+  GstBuffer *buf, *out, *delta, *frame;
+  gulong offset, size;
+
+  FlxColorSpaceConverter *converter;
+
+  FlxHeader hdr;
+};
+
+/* Standard definition defining a class for this element. */
+typedef struct _GstFlxDecClass GstFlxDecClass;
+struct _GstFlxDecClass {
+  GstElementClass parent_class;
+};
+
+/* Standard macros for defining types for this element.  */
+#define GST_TYPE_FLXDEC \
+  (gst_flxdec_get_type())
+#define GST_FLXDEC(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FLXDEC,GstFlxDec))
+#define GST_FLXDEC_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FLXDEC,GstFlxDec))
+#define GST_IS_FLXDEC(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FLXDEC))
+#define GST_IS_FLXDEC_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FLXDEC))
+
+#define FLXDEC_BUFSIZE(buf, offset) \
+  ((GST_BUFFER_OFFSET(buf) + GST_BUFFER_SIZE(buf)) - offset)
+
+/* Standard function returning type information. */
+GType gst_flxdec_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_FLX_DECODER_H__ */
diff --git a/gst/mpeg1sys/.gitignore b/gst/mpeg1sys/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/mpeg1sys/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/mpeg1sys/Makefile.am b/gst/mpeg1sys/Makefile.am
new file mode 100644
index 00000000..5e28e2be
--- /dev/null
+++ b/gst/mpeg1sys/Makefile.am
@@ -0,0 +1,13 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstmpeg1systemencode.la
+
+libgstmpeg1systemencode_la_SOURCES = gstmpeg1systemencode.c \
+			 buffer.c \
+			 systems.c  
+
+noinst_HEADERS = gstmpeg1systemencode.h \
+		 main.h \
+		 buffer.h
+
+libsystem_encode_la_CFLAGS = -O2 $(FOMIT_FRAME_POINTER) -funroll-all-loops -finline-functions -ffast-math $(GST_CFLAGS)
diff --git a/gst/mpeg1sys/buffer.c b/gst/mpeg1sys/buffer.c
new file mode 100644
index 00000000..933b76e6
--- /dev/null
+++ b/gst/mpeg1sys/buffer.c
@@ -0,0 +1,482 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+
+/*#define DEBUG_ENABLED */
+#include <gst/gst.h>
+#include <libs/getbits/gstgetbits.h>
+
+#include "buffer.h"
+
+#define SEQUENCE_HEADER         0x000001b3
+#define SEQUENCE_END            0x000001b7
+#define PICTURE_START           0x00000100
+#define GROUP_START             0x000001b8
+#define SYNCWORD_START          0x000001
+
+#define AUDIO_SYNCWORD          0xfff
+
+#define CLOCKS                  90000.0 
+
+#define DEBUG(a, b...) g_print (##b)
+
+/* This must match decoder and encoder tables */
+static double picture_rates [16] = 
+{ 
+	0.0, 
+	24000.0/1001., 
+	24.0, 
+	25.0, 
+	30000.0/1001., 
+	30.0, 
+	50.0, 
+	60000.0/1001., 
+	60.0,
+	
+	1,
+	5,
+	10,
+	12,
+	15,
+	0,
+	0
+};
+
+static double ratio [16] = { 0., 1., 0.6735, 0.7031, 0.7615, 0.8055,
+	0.8437, 0.8935, 0.9157, 0.9815, 1.0255, 1.0695, 1.0950, 1.1575,
+	1.2015, 0.};
+
+static char picture_types [4][3] = 
+    { "I", "P", "B", "D" };
+
+static int bitrate_index[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 frequency[9] =
+{44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000};
+
+static double dfrequency[9] =
+{44.1, 48, 32, 22.05, 24, 16, 11.025, 12, 8};
+
+static unsigned int samples [4] = {192, 384, 1152, 1152};
+
+static char mode [4][15] =
+    { "stereo", "joint stereo", "dual channel", "single channel" };
+static char copyright [2][20] =
+    { "no copyright","copyright protected" };
+static char original [2][10] =
+    { "copy","original" };
+static char emphasis [4][20] =
+    { "none", "50/15 microseconds", "reserved", "CCITT J.17" };
+
+static void mpeg1mux_buffer_update_video_info(Mpeg1MuxBuffer *mb);
+static void mpeg1mux_buffer_update_audio_info(Mpeg1MuxBuffer *mb);
+
+Mpeg1MuxBuffer *mpeg1mux_buffer_new(guchar type, guchar id) {
+  Mpeg1MuxBuffer *new = g_malloc(sizeof(Mpeg1MuxBuffer));
+
+  new->buffer = NULL;
+  new->length = 0;
+  new->base = 0;
+  new->buffer_type = type;
+  new->stream_id = id;
+  new->scan_pos = 0;
+  new->new_frame = TRUE;
+  new->current_start = 0;
+  new->timecode_list = NULL;
+  new->queued_list = NULL;
+  new->next_frame_time = 0;
+
+  return new;
+}
+
+void mpeg1mux_buffer_queue(Mpeg1MuxBuffer *mb, GstBuffer *buf) {
+
+  if (mb->buffer == NULL) {
+    mb->buffer = g_malloc(GST_BUFFER_SIZE(buf));
+    mb->length = GST_BUFFER_SIZE(buf);
+    memcpy(mb->buffer, GST_BUFFER_DATA(buf), GST_BUFFER_SIZE(buf));
+  }
+  else {
+    mb->buffer = g_realloc(mb->buffer, mb->length + GST_BUFFER_SIZE(buf));
+    memcpy(mb->buffer+mb->length, GST_BUFFER_DATA(buf), GST_BUFFER_SIZE(buf));
+    mb->length += GST_BUFFER_SIZE(buf);
+  }
+
+  GST_DEBUG (0,"queuing buffer %lu\n", mb->length);
+  if (mb->buffer_type == BUFFER_TYPE_VIDEO) {
+    mpeg1mux_buffer_update_video_info(mb);
+  }
+  else {
+    mpeg1mux_buffer_update_audio_info(mb);
+  }
+}
+
+gulong mpeg1mux_buffer_update_queued(Mpeg1MuxBuffer *mb, guint64 scr) {
+  GList *queued_list;
+  Mpeg1MuxTimecode *tc;
+  gulong total_queued = 0;
+  
+  GST_DEBUG (0,"queued in buffer on SCR=%llu\n", scr);
+  queued_list = g_list_first(mb->queued_list);
+
+  while (queued_list) {
+    tc = (Mpeg1MuxTimecode *) queued_list->data;
+    if (tc->DTS < scr) {
+      /* this buffer should be sent out  */
+      mb->queued_list = g_list_remove(mb->queued_list, tc);
+      queued_list = g_list_first(mb->queued_list);
+    }
+    else {
+      GST_DEBUG (0,"queued in buffer %ld, %llu\n", tc->original_length, tc->DTS);
+      total_queued += tc->original_length;
+      queued_list = g_list_next(queued_list);
+    }
+  }
+  GST_DEBUG (0,"queued in buffer %lu\n", total_queued);
+
+  return total_queued;
+}
+
+void mpeg1mux_buffer_shrink(Mpeg1MuxBuffer *mb, gulong size) {
+  GList *timecode_list;
+  Mpeg1MuxTimecode *tc;
+  gulong consumed = 0;
+  gulong count;
+
+  GST_DEBUG (0,"shrinking buffer %lu\n", size);
+
+  g_assert(mb->length >= size);
+
+  memcpy(mb->buffer, mb->buffer+size, mb->length-size);
+  mb->buffer = g_realloc(mb->buffer, mb->length-size);
+
+  mb->length -= size;
+  mb->scan_pos -= size;
+  mb->current_start -= size;
+
+  timecode_list = g_list_first(mb->timecode_list);
+  tc = (Mpeg1MuxTimecode *) timecode_list->data;
+  
+  if (tc->length > size) {
+    tc->length -= size;
+    mb->new_frame = FALSE;
+  }
+  else {
+    consumed += tc->length;
+    while (size >= consumed) {
+      GST_DEBUG (0,"removing timecode: %llu %llu %lu %lu\n", tc->DTS, tc->PTS, tc->length, consumed);
+      mb->timecode_list = g_list_remove_link(mb->timecode_list, timecode_list);
+      mb->queued_list = g_list_append(mb->queued_list, tc);
+      timecode_list = g_list_first(mb->timecode_list);
+      tc = (Mpeg1MuxTimecode *) timecode_list->data;
+      consumed += tc->length;
+      GST_DEBUG (0,"next timecode: %llu %llu %lu %lu\n", tc->DTS, tc->PTS, tc->length, consumed);
+    }
+    mb->new_frame = TRUE;
+    GST_DEBUG (0,"leftover frame size from %lu to %lu \n", tc->length, consumed-size);
+    tc->length = consumed - size;
+  }
+
+  if (mb->buffer_type == BUFFER_TYPE_VIDEO) {
+    mb->info.video.DTS = tc->DTS;
+    mb->info.video.PTS = tc->PTS;
+    mb->next_frame_time = tc->DTS;
+  }
+  else {
+    mb->info.audio.PTS = tc->PTS;
+    mb->next_frame_time = tc->PTS;
+  }
+  GST_DEBUG (0,"next frame time timecode: %llu %lu\n", mb->next_frame_time, tc->length);
+
+  /* check buffer consistency */
+  timecode_list = g_list_first(mb->timecode_list);
+  count = 0;
+
+  while (timecode_list) {
+    tc = (Mpeg1MuxTimecode *) timecode_list->data;
+    count += tc->length;
+    
+    timecode_list = g_list_next(timecode_list);
+  }
+
+  if (count != mb->current_start) g_print("********** error %lu != %lu\n", count, mb->current_start);
+
+  mb->base += size;
+}
+
+static void mpeg1mux_buffer_update_video_info(Mpeg1MuxBuffer *mb) {
+  gboolean have_sync = FALSE;
+  guchar *data = mb->buffer;
+  gulong offset = mb->scan_pos;
+  guint sync_zeros = 0;
+  gulong id=0;
+  guint temporal_reference, temp;
+  gst_getbits_t gb;
+  
+
+  GST_DEBUG (0,"mpeg1mux::update_video_info %lu %lu\n", mb->base, mb->scan_pos);
+  if (mb->base == 0 && mb->scan_pos == 0) {
+    if ((SYNCWORD_START<<8)+*(mb->buffer+3) == SEQUENCE_HEADER) {
+
+      gst_getbits_init(&gb, NULL, NULL);
+      gst_getbits_newbuf(&gb, data+4, mb->length);
+      mb->info.video.horizontal_size     = gst_getbits12(&gb);
+      mb->info.video.vertical_size       = gst_getbits12(&gb);
+      mb->info.video.aspect_ratio        = gst_getbits4(&gb);
+      mb->info.video.picture_rate        = gst_getbits4(&gb);
+      mb->info.video.bit_rate            = gst_getbits18(&gb);
+      if (gst_getbits1(&gb) != 1) {
+        g_print("mpeg1mux::update_video_info: marker bit error\n");
+      }
+      mb->info.video.vbv_buffer_size     = gst_getbits10(&gb);
+      mb->info.video.CSPF                = gst_getbits1(&gb);
+
+      mb->info.video.secs_per_frame = 1. / picture_rates[mb->info.video.picture_rate];
+      mb->info.video.decoding_order=0;
+      mb->info.video.group_order=0;
+      GST_DEBUG (0,"mpeg1mux::update_video_info: secs per frame %g\n", mb->info.video.secs_per_frame);
+    }
+    else {
+      g_print("mpeg1mux::update_video_info: Invalid MPEG Video header\n");
+    }
+  }
+  while (offset < mb->length-6) {
+    if (!have_sync) {
+      guchar byte = *(data+offset);
+      /*GST_DEBUG (0,"mpeg1mux::update_video_info: found #%d at %lu\n",byte,offset); */
+      offset++;
+      /* if it's zero, increment the zero count */
+      if (byte == 0) {
+        sync_zeros++;
+        /*GST_DEBUG (0,"mpeg1mux::update_video_info: found zero #%d at %lu\n",sync_zeros,offset-1); */
+      }
+      /* if it's a one and we have two previous zeros, we have sync */
+      else if ((byte == 1) && (sync_zeros >= 2)) {
+        GST_DEBUG (0,"mpeg1mux::update_video_info: synced at %lu\n",offset-1);
+        have_sync = TRUE;
+        sync_zeros = 0;
+      }
+      /* if it's anything else, we've lost it completely */
+      else sync_zeros = 0;
+    /* then snag the chunk ID */
+    } else if (id == 0) {
+      id = *(data+offset);
+      GST_DEBUG (0,"mpeg1mux::update_video_info: got id 0x%02lX\n",id);
+      id = (SYNCWORD_START<<8)+id;
+      switch (id) {
+	case SEQUENCE_HEADER:
+          GST_DEBUG (0,"mpeg1mux::update_video_info: sequence header\n");
+	  break;
+	case GROUP_START:
+          GST_DEBUG (0,"mpeg1mux::update_video_info: group start\n");
+	  mb->info.video.group_order=0;
+	  break;
+	case PICTURE_START:
+	  /* skip the first access unit */
+	  if (mb->info.video.decoding_order != 0) {
+	    Mpeg1MuxTimecode *tc;
+            GST_DEBUG (0,"mpeg1mux::update_video_info: PTS %llu, DTS %llu, length %lu\n", mb->info.video.current_PTS, 
+			    mb->info.video.current_DTS, offset - mb->current_start-3);
+
+	    tc = (Mpeg1MuxTimecode *) g_malloc(sizeof(Mpeg1MuxTimecode));
+	    tc->length = offset - mb->current_start-3;
+	    tc->original_length = tc->length;
+	    tc->frame_type = mb->info.video.current_type;
+	    tc->DTS = mb->info.video.current_DTS;
+	    tc->PTS = mb->info.video.current_PTS;
+
+	    mb->timecode_list = g_list_append(mb->timecode_list, tc);
+
+	    if (mb->info.video.decoding_order == 0) {
+	      mb->next_frame_time = tc->DTS;
+	    }
+
+            mb->current_start = offset-3;
+	  }
+
+          temp= (*(data+offset+1)<<8)+*(data+offset+2);
+	  temporal_reference = (temp & 0xffc0) >> 6;
+	  mb->info.video.current_type = (temp & 0x0038) >> 3;
+          GST_DEBUG (0,"mpeg1mux::update_video_info: picture start temporal_ref:%d type:%s Frame\n", temporal_reference, 
+			  picture_types[mb->info.video.current_type-1]);
+
+	  mb->info.video.current_DTS = mb->info.video.decoding_order * mb->info.video.secs_per_frame * CLOCKS;
+	  mb->info.video.current_PTS = (temporal_reference - mb->info.video.group_order + 1 +
+			  mb->info.video.decoding_order) *mb->info.video.secs_per_frame*CLOCKS;
+
+	  mb->info.video.decoding_order++;
+	  mb->info.video.group_order++;
+
+
+	  offset++;
+	  break;
+	case SEQUENCE_END:
+          GST_DEBUG (0,"mpeg1mux::update_video_info: sequence end\n");
+	  break;
+      }
+      /* prepare for next sync */
+      offset++;
+      have_sync = FALSE;
+      id = 0;
+      sync_zeros = 0;
+    }
+  }
+  mb->scan_pos = offset;
+}
+
+static void mpeg1mux_buffer_update_audio_info(Mpeg1MuxBuffer *mb) {
+  guchar *data = mb->buffer;
+  gulong offset = mb->scan_pos;
+  gulong id=0;
+  guint padding_bit;
+  gst_getbits_t gb;
+  guint startup_delay = 0;
+  int layer_index,lsf,samplerate_index,padding;
+  long bpf;
+  Mpeg1MuxTimecode *tc;
+  
+
+  GST_DEBUG (0,"mpeg1mux::update_audio_info %lu %lu\n", mb->base, mb->scan_pos);
+  if (mb->base == 0 && mb->scan_pos == 0) {
+    id = GULONG_FROM_BE(*((gulong *)(data)));
+
+    printf("MPEG audio id = %08lx\n", id);
+    if ((id & 0xfff00000) == AUDIO_SYNCWORD<<20) {
+
+      /*mpegver = (header >> 19) & 0x3; // don't need this for bpf */
+      layer_index = (id >> 17) & 0x3;
+      mb->info.audio.layer = 4 - layer_index;
+      lsf = (id & (1 << 20)) ? ((id & (1 << 19)) ? 0 : 1) : 1;
+      mb->info.audio.bit_rate = bitrate_index[lsf][mb->info.audio.layer - 1][((id >> 12) & 0xf)];
+      samplerate_index = (id >> 10) & 0x3;
+      padding = (id >> 9) & 0x1;
+
+      if (mb->info.audio.layer == 1) {
+        bpf = mb->info.audio.bit_rate * 12000;
+        bpf /= frequency[samplerate_index];
+        bpf = ((bpf + padding) << 2);
+      } else {
+        bpf = mb->info.audio.bit_rate * 144000;
+        bpf /= frequency[samplerate_index];
+        bpf += padding;
+      }
+      mb->info.audio.framesize = bpf;
+
+      GST_DEBUG (0,"mpeg1mux::update_audio_info: samples per second %d\n", samplerate_index);
+
+      gst_getbits_init(&gb, NULL, NULL);
+      gst_getbits_newbuf(&gb, data, mb->length);
+
+      gst_flushbitsn(&gb, 12);
+      if (gst_getbits1(&gb) != 1) {
+        g_print("mpeg1mux::update_audio_info: marker bit error\n");
+      }
+      gst_flushbitsn(&gb, 2);
+      mb->info.audio.protection         = gst_getbits1(&gb);
+      gst_flushbitsn(&gb, 4);
+      mb->info.audio.frequency          = gst_getbits2(&gb);
+      padding_bit = gst_getbits1(&gb);
+      gst_flushbitsn(&gb, 1);
+      mb->info.audio.mode               = gst_getbits2(&gb);
+      mb->info.audio.mode_extension     = gst_getbits2(&gb);
+      mb->info.audio.copyright          = gst_getbits1(&gb);
+      mb->info.audio.original_copy      = gst_getbits1(&gb);
+      mb->info.audio.emphasis           = gst_getbits2(&gb);
+
+      GST_DEBUG (0,"mpeg1mux::update_audio_info: layer %d\n", mb->info.audio.layer);
+      GST_DEBUG (0,"mpeg1mux::update_audio_info: bit_rate %d\n", mb->info.audio.bit_rate);
+      GST_DEBUG (0,"mpeg1mux::update_audio_info: frequency %d\n", mb->info.audio.frequency);
+
+      mb->info.audio.samples_per_second = (double)dfrequency [mb->info.audio.frequency];
+
+      GST_DEBUG (0,"mpeg1mux::update_audio_info: samples per second %g\n", mb->info.audio.samples_per_second);
+
+      mb->info.audio.decoding_order=0;
+
+      tc = (Mpeg1MuxTimecode *) g_malloc(sizeof(Mpeg1MuxTimecode));
+      tc->length = mb->info.audio.framesize;
+      tc->original_length = tc->length;
+      tc->frame_type = FRAME_TYPE_AUDIO;
+
+      mb->info.audio.current_PTS = mb->info.audio.decoding_order * samples [mb->info.audio.layer] /
+               mb->info.audio.samples_per_second * 90. + startup_delay;
+
+      GST_DEBUG (0,"mpeg1mux::update_audio_info: PTS %llu, length %u\n", mb->info.audio.current_PTS, mb->info.audio.framesize);
+      tc->PTS = mb->info.audio.current_PTS;
+      tc->DTS = mb->info.audio.current_PTS;
+      mb->timecode_list = g_list_append(mb->timecode_list, tc);
+
+      mb->next_frame_time = tc->PTS;
+
+      mb->info.audio.decoding_order++;
+      offset += tc->length;
+    }
+    else {
+      g_print("mpeg1mux::update_audio_info: Invalid MPEG Video header\n");
+    }
+  }
+  while (offset < mb->length-4) {
+    id = GULONG_FROM_BE(*((gulong *)(data+offset)));
+
+    /*mpegver = (header >> 19) & 0x3; // don't need this for bpf */
+    layer_index = (id >> 17) & 0x3;
+    mb->info.audio.layer = 4 - layer_index;
+    lsf = (id & (1 << 20)) ? ((id & (1 << 19)) ? 0 : 1) : 1;
+    mb->info.audio.bit_rate = bitrate_index[lsf][mb->info.audio.layer - 1][((id >> 12) & 0xf)];
+    samplerate_index = (id >> 10) & 0x3;
+    padding = (id >> 9) & 0x1;
+
+    if (mb->info.audio.layer == 1) {
+      bpf = mb->info.audio.bit_rate * 12000;
+      bpf /= frequency[samplerate_index];
+      bpf = ((bpf + padding) << 2);
+    } else {
+      bpf = mb->info.audio.bit_rate * 144000;
+      bpf /= frequency[samplerate_index];
+      bpf += padding;
+    }
+    tc = (Mpeg1MuxTimecode *) g_malloc(sizeof(Mpeg1MuxTimecode));
+    tc->length = bpf;
+    tc->original_length = tc->length;
+    tc->frame_type = FRAME_TYPE_AUDIO;
+
+    mb->current_start = offset + bpf;
+
+    mb->info.audio.samples_per_second = (double)dfrequency [mb->info.audio.frequency];
+
+    mb->info.audio.current_PTS = (mb->info.audio.decoding_order * samples [mb->info.audio.layer]) /
+             mb->info.audio.samples_per_second * 90. ;
+
+    tc->DTS = tc->PTS = mb->info.audio.current_PTS;
+    GST_DEBUG (0,"mpeg1mux::update_audio_info: PTS %llu, %llu length %lu\n", mb->info.audio.current_PTS, tc->PTS, tc->length);
+    mb->timecode_list = g_list_append(mb->timecode_list, tc);
+
+    mb->info.audio.decoding_order++;
+    offset += tc->length;
+  }
+  mb->scan_pos = offset;
+}
diff --git a/gst/mpeg1sys/buffer.h b/gst/mpeg1sys/buffer.h
new file mode 100644
index 00000000..f3eba4f7
--- /dev/null
+++ b/gst/mpeg1sys/buffer.h
@@ -0,0 +1,141 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 __BUFFER_H__
+#define __BUFFER_H__
+
+#include <gst/gst.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define MPEG1MUX_BUFFER_QUEUED(mb) (g_list_length((mb)->timecode_list))
+#define MPEG1MUX_BUFFER_SPACE(mb) ((mb)->length)
+#define MPEG1MUX_BUFFER_DATA(mb) ((mb)->buffer)
+#define MPEG1MUX_BUFFER_TYPE(mb) ((mb)->buffer)
+#define MPEG1MUX_BUFFER_FIRST_TIMECODE(mb) (g_list_first((mb)->timecode_list)->data)
+
+#define BUFFER_TYPE_VIDEO 1
+#define BUFFER_TYPE_AUDIO 2
+
+#define FRAME_TYPE_IFRAME 1
+#define FRAME_TYPE_BFRAME 2
+#define FRAME_TYPE_PFRAME 3
+#define FRAME_TYPE_AUDIO  4
+
+typedef struct _Mpeg1MuxBuffer Mpeg1MuxBuffer;
+typedef struct _Mpeg1MuxTimecode Mpeg1MuxTimecode;
+
+typedef struct video_struc      /* Informationen ueber Video Stream     */
+{
+  unsigned int stream_length  ;
+  unsigned int num_sequence   ;
+  unsigned int num_seq_end    ;
+  unsigned int num_pictures   ;
+  unsigned int num_groups     ;
+  unsigned int num_frames[4]  ;
+  unsigned int avg_frames[4]  ;
+
+  unsigned int horizontal_size;
+  unsigned int vertical_size  ;
+  unsigned int aspect_ratio   ;
+  unsigned int picture_rate   ;
+  unsigned int bit_rate       ;
+  unsigned int comp_bit_rate  ;
+  unsigned int vbv_buffer_size;
+  unsigned int CSPF           ;
+
+  guint64 PTS;
+  guint64 DTS;
+
+  guint64 current_PTS;
+  guint64 current_DTS;
+  guchar current_type;
+
+  double secs_per_frame;
+  gulong group_order, decoding_order;
+} Video_struc;
+
+typedef struct audio_struc      /* Informationen ueber Audio Stream     */
+{
+  unsigned int stream_length  ;
+  unsigned int num_syncword   ;
+  unsigned int num_frames [2] ;
+  unsigned int framesize      ;
+  unsigned int layer          ;
+  unsigned int protection     ;
+  unsigned int bit_rate       ;
+  unsigned int frequency      ;
+  unsigned int mode           ;
+  unsigned int mode_extension ;
+  unsigned int copyright      ;
+  unsigned int original_copy  ;
+  unsigned int emphasis       ;
+
+  guint64 PTS;
+
+  guint64 current_PTS;
+
+  double samples_per_second;
+  gulong decoding_order;
+} Audio_struc;
+
+struct _Mpeg1MuxTimecode {
+  gulong length;
+  gulong original_length;
+  guchar frame_type;
+  guint64 PTS;
+  guint64 DTS;
+};
+
+struct _Mpeg1MuxBuffer {
+  unsigned char *buffer;
+  gulong length;
+  gulong base;
+  gulong scan_pos;
+  gulong last_pos;
+  gulong current_start;
+  guchar buffer_type;
+  guchar stream_id;
+  gboolean new_frame;
+  guint64 next_frame_time;
+
+  union {
+    Video_struc video;
+    Audio_struc audio;
+  } info;
+
+  GList *timecode_list;
+  GList *queued_list;
+};
+
+Mpeg1MuxBuffer *mpeg1mux_buffer_new(guchar type, guchar id);
+
+void mpeg1mux_buffer_queue(Mpeg1MuxBuffer *mb, GstBuffer *buf);
+void mpeg1mux_buffer_shrink(Mpeg1MuxBuffer *mb, gulong size);
+gulong mpeg1mux_buffer_update_queued(Mpeg1MuxBuffer *mb, guint64 scr);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __BUFFER_H__ */
diff --git a/gst/mpeg1sys/gstmpeg1systemencode.c b/gst/mpeg1sys/gstmpeg1systemencode.c
new file mode 100644
index 00000000..d8927d0f
--- /dev/null
+++ b/gst/mpeg1sys/gstmpeg1systemencode.c
@@ -0,0 +1,572 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+/*#define DEBUG_ENABLED */
+#include "gstmpeg1systemencode.h"
+#include "main.h"
+
+/*#define GST_DEBUG(a, b...) g_print (##b) */
+
+/* elementfactory information */
+static GstElementDetails system_encode_details = {
+  "MPEG1 Multiplexer",
+  "Filter/Multiplexer/System",
+  "Multiplexes MPEG-1 Streams",
+  VERSION,
+  "Wim Taymans <wim.taymans@chello.be>",
+  "(C) 2000",
+};
+
+/* GstMPEG1SystemEncode signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  /* FILL ME */
+};
+
+GST_PADTEMPLATE_FACTORY (src_factory,
+  "src",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "src_video",
+    "video/mpeg",
+      "mpegversion",   	GST_PROPS_INT (1),
+      "systemstream",   GST_PROPS_BOOLEAN (TRUE)
+  )
+)
+GST_PADTEMPLATE_FACTORY (video_sink_factory,
+  "video_%02d",
+  GST_PAD_SINK,
+  GST_PAD_REQUEST,
+  GST_CAPS_NEW (
+    "sink_video",
+    "video/mpeg",
+      "mpegversion",   	GST_PROPS_INT (1),
+      "systemstream",   GST_PROPS_BOOLEAN (FALSE)
+  )
+)
+
+GST_PADTEMPLATE_FACTORY (audio_sink_factory,
+  "audio_%02d",
+  GST_PAD_SINK,
+  GST_PAD_REQUEST,
+  GST_CAPS_NEW (
+    "sink_audio",
+    "audio/mp3",
+    NULL
+  )
+)
+
+static void	gst_system_encode_class_init		(GstMPEG1SystemEncodeClass *klass);
+static void	gst_system_encode_init			(GstMPEG1SystemEncode *system_encode);
+
+static GstPad* 	gst_system_encode_request_new_pad 	(GstElement *element, GstPadTemplate *templ,
+                                                         const gchar *unused);
+static void	gst_system_encode_chain			(GstPad *pad, GstBuffer *buf);
+
+static void	gst_system_encode_set_property		(GObject *object, guint prop_id, 
+							 const GValue *value, GParamSpec *pspec);
+static void	gst_system_encode_get_property		(GObject *object, guint prop_id, 
+							 GValue *value, GParamSpec *pspec);
+
+static GstElementClass *parent_class = NULL;
+/*static guint gst_system_encode_signals[LAST_SIGNAL] = { 0 }; */
+
+GType
+gst_mpeg1_system_encode_get_type (void)
+{
+  static GType system_encode_type = 0;
+
+  if (!system_encode_type) {
+    static const GTypeInfo system_encode_info = {
+      sizeof(GstMPEG1SystemEncodeClass),      
+      NULL,
+      NULL,
+      (GClassInitFunc)gst_system_encode_class_init,
+      NULL,
+      NULL,
+      sizeof(GstMPEG1SystemEncode),
+      0,
+      (GInstanceInitFunc)gst_system_encode_init,
+      NULL
+    };
+    system_encode_type = g_type_register_static(GST_TYPE_ELEMENT, "GstMPEG1SystemEncode", &system_encode_info, 0);
+  }
+  return system_encode_type;
+}
+
+static void
+gst_system_encode_class_init (GstMPEG1SystemEncodeClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  gobject_class->set_property = gst_system_encode_set_property;
+  gobject_class->get_property = gst_system_encode_get_property;
+
+  gstelement_class->request_new_pad = gst_system_encode_request_new_pad;
+}
+
+static void
+gst_system_encode_init (GstMPEG1SystemEncode *system_encode)
+{
+  system_encode->srcpad = gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (src_factory), "src");
+  gst_element_add_pad (GST_ELEMENT (system_encode), system_encode->srcpad);
+
+  system_encode->video_buffer = mpeg1mux_buffer_new (BUFFER_TYPE_VIDEO, 0xE0);
+  system_encode->audio_buffer = mpeg1mux_buffer_new (BUFFER_TYPE_AUDIO, 0xC0);
+  system_encode->have_setup = FALSE;
+  system_encode->mta = NULL;
+  system_encode->packet_size = 2048;
+  system_encode->lock = g_mutex_new();
+  system_encode->current_pack = system_encode->packets_per_pack = 3;
+  system_encode->video_delay_ms = 0;
+  system_encode->audio_delay_ms = 0;
+  system_encode->sectors_delay = 0;
+  system_encode->startup_delay = ~1;
+  system_encode->which_streams = 0;
+  system_encode->num_audio_pads = 0;
+  system_encode->num_video_pads = 0;
+  system_encode->pack = g_malloc (sizeof (Pack_struc));
+  system_encode->sys_header = g_malloc (sizeof (Sys_header_struc));
+  system_encode->sector = g_malloc (sizeof (Sector_struc));
+
+}
+
+static GstPad*
+gst_system_encode_request_new_pad (GstElement *element, GstPadTemplate *templ, const gchar *unused)
+{
+  GstMPEG1SystemEncode *system_encode;
+  gchar *name = NULL;
+  GstPad *newpad;
+
+  g_return_val_if_fail (templ != NULL, NULL);
+
+  if (templ->direction != GST_PAD_SINK) {
+    g_warning ("system_encode: request pad that is not a SINK pad\n");
+    return NULL;
+  }
+  system_encode = GST_SYSTEM_ENCODE (element);
+
+  if (templ == GST_PADTEMPLATE_GET (audio_sink_factory)) {
+    name = g_strdup_printf ("audio_%02d", system_encode->num_audio_pads);
+    g_print ("%s\n", name);
+    newpad = gst_pad_new_from_template (templ, name);
+    gst_pad_set_element_private (newpad, GINT_TO_POINTER (system_encode->num_audio_pads));
+
+    system_encode->audio_pad[system_encode->num_audio_pads] = newpad;
+    system_encode->num_audio_pads++;
+    system_encode->which_streams |= STREAMS_AUDIO;
+  }
+  else if (templ == GST_PADTEMPLATE_GET (video_sink_factory)) {
+    name = g_strdup_printf ("video_%02d", system_encode->num_video_pads);
+    g_print ("%s\n", name);
+    newpad = gst_pad_new_from_template (templ, name);
+    gst_pad_set_element_private (newpad, GINT_TO_POINTER (system_encode->num_video_pads));
+
+    system_encode->video_pad[system_encode->num_video_pads] = newpad;
+    system_encode->num_video_pads++;
+    system_encode->which_streams |= STREAMS_VIDEO;
+  }
+  else {
+    g_warning ("system_encode: this is not our template!\n");
+    return NULL;
+  }
+
+  gst_pad_set_chain_function (newpad, gst_system_encode_chain);
+  gst_element_add_pad (GST_ELEMENT (system_encode), newpad);
+
+  return newpad;
+}
+
+/* return a list of all the highest prioripty streams */
+static GList*
+gst_system_encode_pick_streams (GList *mta, GstMPEG1SystemEncode *system_encode)
+{
+  guint64 lowest = ~1;
+
+  GST_DEBUG (0, "pick_streams: %lld, %lld\n", system_encode->video_buffer->next_frame_time,
+		  			    system_encode->audio_buffer->next_frame_time);
+
+  if (system_encode->which_streams & STREAMS_VIDEO) {
+    if (system_encode->video_buffer->next_frame_time < lowest-system_encode->video_delay) {
+      lowest = system_encode->video_buffer->next_frame_time;
+    }
+  }
+  if (system_encode->which_streams & STREAMS_AUDIO) {
+    if (system_encode->audio_buffer->next_frame_time < lowest-system_encode->audio_delay) {
+      lowest = system_encode->audio_buffer->next_frame_time;
+    }
+  }
+
+  if (system_encode->which_streams & STREAMS_VIDEO) {
+    if (system_encode->video_buffer->next_frame_time == lowest) {
+      mta = g_list_append(mta, system_encode->video_buffer);
+    }
+  }
+  if (system_encode->which_streams & STREAMS_AUDIO) {
+    if (system_encode->audio_buffer->next_frame_time == lowest) {
+      mta = g_list_append(mta, system_encode->audio_buffer);
+    }
+  }
+  return mta;
+}
+
+static gboolean
+gst_system_encode_have_data (GstMPEG1SystemEncode *system_encode)
+{
+
+  if (system_encode->which_streams == (STREAMS_VIDEO | STREAMS_AUDIO)) {
+    if (MPEG1MUX_BUFFER_QUEUED(system_encode->audio_buffer) > 2 &&
+        MPEG1MUX_BUFFER_SPACE(system_encode->audio_buffer) > system_encode->packet_size*2 &&
+        MPEG1MUX_BUFFER_QUEUED(system_encode->video_buffer) > 2 &&
+        MPEG1MUX_BUFFER_SPACE(system_encode->video_buffer) > system_encode->packet_size*2) {
+      return TRUE;
+    }
+  }
+  if (system_encode->which_streams == STREAMS_VIDEO) {
+    if (MPEG1MUX_BUFFER_QUEUED(system_encode->video_buffer) > 2 &&
+        MPEG1MUX_BUFFER_SPACE(system_encode->video_buffer) > system_encode->packet_size*2) {
+      return TRUE;
+    }
+  }
+  if (system_encode->which_streams == STREAMS_VIDEO) {
+    if (MPEG1MUX_BUFFER_QUEUED(system_encode->audio_buffer) > 2 &&
+        MPEG1MUX_BUFFER_SPACE(system_encode->audio_buffer) > system_encode->packet_size*2) {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+static GList*
+gst_system_encode_update_mta (GstMPEG1SystemEncode *system_encode, GList *mta, gulong size)
+{
+  GList *streams = g_list_first(mta);
+  Mpeg1MuxBuffer *mb = (Mpeg1MuxBuffer *)streams->data;
+
+  GST_DEBUG (0,"system_encode::multiplex: update mta\n");
+
+  mpeg1mux_buffer_shrink(mb, size);
+
+  mta = g_list_remove(mta, mb);
+
+  return mta;
+}
+
+static void
+gst_system_setup_multiplex (GstMPEG1SystemEncode *system_encode)
+{
+  Mpeg1MuxTimecode *video_tc, *audio_tc;
+
+  system_encode->audio_buffer_size = 4*1024;
+  system_encode->video_buffer_size = 46*1024;
+  system_encode->bytes_output = 0;
+  system_encode->min_packet_data = system_encode->packet_size - PACK_HEADER_SIZE - SYS_HEADER_SIZE -
+	          PACKET_HEADER_SIZE - AFTER_PACKET_LENGTH;
+  system_encode->max_packet_data = system_encode->packet_size - PACKET_HEADER_SIZE - AFTER_PACKET_LENGTH;
+
+  if (system_encode->which_streams & STREAMS_VIDEO) {
+    system_encode->video_rate = system_encode->video_buffer->info.video.bit_rate * 50;
+  }
+  else system_encode->video_rate = 0;
+  if (system_encode->which_streams & STREAMS_AUDIO)
+    system_encode->audio_rate = system_encode->audio_buffer->info.audio.bit_rate * 128;
+  else system_encode->audio_rate = 0;
+
+  system_encode->data_rate = system_encode->video_rate + system_encode->audio_rate;
+
+  system_encode->dmux_rate =  ceil((double)(system_encode->data_rate) *
+            ((double)(system_encode->packet_size)/(double)(system_encode->min_packet_data) +
+            ((double)(system_encode->packet_size)/(double)(system_encode->max_packet_data) *
+            (double)(system_encode->packets_per_pack-1.))) / (double)(system_encode->packets_per_pack) );
+  system_encode->data_rate = ceil(system_encode->dmux_rate/50.)*50;
+
+  GST_DEBUG (0,"system_encode::multiplex: data_rate %u, video_rate: %u, audio_rate: %u\n", system_encode->data_rate,
+		  system_encode->video_rate, system_encode->audio_rate);
+
+  system_encode->video_delay = (double)system_encode->video_delay_ms*(double)(CLOCKS/1000);
+  system_encode->audio_delay = (double)system_encode->audio_delay_ms*(double)(CLOCKS/1000);
+
+  system_encode->mux_rate = ceil(system_encode->dmux_rate/50.);
+  system_encode->dmux_rate= system_encode->mux_rate * 50.;
+
+  video_tc = MPEG1MUX_BUFFER_FIRST_TIMECODE(system_encode->video_buffer);
+  audio_tc = MPEG1MUX_BUFFER_FIRST_TIMECODE(system_encode->audio_buffer);
+
+  GST_DEBUG (0,"system_encode::video tc %lld, audio tc %lld:\n", video_tc->DTS, audio_tc->DTS);
+
+  system_encode->delay = ((double)system_encode->sectors_delay +
+          ceil((double)video_tc->length/(double)system_encode->min_packet_data)  +
+          ceil((double)video_tc->length/(double)system_encode->min_packet_data )) *
+          (double)system_encode->packet_size/system_encode->dmux_rate*(double)CLOCKS;
+
+  system_encode->audio_delay += system_encode->delay;
+  system_encode->video_delay += system_encode->delay;
+
+  system_encode->audio_delay = 0;
+  system_encode->video_delay = 0;
+  system_encode->delay = 0;
+
+  GST_DEBUG (0,"system_encode::multiplex: delay %g, mux_rate: %lu\n", system_encode->delay, system_encode->mux_rate);
+}
+
+static void
+gst_system_encode_multiplex(GstMPEG1SystemEncode *system_encode)
+{
+  GList *streams;
+  Mpeg1MuxBuffer *mb = (Mpeg1MuxBuffer *)streams->data;
+  guchar timestamps;
+  guchar buffer_scale;
+  GstBuffer *outbuf;
+  Pack_struc          *pack;
+  Sys_header_struc    *sys_header;
+  Mpeg1MuxTimecode *tc;
+  gulong buffer_size, non_scaled_buffer_size, total_queued;
+  guint64 PTS, DTS;
+
+  g_mutex_lock(system_encode->lock);
+
+  while (gst_system_encode_have_data(system_encode)) {
+    GST_DEBUG (0,"system_encode::multiplex: multiplexing\n");
+
+    if (!system_encode->have_setup) {
+      gst_system_setup_multiplex(system_encode);
+      system_encode->have_setup = TRUE;
+    }
+
+    if (system_encode->mta == NULL) {
+      system_encode->mta = gst_system_encode_pick_streams(system_encode->mta, system_encode);
+    }
+    if (system_encode->mta == NULL) break;
+
+
+    system_encode->SCR = (guint64)(system_encode->bytes_output+LAST_SCR_BYTE_IN_PACK)*CLOCKS/system_encode->dmux_rate;
+
+
+    streams = g_list_first(system_encode->mta);
+    mb = (Mpeg1MuxBuffer *)streams->data;
+
+    if (system_encode->current_pack == system_encode->packets_per_pack) {
+      create_pack(system_encode->pack, system_encode->SCR, system_encode->mux_rate);
+      create_sys_header (system_encode->sys_header, system_encode->mux_rate, 1, 1, 1, 1, 1, 1,
+                        AUDIO_STR_0, 0, system_encode->audio_buffer_size/128,
+                        VIDEO_STR_0, 1, system_encode->video_buffer_size/1024, system_encode->which_streams );
+      system_encode->current_pack = 0;
+      pack = system_encode->pack;
+      sys_header = system_encode->sys_header;
+    }
+    else {
+      system_encode->current_pack++;
+      pack = NULL;
+      sys_header = NULL;
+    }
+
+    tc = MPEG1MUX_BUFFER_FIRST_TIMECODE(mb);
+    if (mb->new_frame) {
+      GST_DEBUG (0,"system_encode::multiplex: new frame\n");
+      if (tc->frame_type == FRAME_TYPE_AUDIO || tc->frame_type == FRAME_TYPE_IFRAME || tc->frame_type == FRAME_TYPE_PFRAME) {
+        timestamps = TIMESTAMPS_PTS;
+      }
+      else {
+        timestamps = TIMESTAMPS_PTS_DTS;
+      }
+    }
+    else {
+      timestamps = TIMESTAMPS_NO;
+    }
+
+    if (tc->frame_type != FRAME_TYPE_AUDIO) {
+      if (tc->PTS<system_encode->startup_delay)
+	system_encode->startup_delay = tc->PTS;
+    }
+
+    if (tc->frame_type == FRAME_TYPE_AUDIO) {
+      buffer_scale = 0;
+      non_scaled_buffer_size = system_encode->audio_buffer_size;
+      buffer_size = system_encode->audio_buffer_size/128;
+      PTS = tc->PTS + system_encode->audio_delay + system_encode->startup_delay;
+      DTS = tc->PTS + system_encode->audio_delay + system_encode->startup_delay;
+    }
+    else {
+      buffer_scale = 1;
+      non_scaled_buffer_size = system_encode->video_buffer_size;
+      buffer_size = system_encode->video_buffer_size/1024;
+      PTS = tc->PTS + system_encode->video_delay;
+      DTS = tc->DTS + system_encode->video_delay;
+    }
+
+    total_queued = mpeg1mux_buffer_update_queued(mb, system_encode->SCR);
+
+    if (non_scaled_buffer_size - total_queued >= system_encode->packet_size) {
+
+      /* write the pack/packet here */
+      create_sector (system_encode->sector, pack, sys_header,
+	            system_encode->packet_size,
+		    MPEG1MUX_BUFFER_DATA(mb), mb->stream_id, buffer_scale,
+	            buffer_size, TRUE, PTS, DTS,
+	            timestamps, system_encode->which_streams);
+    /* update mta */
+      system_encode->mta = gst_system_encode_update_mta(system_encode, system_encode->mta, 
+		      		system_encode->sector->length_of_packet_data);
+    }
+    else {
+      /* write  a padding packet */
+      create_sector (system_encode->sector, pack, sys_header,
+	            system_encode->packet_size, NULL, PADDING_STR, 0,
+	            0, FALSE, 0, 0,
+	            TIMESTAMPS_NO, system_encode->which_streams);
+    }
+
+    outbuf = gst_buffer_new();
+    GST_BUFFER_DATA(outbuf) = g_malloc(system_encode->sector->length_of_sector);
+    GST_BUFFER_SIZE(outbuf) = system_encode->sector->length_of_sector;
+    memcpy(GST_BUFFER_DATA(outbuf),system_encode->sector->buf, system_encode->sector->length_of_sector);
+    system_encode->bytes_output += GST_BUFFER_SIZE(outbuf);
+    gst_pad_push(system_encode->srcpad,outbuf);
+
+    GST_DEBUG (0,"system_encode::multiplex: writing %02x\n", mb->stream_id);
+
+  }
+  gst_info("system_encode::multiplex: data left in video buffer %lu\n", MPEG1MUX_BUFFER_SPACE(system_encode->video_buffer));
+  gst_info("system_encode::multiplex: data left in audio buffer %lu\n", MPEG1MUX_BUFFER_SPACE(system_encode->audio_buffer));
+
+  g_mutex_unlock(system_encode->lock);
+}
+
+static void
+gst_system_encode_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstMPEG1SystemEncode *system_encode;
+  guchar *data;
+  gulong size;
+  const gchar *padname;
+  gint channel;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  system_encode = GST_SYSTEM_ENCODE (GST_OBJECT_PARENT (pad));
+  data = GST_BUFFER_DATA(buf);
+  size = GST_BUFFER_SIZE(buf);
+
+  GST_DEBUG (0,"system_encode::chain: system_encode: have buffer of size %lu\n",size);
+  padname = GST_OBJECT_NAME (pad);
+
+  if (strncmp(padname, "audio_", 6) == 0) {
+    channel = atoi(&padname[6]);
+    GST_DEBUG (0,"gst_system_encode_chain: got audio buffer in from audio channel %02d\n", channel);
+
+    mpeg1mux_buffer_queue(system_encode->audio_buffer, buf);
+  }
+  else if (strncmp(padname, "video_", 6) == 0) {
+    channel = atoi(&padname[6]);
+    GST_DEBUG (0,"gst_system_encode_chain: got video buffer in from video channel %02d\n", channel);
+
+    mpeg1mux_buffer_queue(system_encode->video_buffer, buf);
+
+  }
+  else {
+    g_assert_not_reached (); 
+  }
+  gst_system_encode_multiplex(system_encode);
+
+  gst_buffer_unref(buf);
+}
+
+static void
+gst_system_encode_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstMPEG1SystemEncode *system_encode;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SYSTEM_ENCODE(object));
+  system_encode = GST_SYSTEM_ENCODE(object);
+
+  switch (prop_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_system_encode_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstMPEG1SystemEncode *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SYSTEM_ENCODE(object));
+  src = GST_SYSTEM_ENCODE(object);
+
+  switch (prop_id) {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* this filter needs the getbits functions */
+  if (!gst_library_load("gstgetbits")) {
+    gst_info("system_encode:: could not load support library: 'gstgetbits'\n");
+    return FALSE;
+  }
+
+  /* create an elementfactory for the system_encode element */
+  factory = gst_elementfactory_new("system_encode",GST_TYPE_SYSTEM_ENCODE,
+                                   &system_encode_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (src_factory));
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (audio_sink_factory));
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (video_sink_factory));
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "system_encode",
+  plugin_init
+};
diff --git a/gst/mpeg1sys/gstmpeg1systemencode.h b/gst/mpeg1sys/gstmpeg1systemencode.h
new file mode 100644
index 00000000..bb24f01d
--- /dev/null
+++ b/gst/mpeg1sys/gstmpeg1systemencode.h
@@ -0,0 +1,110 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 __SYSTEM_ENCODE_H__
+#define __SYSTEM_ENCODE_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+#include <libs/getbits/gstgetbits.h>
+
+#include "buffer.h"
+#include "main.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SYSTEM_ENCODE \
+  (gst_mpeg1_system_encode_get_type())
+#define GST_SYSTEM_ENCODE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SYSTEM_ENCODE,GstMPEG1SystemEncode))
+#define GST_SYSTEM_ENCODE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SYSTEM_ENCODE,GstMPEG1SystemEncode))
+#define GST_IS_SYSTEM_ENCODE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SYSTEM_ENCODE))
+#define GST_IS_SYSTEM_ENCODE_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SYSTEM_ENCODE))
+
+typedef struct _GstMPEG1SystemEncode GstMPEG1SystemEncode;
+typedef struct _GstMPEG1SystemEncodeClass GstMPEG1SystemEncodeClass;
+
+struct _GstMPEG1SystemEncode {
+  GstElement element;
+
+  GstPad *srcpad;
+
+  gboolean have_setup;
+
+  GMutex *lock;
+
+  guint num_audio_pads;
+  guint num_video_pads;
+
+  Mpeg1MuxBuffer *audio_buffer;
+  Mpeg1MuxBuffer *video_buffer;
+
+  Pack_struc          *pack;
+  Sys_header_struc    *sys_header;
+  Sector_struc        *sector;
+
+  guint data_rate, video_rate, audio_rate;
+  gdouble delay, audio_delay, video_delay;
+  gdouble clock_cycles;
+  gulong sectors_delay, video_delay_ms, audio_delay_ms;
+  gulong startup_delay;
+  gulong audio_buffer_size;
+  gulong video_buffer_size;
+  gulong mux_rate, dmux_rate;
+  guint64 SCR;
+  gint which_streams;
+
+  gint current_pack;
+  gulong min_packet_data;
+  gulong max_packet_data;
+  gint packets_per_pack;
+  gulong packet_size;
+  gulong bytes_output;
+
+  GList *mta;
+
+  /* stream input pads */
+  GstPad *private_1_pad[8];	/* up to 8 ac3 audio tracks <grumble> */
+  GstPad *private_2_pad;
+  GstPad *video_pad[16];
+  GstPad *audio_pad[32];
+};
+
+struct _GstMPEG1SystemEncodeClass {
+  GstElementClass parent_class;
+};
+
+GType gst_mpeg1_system_encode_get_type(void);
+
+/* multplex.c */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __SYSTEM_ENCODE_H__ */
diff --git a/gst/mpeg1sys/main.h b/gst/mpeg1sys/main.h
new file mode 100644
index 00000000..434f57f5
--- /dev/null
+++ b/gst/mpeg1sys/main.h
@@ -0,0 +1,140 @@
+/*************************************************************************
+*  Generating a MPEG/SYSTEMS						 *
+*  MULTIPLEXED VIDEO/AUDIO STREAM					 *
+*  from two MPEG source streams						 *
+*  Christoph Moar							 *
+*  SIEMENS CORPORATE RESEARCH AND DEVELOPMENT ST SN 11 / T SN 6		 *
+*  (C) 1994 1995							 *
+**************************************************************************
+*  Restrictions apply. Will not support the whole MPEG/SYSTEM Standard.  *
+*  Basically, will generate Constrained System Parameter Files.		 *
+*  Mixes only one audio and/or one video stream. Might be expanded.	 *
+*************************************************************************/
+
+/*************************************************************************
+*  mplex - MPEG/SYSTEMS multiplexer					 *
+*  Copyright (C) 1994 1995 Christoph Moar				 *
+*  Siemens ZFE ST SN 11 / T SN 6					 *
+*									 *
+*  moar@informatik.tu-muenchen.de 					 *
+*       (Christoph Moar)			 			 *
+*									 *
+*  This program is free software; you can redistribute it and/or modify	 *
+*  it under the terms of the GNU General Public License as published by	 *
+*  the Free Software Foundation; either version 2 of the License, or	 *
+*  (at your option) any later version.					 *
+*									 *
+*  This program 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 General Public License for more details.				 *
+*									 *
+*  You should have received a copy of the GNU General Public License	 *
+*  along with this program; if not, write to the Free Software		 *
+*  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		 *
+*************************************************************************/
+
+
+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+#include <glib.h>
+
+#define PACK_START		0x000001ba
+#define SYS_HEADER_START	0x000001bb
+#define ISO11172_END		0x000001b9
+#define PACKET_START		0x000001
+
+#define CLOCKS			90000.0		/* System Clock Hertz	*/
+
+#define AFTER_PACKET_LENGTH	15		/* No of non-data-bytes	*/
+						/* following the packet	*/
+						/* length field		*/
+#define LAST_SCR_BYTE_IN_PACK	9		/* No of bytes in pack	*/
+						/* preceding, and 	*/
+						/* including, the SCR	*/
+
+/* The following values for sys_header_length & size are only valid for */
+/* System streams consisting of two basic streams. When wrapping around */
+/* the system layer on a single video or a single audio stream, those   */
+/* values get decreased by 3.                                           */
+
+#define SYS_HEADER_LENGTH	12		/* length of Sys Header	*/
+						/* after start code and	*/
+						/* length field		*/
+
+#define SYS_HEADER_SIZE		18		/* incl. start code and	*/
+						/* length field		*/
+#define PACK_HEADER_SIZE	12
+
+#define PACKET_HEADER_SIZE	6
+
+#define MAX_SECTOR_SIZE		0x20000		/* Max Sektor Groesse	*/
+
+#define STREAMS_VIDEO           1
+#define STREAMS_AUDIO           2
+#define STREAMS_BOTH            3
+
+#define AUDIO_STREAMS		0xb8		/* Marker Audio Streams	*/
+#define VIDEO_STREAMS		0xb9		/* Marker Video Streams	*/
+#define AUDIO_STR_0		0xc0		/* Marker Audio Stream0	*/
+#define VIDEO_STR_0		0xe0		/* Marker Video Stream0	*/
+#define PADDING_STR		0xbe		/* Marker Padding Stream*/
+
+#define ZERO_STUFFING_BYTE	0
+#define STUFFING_BYTE		0xff
+#define RESERVED_BYTE		0xff
+#define TIMESTAMPS_NO		0		/* Flag NO timestamps	*/
+#define TIMESTAMPS_PTS		1		/* Flag PTS timestamp	*/
+#define TIMESTAMPS_PTS_DTS	2		/* Flag BOTH timestamps	*/
+
+#define MARKER_SCR		2		/* Marker SCR		*/
+#define MARKER_JUST_PTS		2		/* Marker only PTS	*/
+#define MARKER_PTS		3		/* Marker PTS		*/
+#define MARKER_DTS		1		/* Marker DTS		*/
+#define MARKER_NO_TIMESTAMPS	0x0f		/* Marker NO timestamps	*/
+
+#define STATUS_AUDIO_END	0		/* Statusmessage A end	*/
+#define STATUS_VIDEO_END	1		/* Statusmessage V end	*/
+#define STATUS_AUDIO_TIME_OUT	2		/* Statusmessage A out	*/
+#define STATUS_VIDEO_TIME_OUT	3		/* Statusmessage V out	*/
+
+/*************************************************************************
+    Typ- und Strukturdefinitionen
+*************************************************************************/
+
+typedef struct sector_struc	/* A sector, can contain pack, sys header	*/
+				/* and packet.		*/
+{   unsigned char  buf [MAX_SECTOR_SIZE] ;
+    unsigned int   length_of_sector  ;
+    unsigned int   length_of_packet_data ;
+    guint64 TS                ;
+} Sector_struc;
+
+typedef struct pack_struc	/* Pack Info				*/
+{   unsigned char  buf [PACK_HEADER_SIZE];
+    guint64 SCR;
+} Pack_struc;
+
+typedef struct sys_header_struc	/* System Header Info			*/
+{   unsigned char  buf [SYS_HEADER_SIZE];
+} Sys_header_struc;
+
+/*************************************************************************
+    Funktionsprototypen, keine Argumente, K&R Style
+*************************************************************************/
+
+/* systems.c */
+void create_sector (Sector_struc     *sector, Pack_struc       *pack, Sys_header_struc *sys_header,
+	unsigned int packet_size, unsigned char *inputbuffer, unsigned char type, unsigned char buffer_scale,
+	unsigned int buffer_size, unsigned char buffers, guint64 PTS, guint64 DTS,
+	unsigned char timestamps, unsigned int  which_streams);
+
+void create_pack (Pack_struc *pack, guint64 SCR, unsigned int mux_rate);
+
+void create_sys_header (Sys_header_struc *sys_header, unsigned int rate_bound, unsigned char audio_bound,
+	unsigned char fixed, unsigned char CSPS, unsigned char audio_lock, unsigned char video_lock,
+	unsigned char video_bound, unsigned char stream1, unsigned char buffer1_scale, unsigned int buffer1_size,
+	unsigned char stream2, unsigned char buffer2_scale, unsigned int buffer2_size, unsigned int which_streams);
+
+#endif
diff --git a/gst/mpeg1sys/systems.c b/gst/mpeg1sys/systems.c
new file mode 100644
index 00000000..d0b3388a
--- /dev/null
+++ b/gst/mpeg1sys/systems.c
@@ -0,0 +1,290 @@
+#include <string.h>
+
+#include "main.h"
+
+static void buffer_timecode (timecode, marker, buffer)
+guint64 timecode;
+unsigned char  marker;
+unsigned char **buffer;
+
+{
+  unsigned char temp;
+
+  temp = (marker << 4) | ((timecode>>29) & 0x38) |
+                ((timecode >> 29) & 0x6) | 1;
+  *((*buffer)++)=temp;
+  temp = (timecode & 0x3fc00000) >> 22;
+  *((*buffer)++)=temp;
+  temp = ((timecode & 0x003f8000) >> 14) | 1;
+  *((*buffer)++)=temp;
+  temp = (timecode & 0x7f80) >> 7;
+  *((*buffer)++)=temp;
+  temp = ((timecode & 0x007f) << 1) | 1;
+  *((*buffer)++)=temp;
+}
+
+/*************************************************************************
+	creates a complete sector.
+	Also copies Pack and Sys_Header informations into the
+	sector buffer, then reads a packet full of data from
+	the input stream into the sector buffer.
+*************************************************************************/
+
+
+void create_sector (sector, pack, sys_header,
+			packet_size, inputbuffer, type, 
+			buffer_scale, buffer_size, buffers,
+			PTS, DTS, timestamps, which_streams )
+
+Sector_struc 	 *sector;
+Pack_struc	 *pack;
+Sys_header_struc *sys_header;
+unsigned int 	 packet_size;
+unsigned char	 *inputbuffer;
+
+unsigned char 	 type;
+unsigned char 	 buffer_scale;
+unsigned int 	 buffer_size;
+unsigned char 	 buffers;
+guint64   PTS;
+guint64   DTS;
+unsigned char 	 timestamps;
+unsigned int     which_streams;
+
+{
+    int i,j,tmp;
+    unsigned char *index;
+    unsigned char *size_offset;
+
+    /* printf("creating sector\n"); */
+
+    index = sector->buf;
+    sector->length_of_sector=0;
+
+/* Should we copy Pack Header information ? */
+
+    if (pack != NULL)
+    {
+	i = sizeof(pack->buf);
+	bcopy (pack->buf, index, i);
+	index += i;
+	sector->length_of_sector += i;
+    }
+
+/* Should we copy System Header information ? */
+
+    if (sys_header != NULL)
+    {
+		i = sizeof(sys_header->buf);
+
+		/* only one stream? 3 bytes less in sys header */
+		if (which_streams != STREAMS_BOTH) i -= 3;
+
+		bcopy (sys_header->buf, index, i);
+		index += i;
+		sector->length_of_sector += i;
+    }
+
+    /* write constant packet header data */
+
+    *(index++) = (unsigned char)(PACKET_START)>>16;
+    *(index++) = (unsigned char)(PACKET_START & 0x00ffff)>>8;
+    *(index++) = (unsigned char)(PACKET_START & 0x0000ff);
+    *(index++) = type;	
+
+    /* we remember this offset in case we will have to shrink this packet */
+    
+    size_offset = index;
+    *(index++) = (unsigned char)((packet_size - PACKET_HEADER_SIZE)>>8);
+    *(index++) = (unsigned char)((packet_size - PACKET_HEADER_SIZE)&0xff);
+
+    *(index++) = STUFFING_BYTE;
+    *(index++) = STUFFING_BYTE;
+    *(index++) = STUFFING_BYTE;
+
+    i = 0;
+
+    if (!buffers) i +=2;
+    if (timestamps == TIMESTAMPS_NO) i+=9;
+    else if (timestamps == TIMESTAMPS_PTS) i+=5;
+
+    /* printf("%i stuffing %d\n", i, timestamps); */
+    
+    for (j=0; j<i; j++)
+	*(index++) = STUFFING_BYTE;
+
+    /* should we write buffer info ? */
+
+    if (buffers)
+    {
+	*(index++) = (unsigned char) (0x40 |
+			(buffer_scale << 5) | (buffer_size >> 8));
+	*(index++) = (unsigned char) (buffer_size & 0xff);
+    }
+
+    /* should we write PTS, PTS & DTS or nothing at all ? */
+
+    switch (timestamps)
+    {
+	case TIMESTAMPS_NO:
+	    *(index++) = MARKER_NO_TIMESTAMPS;
+	    break;
+	case TIMESTAMPS_PTS:
+	    buffer_timecode (PTS, MARKER_JUST_PTS, &index);
+	    sector->TS = PTS;
+	    break;
+	case TIMESTAMPS_PTS_DTS:
+	    buffer_timecode (PTS, MARKER_PTS, &index);
+	    buffer_timecode (DTS, MARKER_DTS, &index);
+	    sector->TS = DTS;
+	    break;
+    }
+
+/* read in packet data */
+    
+    i = (packet_size - PACKET_HEADER_SIZE - AFTER_PACKET_LENGTH);
+
+    if (type == PADDING_STR)
+    {
+	for (j=0; j<i; j++)
+	    *(index++)=(unsigned char) STUFFING_BYTE;
+	tmp = i;
+    } 
+    else
+    {   
+	/*tmp = fread (index, sizeof (unsigned char), i, inputstream);*/
+	memcpy(index, inputbuffer, i); tmp = i;
+        index += tmp;
+
+	/* if we did not get enough data bytes, shorten the Packet length */
+
+	if (tmp != i)
+	{   
+	    packet_size -= (i-tmp);
+	    *(size_offset++) = (unsigned char)((packet_size - PACKET_HEADER_SIZE)>>8);
+	    *(size_offset++) = (unsigned char)((packet_size - PACKET_HEADER_SIZE)&0xff);
+	    
+/* zero byte stuffing in the last Packet of a stream */
+/* we don't need this any more, since we shortenend the packet */
+/* 	    for (j=tmp; j<i; j++) */
+/* 		*(index++)=(unsigned char) ZERO_STUFFING_BYTE; */
+	}
+    }
+
+
+    /* write other struct data */
+
+    sector->length_of_sector += packet_size;
+    sector->length_of_packet_data = tmp;
+    
+}
+
+/*************************************************************************
+	writes specifical pack header information into a buffer
+	later this will be copied from the sector routine into
+	the sector buffer
+*************************************************************************/
+
+void create_pack (pack, SCR, mux_rate)
+
+Pack_struc	 *pack;
+unsigned int 	 mux_rate;
+guint64   SCR;
+
+{
+    unsigned char *index;
+
+    index = pack->buf;
+
+    *(index++) = (unsigned char)((PACK_START)>>24);
+    *(index++) = (unsigned char)((PACK_START & 0x00ff0000)>>16);
+    *(index++) = (unsigned char)((PACK_START & 0x0000ff00)>>8);
+    *(index++) = (unsigned char)(PACK_START & 0x000000ff);
+    buffer_timecode (SCR, MARKER_SCR, &index);
+    *(index++) = (unsigned char)(0x80 | (mux_rate >>15));
+    *(index++) = (unsigned char)(0xff & (mux_rate >> 7));
+    *(index++) = (unsigned char)(0x01 | ((mux_rate & 0x7f)<<1));
+    pack->SCR = SCR;
+}
+
+
+/*************************************************************************
+	writes specifical system header information into a buffer
+	later this will be copied from the sector routine into
+	the sector buffer
+*************************************************************************/
+
+void create_sys_header (sys_header, rate_bound, audio_bound, 
+			fixed, CSPS, audio_lock, video_lock,
+			video_bound,
+			stream1, buffer1_scale, buffer1_size,
+			stream2, buffer2_scale, buffer2_size,
+			which_streams)
+
+Sys_header_struc *sys_header;
+unsigned int	 rate_bound;
+unsigned char	 audio_bound;
+unsigned char	 fixed;
+unsigned char	 CSPS;
+unsigned char	 audio_lock;
+unsigned char	 video_lock;
+unsigned char	 video_bound;
+
+unsigned char 	 stream1;
+unsigned char 	 buffer1_scale;
+unsigned int 	 buffer1_size;
+unsigned char 	 stream2;
+unsigned char 	 buffer2_scale;
+unsigned int 	 buffer2_size;
+unsigned int     which_streams;
+
+{
+    unsigned char *index;
+
+    index = sys_header->buf;
+
+    /* if we are not using both streams, we should clear some
+       options here */
+
+    if (!(which_streams & STREAMS_AUDIO))
+	audio_bound = 0;
+    if (!(which_streams & STREAMS_VIDEO))
+	video_bound = 0;
+
+    *(index++) = (unsigned char)((SYS_HEADER_START)>>24);
+    *(index++) = (unsigned char)((SYS_HEADER_START & 0x00ff0000)>>16);
+    *(index++) = (unsigned char)((SYS_HEADER_START & 0x0000ff00)>>8);
+    *(index++) = (unsigned char)(SYS_HEADER_START & 0x000000ff);
+
+    if (which_streams == STREAMS_BOTH) {
+	*(index++) = (unsigned char)(SYS_HEADER_LENGTH >> 8);
+	*(index++) = (unsigned char)(SYS_HEADER_LENGTH & 0xff);
+    } else {
+	*(index++) = (unsigned char)((SYS_HEADER_LENGTH-3) >> 8);
+	*(index++) = (unsigned char)((SYS_HEADER_LENGTH-3) & 0xff);
+    }
+
+    *(index++) = (unsigned char)(0x80 | (rate_bound >>15));
+    *(index++) = (unsigned char)(0xff & (rate_bound >> 7));
+    *(index++) = (unsigned char)(0x01 | ((rate_bound & 0x7f)<<1));
+    *(index++) = (unsigned char)((audio_bound << 2)|(fixed << 1)|CSPS);
+    *(index++) = (unsigned char)((audio_lock << 7)|
+		 (video_lock << 6)|0x20|video_bound);
+
+    *(index++) = (unsigned char)RESERVED_BYTE;
+
+    if (which_streams & STREAMS_AUDIO) {
+	*(index++) = stream1;
+	*(index++) = (unsigned char) (0xc0 |
+		     (buffer1_scale << 5) | (buffer1_size >> 8));
+	*(index++) = (unsigned char) (buffer1_size & 0xff);
+    }
+
+    if (which_streams & STREAMS_VIDEO) {
+	*(index++) = stream2;
+	*(index++) = (unsigned char) (0xc0 |
+		     (buffer2_scale << 5) | (buffer2_size >> 8));
+	*(index++) = (unsigned char) (buffer2_size & 0xff);
+    }
+
+}
diff --git a/gst/mpeg2sub/.gitignore b/gst/mpeg2sub/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/mpeg2sub/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/mpeg2sub/Makefile.am b/gst/mpeg2sub/Makefile.am
new file mode 100644
index 00000000..d8bfe888
--- /dev/null
+++ b/gst/mpeg2sub/Makefile.am
@@ -0,0 +1,18 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstmpeg2subt.la
+
+libgstmpeg2subt_la_SOURCES = gstmpeg2subt.c  
+
+if HAVE_CPU_I386
+ARCHCFLAGS = -m486
+else
+ARCHCFLAGS = 
+endif
+
+libgstmpeg2subt_la_CFLAGS = -O3 $(ARCHCFLAGS) -fschedule-insns2 $(FOMIT_FRAME_POINTER) -finline-functions -ffast-math $(GST_CFLAGS)
+
+noinst_HEADERS = gstmpeg2subt.h 
+
+EXTRA_DIST = Notes.txt
+
diff --git a/gst/mpeg2sub/Notes.txt b/gst/mpeg2sub/Notes.txt
new file mode 100644
index 00000000..a0e56e3c
--- /dev/null
+++ b/gst/mpeg2sub/Notes.txt
@@ -0,0 +1,324 @@
+

+          DVD subtitles

+         ---------------

+

+

+  0. Introduction

+  1. Basics

+  2. The data structure

+  3. Reading the control header

+  4. Decoding the graphics

+  5. What I do not know yet / What I need

+  6. Thanks

+  7. Changes

+

+

+

+

+

+The latest version of this document can be found here:

+http://www.via.ecp.fr/~sam/doc/dvd/

+

+

+

+

+

+0. Introduction

+

+  One of the last things we missed in DVD decoding under my system was the

+decoding of subtitles. I found no information on the web or Usenet about them,

+apart from a few words on them being run-length encoded in the DVD FAQ.

+

+  So we decided to reverse-engineer their format (it's completely legal in

+France, since we did it on interoperability purposes), and managed to get

+almost all of it.

+

+

+

+

+

+1. Basics

+

+  DVD subtitles are hidden in private PS packets (0x000001ba), just like AC3

+streams are.

+

+  Within the PS packet, there are PES packets, and like AC3, the header for the

+ones containing subtitles have a 0x000001bd header.

+  As for AC3, where there's an ID like (0x80 + x), there's a subtitle ID equal

+to (0x20 + x), where x is the subtitle ID. Thus there seems to be only

+16 possible different subtitles on a DVD (my Taxi Driver copy has 16).

+

+  I'll suppose you know how to extract AC3 from a DVD, and jump to the

+interesting part of this documentation. Anyway you're unlikely to have

+understood what I said without already being familiar with MPEG2.

+

+

+

+

+

+2. The data structure

+

+A subtitle packet, after its parts have been collected and appended, looks

+like this :

+

+   +----------------------------------------------------------+    

+   |                                                          |

+   |   0    2                                         size    |

+   |   +----+------------------------+-----------------+      |

+   |   |size|       data packet      |     control     |      |

+   |   +----+------------------------+-----------------+      |

+   |                                                          |

+   |                     a subtitle packet                    |

+   |                                                          |

+   +----------------------------------------------------------+    

+

+size is a 2 bytes word, and data packet and control may have any size.

+

+

+Here is the structure of the data packet :

+

+   +----------------------------------------------------------+    

+   |                                                          |

+   |   2    4                                        S0+2     |

+   |   +----+------------------------------------------+      |

+   |   | S0 |                  data                    |      |

+   |   +----+------------------------------------------+      |

+   |                                                          |

+   |                      the data packet                     |

+   |                                                          |

+   +----------------------------------------------------------+    

+

+S0, the data packet size, is a 2 bytes word.

+

+

+Finally, here's the structure of the control packet :

+

+   +----------------------------------------------------------+    

+   |                                                          |

+   | S0+2  S0+4                                 S1       size |

+   |   +----+---------+---------+--+---------+--+---------+   |

+   |   | S1 |ctrl seq |ctrl seq |..|ctrl seq |ff| end seq |   |

+   |   +----+---------+---------+--+---------+--+---------+   |

+   |                                                          |

+   |                     the control packet                   |

+   |                                                          |

+   +----------------------------------------------------------+    

+

+To summarize :

+

+ - S1, at offset S0+2, the position of the end sequence

+ - several control sequences

+ - the 'ff' byte

+ - the end sequence

+

+

+

+

+

+3. Reading the control header

+

+The first thing to read is the control sequences. There are several

+types of them, and each type is determined by its first byte. As far

+as I know, each type has a fixed length.

+

+ * type 0x01 : '01' - 1 byte

+  it seems to be an empty control sequence.

+

+ * type 0x03 : '03wxyz' - 3 bytes

+  this one has the palette information ; it basically says 'encoded color 0

+ is the wth color of the palette, encoded color 1 is the xth color, aso.

+

+ * type 0x04 : '04wxyz' - 3 bytes

+  I *think* this is the alpha channel information ; I only saw values of 0 or f

+ for those nibbles, so I can't really be sure, but it seems plausable.

+

+ * type 0x05 : '05xxxXXXyyyYYY' - 7 bytes

+  the coordinates of the subtitle on the screen :

+   xxx is the first column of the subtitle

+   XXX is the last column of the subtitle

+   yyy is the first line of the subtitle

+   YYY is the last line of the subtitle

+  thus the subtitle's size is (XXX-xxx+1) x (YYY-yyy+1)

+

+ * type 0x06 : '06xxxxyyyy' - 5 bytes

+  xxxx is the position of the first graphic line, and yyyy is the position of

+ the second one (the graphics are interlaced, so it helps a lot :p)

+

+The end sequence has this structure:

+

+ xxxx yyyy 02 ff (ff)

+

+ it ends with 'ff' or 'ffff', to make the whole packet have an even length.

+

+FIXME: I absolutely don't know what xxxx is. I suppose it may be some date

+information since I found it nowhere else, but I can't be sure.

+

+ yyyy is equal to S1 (see picture).

+

+

+Example of a control header :

+----

+0A 0C 01 03 02 31 04 0F F0 05 00 02 CF 00 22 3E 06 00 06 04 E9 FF 00 93 0A 0C 02 FF

+----

+Let's decode it. First of all, S1 = 0x0a0c.

+

+The control sequences are :

+ 01

+   Nothing to say about this one

+ 03 02 31

+   Color 0 is 0, color 1 is 2, color 2 is 3, and color 3 is 1.

+ 04 0F F0

+   Colors 0 and 3 are transparent, and colors 2 and 3 are opaque (not sure of this one)

+ 05 00 02 CF 00 22 3E

+   The first column is 0x000, the last one is 0x2cf, the first line is 0x002, and

+   the last line is 0x23e. Thus the subtitle's size is 0x2d0 x 0x23d.

+ 06 00 06 04 E9

+   The first encoded image starts at offset 0x006, and the second one starts at 0x04e9.

+

+And the end sequence is :

+  00 93 0A 0C 02 FF

+   Which means... well, not many things now. We can at least verify that S1 (0x0a0c) is

+   there.

+

+

+

+

+

+4. Decoding the graphics

+

+   The graphics are rather easy to decode (at least, when you know how to do it - it

+  took us one whole week to figure out what the encoding was :p).

+

+   The picture is interlaced, for instance for a 40 lines picture :

+

+  line 0  ---------------#----------

+  line 2  ------#-------------------

+   ...

+  line 38 ------------#-------------

+  line 1  ------------------#-------

+  line 3  --------#-----------------

+   ...

+  line 39 -------------#------------

+

+   When decoding you should get:

+

+  line 0  ---------------#----------

+  line 1  ------------------#-------

+  line 2  ------#-------------------

+  line 3  --------#-----------------

+   ...

+  line 38 ------------#-------------

+  line 39 -------------#------------

+

+   Computers with weak processors could choose only to decode even lines

+  in order to gain some time, for instance.

+

+

+   The encoding is run-length encoded, with the following alphabet:

+

+   0xf

+   0xe

+   0xd

+   0xc

+   0xb

+   0xa

+   0x9

+   0x8

+   0x7

+   0x6

+   0x5

+   0x4

+   0x3-

+   0x2-

+   0x1-

+   0x0f-

+   0x0e-

+   0x0d-

+   0x0c-

+   0x0b-

+   0x0a-

+   0x09-

+   0x08-

+   0x07-

+   0x06-

+   0x05-

+   0x04-

+   0x03--

+   0x02--

+   0x01--

+   0x0000

+

+   '-' stands for any other nibble. Once a sequence X of this alphabet has

+  been read, the pixels can be displayed : (X >> 2) is the number of pixels

+  to display, and (X & 0x3) is the color of the pixel.

+

+   For instance, 0x23 means "8 pixels of color 3".

+

+   "0000" has a special meaning : it's a carriage return. The decoder should

+  do a carriage return when reaching the end of the line, or when encountering

+  this "0000" sequence. When doing a carriage return, the parser should be

+  reset to the next even position (it cannot be nibble-aligned at the start

+  of a line).

+

+   After a carriage return, the parser should read a line on the other

+  interlaced picture, and swap like this after each carriage return.

+

+   Perhaps I don't explain this very well, so you'd better have a look at

+  the enclosed source.

+

+

+

+

+

+5. What I do not know yet / What I need

+

+I don't know what's in the end sequence yet.

+

+Also, I don't know exactly when to display subtitles, and when to remove them.

+

+I don't know if there are other types of control sequences (in my programs I consider

+0xff as a control sequence type, as well as 0x02. I don't know if it's correct or not,

+so please comment on this).

+

+I don't know what the "official" color palette is.

+

+I don't know how to handle transparency information.

+

+I don't know if this document is generic enough.

+

+So what I need is you :

+

+ - if you can, patch this document or my programs to fix strange behaviour with your subtitles.

+

+ - send me your subtitles (there's a program to extract them enclosed) ; the first 10 KB

+  of subtitles in a VOB should be enough, but it would be cool if you sent me one subtitle

+  file per language.

+

+

+

+

+

+6. Thanks

+

+ Thanks to Michel Lespinasse <walken@via.ecp.fr> for his great help on understanding

+the RLE stuff, and for all the ideas he had.

+

+ Thanks to mass (David Waite) and taaz (David I. Lehn) from irc at

+openprojects.net for sending me their subtitles.

+

+

+

+

+

+7. Changes

+

+ 20000116: added the 'changes' section.

+ 20000116: added David Waite's and David I. Lehn's name.

+ 20000116: changed "x0" and "x1" to "S0" and "S1" to make it less confusing.

+

+

+

+

+-- 

+Paris, January 16th 2000

+Samuel Hocevar <sam@via.ecp.fr>

diff --git a/gst/mpeg2sub/gstmpeg2subt.c b/gst/mpeg2sub/gstmpeg2subt.c
new file mode 100644
index 00000000..ee51d067
--- /dev/null
+++ b/gst/mpeg2sub/gstmpeg2subt.c
@@ -0,0 +1,443 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 <mpeg2subt.h>
+
+static void	gst_mpeg2subt_class_init	(GstMpeg2SubtClass *klass);
+static void	gst_mpeg2subt_init		(GstMpeg2Subt *mpeg2subt);
+
+static void	gst_mpeg2subt_chain_video	(GstPad *pad,GstBuffer *buf);
+static void	gst_mpeg2subt_chain_subtitle	(GstPad *pad,GstBuffer *buf);
+
+static void	gst_mpeg2subt_merge_title	(GstMpeg2Subt *mpeg2subt, GstBuffer *buf);
+
+static void	gst_mpeg2subt_set_property		(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void	gst_mpeg2subt_get_property		(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+/* elementfactory information */
+static GstElementDetails mpeg2subt_details = {
+  "MPEG2 subtitle Decoder",
+  "Filter/Decoder/Video",
+  "Decodes and merges MPEG2 subtitles into a video frame",
+  VERSION,
+  "Samuel Hocevar <sam@via.ecp.fr>\n"
+  "Michel Lespinasse <walken@via.ecp.fr>\n"
+  "Wim Taymans <wim.taymans@chello.be>",
+  "(C) 2000",
+};
+
+static GstTypeDefinition mpeg2subtitledefinition = {
+  "mpeg2subt_video/mpeg2ubtitle",
+  "video/mpeg2subtitle",
+  NULL,
+  NULL,
+};
+
+/* GstMpeg2Subt signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_SKIP,
+  /* FILL ME */
+};
+
+static guchar yuv_color[16] = {
+  0x99,
+  0x00,
+  0xFF,
+  0x00,
+  0x40,
+  0x50,
+  0x60,
+  0x70,
+  0x80,
+  0x90,
+  0xA0,
+  0xB0,
+  0xC0,
+  0xD0,
+  0xE0,
+  0xF0
+};
+
+
+
+
+static GstElementClass *parent_class = NULL;
+/*static guint gst_mpeg2subt_signals[LAST_SIGNAL] = { 0 };*/
+
+GType
+gst_mpeg2subt_get_type (void)
+{
+  static GType mpeg2subt_type = 0;
+
+  if (!mpeg2subt_type) {
+    static const GTypeInfo mpeg2subt_info = {
+      sizeof(GstMpeg2SubtClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_mpeg2subt_class_init,
+      NULL,
+      NULL,
+      sizeof(GstMpeg2Subt),
+      0,
+      (GInstanceInitFunc)gst_mpeg2subt_init,
+    };
+    mpeg2subt_type = g_type_register_static(GST_TYPE_ELEMENT, "GstMpeg2Subt", &mpeg2subt_info, 0);
+  }
+  return mpeg2subt_type;
+}
+
+static void
+gst_mpeg2subt_class_init (GstMpeg2SubtClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SKIP,
+    g_param_spec_int("skip","skip","skip",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  gobject_class->set_property = gst_mpeg2subt_set_property;
+  gobject_class->get_property = gst_mpeg2subt_get_property;
+
+}
+
+static void
+gst_mpeg2subt_init (GstMpeg2Subt *mpeg2subt)
+{
+  mpeg2subt->videopad = gst_pad_new("video",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(mpeg2subt),mpeg2subt->videopad);
+  gst_pad_set_chain_function(mpeg2subt->videopad,gst_mpeg2subt_chain_video);
+
+  mpeg2subt->subtitlepad = gst_pad_new("subtitle",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(mpeg2subt),mpeg2subt->subtitlepad);
+  gst_pad_set_chain_function(mpeg2subt->subtitlepad,gst_mpeg2subt_chain_subtitle);
+
+  mpeg2subt->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(mpeg2subt),mpeg2subt->srcpad);
+
+  mpeg2subt->partialbuf = NULL;
+  mpeg2subt->have_title = FALSE;
+}
+
+static void
+gst_mpeg2subt_chain_video (GstPad *pad, GstBuffer *buf)
+{
+  GstMpeg2Subt *mpeg2subt;
+  guchar *data;
+  glong size;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  mpeg2subt = GST_MPEG2SUBT (GST_OBJECT_PARENT (pad));
+
+  data = GST_BUFFER_DATA(buf);
+  size = GST_BUFFER_SIZE(buf);
+
+  if (mpeg2subt->have_title && mpeg2subt->duration != 0) {
+    gst_mpeg2subt_merge_title(mpeg2subt, buf);
+    mpeg2subt->duration--;
+  }
+
+  gst_pad_push(mpeg2subt->srcpad, buf);
+}
+
+
+static void
+gst_mpeg2subt_parse_header (GstMpeg2Subt *mpeg2subt)
+{
+  guchar *buffer = GST_BUFFER_DATA(mpeg2subt->partialbuf);
+  guchar dummy;
+  guint i;
+
+  i = mpeg2subt->data_size + 4;
+  while (i < mpeg2subt->packet_size)
+  {
+    dummy = buffer [i];
+    switch (dummy)
+    {
+      case 0x01: /* null packet ? */
+        i++;
+        break;
+      case 0x02: /* 02 ff (ff) is the end of the packet */
+        i = mpeg2subt->packet_size;
+        break;
+      case 0x03: /* palette */
+        mpeg2subt->color[0] = yuv_color[buffer [i+1] >> 4];
+        mpeg2subt->color[1] = yuv_color[buffer [i+1] & 0xf];
+        mpeg2subt->color[2] = yuv_color[buffer [i+2] >> 4];
+        mpeg2subt->color[3] = yuv_color[buffer [i+2] & 0xf];
+        mpeg2subt->color[4] = yuv_color[0xf];
+	GST_DEBUG (0,"mpeg2subt: colors %d %d %d %d\n", mpeg2subt->color[0],mpeg2subt->color[1],mpeg2subt->color[2],mpeg2subt->color[3]);
+        i += 3;
+        break;
+      case 0x04: /* transparency palette */
+        mpeg2subt->trans[3] = buffer [i+1] >> 4;
+	mpeg2subt->trans[2] = buffer [i+1] & 0xf;
+	mpeg2subt->trans[1] = buffer [i+2] >> 4;
+	mpeg2subt->trans[0] = buffer [i+2] & 0xf;
+	GST_DEBUG (0,"mpeg2subt: transparency %d %d %d %d\n", mpeg2subt->trans[0],mpeg2subt->trans[1],mpeg2subt->trans[2],mpeg2subt->trans[3]);
+	i += 3;
+	break;
+      case 0x05: /* image coordinates */
+        mpeg2subt->width = 1 + ( ((buffer[i+2] & 0x0f) << 8) + buffer[i+3] )
+                  - ( (((unsigned int)buffer[i+1]) << 4) + (buffer[i+2] >> 4) );
+        mpeg2subt->height = 1 + ( ((buffer[i+5] & 0x0f) << 8) + buffer[i+6] )
+                   - ( (((unsigned int)buffer[i+4]) << 4) + (buffer[i+5] >> 4) );
+        i += 7;
+	break;
+      case 0x06: /* image 1 / image 2 offsets */
+        mpeg2subt->offset[0] = (((unsigned int)buffer[i+1]) << 8) + buffer[i+2];
+        mpeg2subt->offset[1] = (((unsigned int)buffer[i+3]) << 8) + buffer[i+4];
+	i += 5;
+	break;
+      case 0xff: /* "ff xx yy zz uu" with 'zz uu' == start of control packet
+		  *  xx and yy are the end time in 90th/sec
+	          */
+	mpeg2subt->duration = (((buffer[i+1] << 8) + buffer[i+2]) * 25)/90;
+
+	GST_DEBUG (0,"duration %d\n", mpeg2subt->duration);
+
+	if ( (buffer[i+3] != buffer[mpeg2subt->data_size+2])
+	     || (buffer[i+4] != buffer[mpeg2subt->data_size+3]) )
+	{
+	  g_print("mpeg2subt: invalid control header (%.2x%.2x != %.2x%.2x) !\n",
+		buffer[i+3], buffer[i+4], buffer[mpeg2subt->data_size+2], buffer[mpeg2subt->data_size+3] );
+/* FIXME */
+/*          exit(1); */
+	}
+	i += 5;
+	break;
+      default:
+	g_print("mpeg2subt: invalid sequence in control header (%.2x) !\n", dummy);
+	break;
+    }
+  }
+}
+
+static int
+get_nibble (guchar *buffer, gint *offset, gint id, gint *aligned)
+{
+  static int next;
+
+  if (*aligned)
+  {
+    next = buffer[offset[id]];
+    offset[id]++;
+
+    *aligned = 0;
+    return next >> 4;
+  }
+  else
+  {
+    *aligned = 1;
+    return next & 0xf;
+  }
+}
+
+static void
+gst_mpeg2subt_merge_title (GstMpeg2Subt *mpeg2subt, GstBuffer *buf)
+{
+  gint x=0, y=0;
+  gint width = mpeg2subt->width;
+  gint height = mpeg2subt->height;
+  guchar *buffer = GST_BUFFER_DATA(mpeg2subt->partialbuf);
+  guchar *target = GST_BUFFER_DATA(buf);
+  gint id=0, aligned=1;
+  gint offset[2];
+
+  offset[0] = mpeg2subt->offset[0];
+  offset[1] = mpeg2subt->offset[1];
+#define get_nibble() get_nibble (buffer, offset, id, &aligned)
+
+  GST_DEBUG (0,"mpeg2subt: merging subtitle\n");
+
+  while ((offset[1] < mpeg2subt->data_size + 2) && (y < height))
+  {
+    gint code;
+    gint length, colorid;
+
+    code = get_nibble();
+    if (code >= 0x4)	/* 4 .. f */
+    {
+found_code:
+      length = code >> 2;
+      colorid = code & 3;
+      while (length--)
+        if (x++ < width) {
+	  if (mpeg2subt->trans[colorid] != 0x0) {
+            *target++ = mpeg2subt->color[colorid];
+	  }
+          else target++;
+	}
+
+      if (x >= width)
+      {
+        if (!aligned)
+          get_nibble ();
+        goto next_line;
+      }
+      continue;
+    }
+
+    code = (code << 4) + get_nibble();
+    if (code >= 0x10)	/* 1x .. 3x */
+      goto found_code;
+
+    code = (code << 4) + get_nibble();
+    if (code >= 0x40)	/* 04x .. 0fx */
+      goto found_code;
+
+    code = (code << 4) + get_nibble();
+    if (code >= 0x100)	/* 01xx .. 03xx */
+      goto found_code;
+
+    /* 00xx - should only happen for 00 00 */
+    if (!aligned)
+      code = (code << 4) + get_nibble(); /* 0 0x xx */
+
+    if (code)
+    {
+      g_print("mpeg2subt: got unknown code 00%x (offset %x side %x, x=%d, y=%d)\n", code, mpeg2subt->offset[id], id, x, y);
+      goto next_line;
+    }
+next_line:
+    /* aligned 00 00 */
+    if (y < height) {
+      target+=(width-x);
+      x = 0;
+      y++;
+      id = 1 - id;
+    }
+  }
+}
+
+static void
+gst_mpeg2subt_chain_subtitle (GstPad *pad, GstBuffer *buf)
+{
+  GstMpeg2Subt *mpeg2subt;
+  guchar *data;
+  glong size = 0;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+/*  g_return_if_fail(GST_IS_BUFFER(buf)); */
+
+  mpeg2subt = GST_MPEG2SUBT (GST_OBJECT_PARENT (pad));
+
+  if (mpeg2subt->have_title) {
+    gst_buffer_unref(mpeg2subt->partialbuf);
+    mpeg2subt->partialbuf = NULL;
+    mpeg2subt->have_title = FALSE;
+  }
+
+  GST_DEBUG (0,"presentation time %llu\n", GST_BUFFER_TIMESTAMP(buf));
+
+  /* deal with partial frame from previous buffer */
+  if (mpeg2subt->partialbuf) {
+
+    mpeg2subt->partialbuf = gst_buffer_append(mpeg2subt->partialbuf, buf);;
+    /* and the one we received.. */
+    gst_buffer_unref(buf);
+  }
+  else {
+    mpeg2subt->partialbuf = buf;
+  }
+
+  data = GST_BUFFER_DATA(mpeg2subt->partialbuf);
+  size = GST_BUFFER_SIZE(mpeg2subt->partialbuf);
+
+  mpeg2subt->packet_size = GUINT16_FROM_BE(*(guint16 *)data);
+
+  if (mpeg2subt->packet_size == size) {
+
+    GST_DEBUG (0,"mpeg2subt: subtitle packet size %d, current size %ld\n", mpeg2subt->packet_size, size);
+
+    mpeg2subt->data_size = GUINT16_FROM_BE(*(guint16 *)(data+2));
+
+    gst_mpeg2subt_parse_header(mpeg2subt);
+    mpeg2subt->have_title = TRUE;
+  }
+}
+
+static void
+gst_mpeg2subt_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstMpeg2Subt *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_MPEG2SUBT(object));
+  src = GST_MPEG2SUBT(object);
+
+  switch (prop_id) {
+    default:
+      break;
+  }
+}
+
+static void
+gst_mpeg2subt_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstMpeg2Subt *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_MPEG2SUBT(object));
+  src = GST_MPEG2SUBT(object);
+
+  switch (prop_id) {
+    default:
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* create an elementfactory for the mpeg2subt element */
+  factory = gst_elementfactory_new("mpeg2subt",GST_TYPE_MPEG2SUBT,
+                                   &mpeg2subt_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "mpeg2subt",
+  plugin_init
+};
diff --git a/gst/mpeg2sub/gstmpeg2subt.h b/gst/mpeg2sub/gstmpeg2subt.h
new file mode 100644
index 00000000..71e88909
--- /dev/null
+++ b/gst/mpeg2sub/gstmpeg2subt.h
@@ -0,0 +1,82 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_MPEG2SUBT_H__
+#define __GST_MPEG2SUBT_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_MPEG2SUBT \
+  (gst_mpeg2subt_get_type())
+#define GST_MPEG2SUBT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MPEG2SUBT,GstMpeg2Subt))
+#define GST_MPEG2SUBT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MPEG2SUBT,GstMpeg2Subt))
+#define GST_IS_MPEG2SUBT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MPEG2SUBT))
+#define GST_IS_MPEG2SUBT_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MPEG2SUBT))
+
+typedef struct _GstMpeg2Subt GstMpeg2Subt;
+typedef struct _GstMpeg2SubtClass GstMpeg2SubtClass;
+
+struct _GstMpeg2Subt {
+  GstElement element;
+
+  GstPad *videopad,*subtitlepad,*srcpad;
+
+  GstBuffer *partialbuf;	/* previous buffer (if carryover) */
+
+  gboolean have_title;
+
+  guint16 packet_size;
+  guint16 data_size;
+
+  gint offset[2];
+  guchar color[5];
+  guchar trans[4];
+
+  guint duration;
+
+  gint width, height;
+
+};
+
+struct _GstMpeg2SubtClass {
+  GstElementClass parent_class;
+};
+
+GType gst_mpeg2subt_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_MPEG2SUBT_H__ */
diff --git a/gst/mpegaudioparse/Makefile.am b/gst/mpegaudioparse/Makefile.am
new file mode 100644
index 00000000..9d670bd3
--- /dev/null
+++ b/gst/mpegaudioparse/Makefile.am
@@ -0,0 +1,16 @@
+#FIXME clean me up a bit
+
+filterdir = $(libdir)/gst
+filter_LTLIBRARIES = libgstmpegaudioparse.la libgstmp3types.la
+
+libgstmpegaudioparse_la_SOURCES = gstmpegaudioparse.c gstmp3types.c
+# FIXME is this useful?
+libgstmpegaudioparse_la_CFLAGS = -O3 $(FOMIT_FRAME_POINTER) -ffast-math -finline-functions $(GST_CFLAGS)
+
+libgstmp3types_la_SOURCES = gstmp3types.c
+libgstmp3types_la_CFLAGS = -O3 $(FOMIT_FRAME_POINTER) -ffast-math -finline-functions $(GST_CFLAGS)
+
+noinst_HEADERS = gstmpegaudioparse.h
+EXTRA_DIST = README
+
+# FIXME is this needed?
diff --git a/gst/mpegaudioparse/README b/gst/mpegaudioparse/README
new file mode 100644
index 00000000..8a803d3e
--- /dev/null
+++ b/gst/mpegaudioparse/README
@@ -0,0 +1,12 @@
+MP3 Audio Parser
+================
+
+This element acts as a parser for mpeg audio data.  It's called 'mp3' but
+in reality will work for any MPEG-1, MPEG-2, or MPEG-2.5 elemental audio
+stream of any of Layers I, II, and III.  It will not (currently, ever?)
+handle MPEG-2 BC or NBC streams, as those have rather specialized needs
+best served be a different filter.
+
+It will take an mpeg audio stream in any form on its 'src' input, with any
+buffer size, and split it into buffers containing a single frame each.
+NOTE: ancillary data is not dealt with right now.
diff --git a/gst/mpegaudioparse/gstmp3types.c b/gst/mpegaudioparse/gstmp3types.c
new file mode 100644
index 00000000..efb9fd5b
--- /dev/null
+++ b/gst/mpegaudioparse/gstmp3types.c
@@ -0,0 +1,77 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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* mp3_typefind(GstBuffer *buf, gpointer private);
+
+static GstTypeDefinition mp3type_definitions[] = {
+  { "mp3types_audio/mp3", "audio/mp3", ".mp3 .mp2 .mp1 .mpga", mp3_typefind },
+  { NULL, NULL, NULL, NULL },
+};
+
+static GstCaps* 
+mp3_typefind(GstBuffer *buf, gpointer private) 
+{
+  gulong head = GULONG_FROM_BE(*((gulong *)GST_BUFFER_DATA(buf)));
+  GstCaps *caps;
+
+  GST_DEBUG (0,"mp3typefind: typefind\n");
+  if ((head & 0xffe00000) != 0xffe00000)
+    return NULL;
+  if (!((head >> 17) & 3))
+    return NULL;
+  if (((head >> 12) & 0xf) == 0xf)
+    return NULL;
+  if (!((head >> 12) & 0xf))
+    return NULL;
+  if (((head >> 10) & 0x3) == 0x3)
+    return NULL;
+
+  caps = gst_caps_new ("mp3_typefind", "audio/mp3", NULL);
+//  gst_caps_set(caps,"layer",GST_PROPS_INT(4-((head>>17)&0x3)));
+
+  return caps;
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  gint i=0;
+
+  while (mp3type_definitions[i].name) {
+    GstTypeFactory *type;
+
+    type = gst_typefactory_new (&mp3type_definitions[i]);
+    gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
+    i++;
+  }
+
+//  gst_info("gsttypes: loaded %d mp3 types\n",i);
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "mp3types",
+  plugin_init
+};
diff --git a/gst/mpegaudioparse/gstmpegaudioparse.c b/gst/mpegaudioparse/gstmpegaudioparse.c
new file mode 100644
index 00000000..b1431c73
--- /dev/null
+++ b/gst/mpegaudioparse/gstmpegaudioparse.c
@@ -0,0 +1,506 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 GST_DEBUG_ENABLED
+#include <gstmpegaudioparse.h>
+
+
+/* elementfactory information */
+static GstElementDetails mp3parse_details = {
+  "MP3 Parser",
+  "Filter/Parser/Audio",
+  "Parses and frames MP3 audio streams, provides seek",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+static GstPadTemplate*
+mp3_src_factory (void)
+{
+  return
+   gst_padtemplate_new (
+  	"src",
+  	GST_PAD_SRC,
+  	GST_PAD_ALWAYS,
+  	gst_caps_new (
+  	  "mp3parse_src",
+    	  "audio/mp3",
+	  gst_props_new (
+    	    "layer",   GST_PROPS_INT_RANGE (1, 3),
+    	    "bitrate", GST_PROPS_INT_RANGE (8, 320),
+    	    "framed",  GST_PROPS_BOOLEAN (TRUE),
+	    NULL)),
+	NULL);
+}
+
+static GstPadTemplate*
+mp3_sink_factory (void) 
+{
+  return
+   gst_padtemplate_new (
+  	"sink",
+  	GST_PAD_SINK,
+  	GST_PAD_ALWAYS,
+  	gst_caps_new (
+  	  "mp3parse_sink",
+    	  "audio/mp3",
+	  NULL),
+	NULL);
+};
+
+/* GstMPEGAudioParse signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_SKIP,
+  ARG_BIT_RATE,
+  /* FILL ME */
+};
+
+static GstPadTemplate *sink_temp, *src_temp;
+
+static void	gst_mp3parse_class_init		(GstMPEGAudioParseClass *klass);
+static void	gst_mp3parse_init		(GstMPEGAudioParse *mp3parse);
+
+static void	gst_mp3parse_loop		(GstElement *element);
+static void	gst_mp3parse_chain		(GstPad *pad,GstBuffer *buf);
+static long	bpf_from_header			(GstMPEGAudioParse *parse, unsigned long header);
+static int	head_check			(unsigned long head);
+
+static void	gst_mp3parse_set_property		(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void	gst_mp3parse_get_property		(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_mp3parse_signals[LAST_SIGNAL] = { 0 };
+
+GType
+mp3parse_get_type(void) {
+  static GType mp3parse_type = 0;
+
+  if (!mp3parse_type) {
+    static const GTypeInfo mp3parse_info = {
+      sizeof(GstMPEGAudioParseClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_mp3parse_class_init,
+      NULL,
+      NULL,
+      sizeof(GstMPEGAudioParse),
+      0,
+      (GInstanceInitFunc)gst_mp3parse_init,
+    };
+    mp3parse_type = g_type_register_static(GST_TYPE_ELEMENT, "GstMPEGAudioParse", &mp3parse_info, 0);
+  }
+  return mp3parse_type;
+}
+
+static void
+gst_mp3parse_class_init (GstMPEGAudioParseClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SKIP,
+    g_param_spec_int("skip","skip","skip",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BIT_RATE,
+    g_param_spec_int("bit_rate","bit_rate","bit_rate",
+                     G_MININT,G_MAXINT,0,G_PARAM_READABLE)); // CHECKME
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  gobject_class->set_property = gst_mp3parse_set_property;
+  gobject_class->get_property = gst_mp3parse_get_property;
+}
+
+static void
+gst_mp3parse_init (GstMPEGAudioParse *mp3parse)
+{
+  mp3parse->sinkpad = gst_pad_new_from_template(sink_temp, "sink");
+  gst_pad_set_caps(mp3parse->sinkpad, gst_pad_get_padtemplate_caps (mp3parse->sinkpad));
+  gst_element_add_pad(GST_ELEMENT(mp3parse),mp3parse->sinkpad);
+//  gst_pad_set_type_id(mp3parse->sinkpad, mp3type);
+
+#if 1	// set this to one to use the old chaining code
+  gst_pad_set_chain_function(mp3parse->sinkpad,gst_mp3parse_chain);
+#else		// else you get the new loop-based code, which isn't complete yet
+  gst_element_set_loop_function (GST_ELEMENT(mp3parse),gst_mp3parse_loop);
+#endif
+
+  mp3parse->srcpad = gst_pad_new_from_template(src_temp, "src");
+  gst_element_add_pad(GST_ELEMENT(mp3parse),mp3parse->srcpad);
+  //gst_pad_set_type_id(mp3parse->srcpad, mp3frametype);
+
+  mp3parse->partialbuf = NULL;
+  mp3parse->skip = 0;
+  mp3parse->in_flush = FALSE;
+}
+
+static guint32
+gst_mp3parse_next_header (guchar *buf,guint32 len,guint32 start)
+{
+  guint32 offset = start;
+  int f = 0;
+
+  while (offset < (len - 4)) {
+    fprintf(stderr,"%02x ",buf[offset]);
+    if (buf[offset] == 0xff)
+      f = 1;
+    else if (f && ((buf[offset] >> 4) == 0x0f))
+      return offset - 1;
+    else
+      f = 0;
+    offset++;
+  }
+  return -1;
+}
+
+static void
+gst_mp3parse_loop (GstElement *element)
+{
+  GstMPEGAudioParse *parse = GST_MP3PARSE(element);
+  GstBuffer *inbuf, *outbuf;
+  guint32 size, offset;
+  guchar *data;
+  guint32 start;
+  guint32 header;
+  gint bpf;
+
+  while (1) {
+    // get a new buffer
+    inbuf = gst_pad_pull (parse->sinkpad);
+    size = GST_BUFFER_SIZE (inbuf);
+    data = GST_BUFFER_DATA (inbuf);
+    offset = 0;
+fprintf(stderr, "have buffer of %d bytes\n",size);
+
+    // loop through it and find all the frames
+    while (offset < (size - 4)) {
+      start = gst_mp3parse_next_header (data,size,offset);
+fprintf(stderr, "skipped %d bytes searching for the next header\n",start-offset);
+      header = GULONG_FROM_BE(*((guint32 *)(data+start)));
+fprintf(stderr, "header is 0x%08x\n",header);
+
+      // figure out how big the frame is supposed to be
+      bpf = bpf_from_header (parse, header);
+
+      // see if there are enough bytes in this buffer for the whole frame
+      if ((start + bpf) <= size) {
+        outbuf = gst_buffer_create_sub (inbuf,start,bpf);
+fprintf(stderr, "sending buffer of %d bytes\n",bpf);
+        gst_pad_push (parse->srcpad, outbuf);
+        offset = start + bpf;
+
+      // if not, we have to deal with it somehow
+      } else {
+fprintf(stderr,"don't have enough data for this frame\n");
+        
+        break;
+      }
+    }
+  }
+}
+
+static void
+gst_mp3parse_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstMPEGAudioParse *mp3parse;
+  guchar *data;
+  glong size,offset = 0;
+  unsigned long header;
+  int bpf;
+  GstBuffer *outbuf;
+  guint64 last_ts;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+//  g_return_if_fail(GST_IS_BUFFER(buf));
+
+  mp3parse = GST_MP3PARSE (gst_pad_get_parent (pad));
+
+  GST_DEBUG (0,"mp3parse: received buffer of %d bytes\n",GST_BUFFER_SIZE(buf));
+
+  last_ts = GST_BUFFER_TIMESTAMP(buf);
+
+  if (GST_BUFFER_FLAG_IS_SET(buf, GST_BUFFER_FLUSH)) {
+    if (mp3parse->partialbuf) {
+      gst_buffer_unref(mp3parse->partialbuf);
+      mp3parse->partialbuf = NULL;
+    }
+    mp3parse->in_flush = TRUE;
+  }
+
+  // if we have something left from the previous frame
+  if (mp3parse->partialbuf) {
+
+    mp3parse->partialbuf = gst_buffer_append(mp3parse->partialbuf, buf);
+    // and the one we received..
+    gst_buffer_unref(buf);
+  }
+  else {
+    mp3parse->partialbuf = buf;
+  }
+
+  size = GST_BUFFER_SIZE(mp3parse->partialbuf);
+  data = GST_BUFFER_DATA(mp3parse->partialbuf);
+
+  // while we still have bytes left -4 for the header
+  while (offset < size-4) {
+    int skipped = 0;
+
+    GST_DEBUG (0,"mp3parse: offset %ld, size %ld \n",offset, size);
+
+    // search for a possible start byte
+    for (;((data[offset] != 0xff) && (offset < size));offset++) skipped++;
+    if (skipped && !mp3parse->in_flush) {
+      GST_DEBUG (0,"mp3parse: **** now at %ld skipped %d bytes\n",offset,skipped);
+    }
+    // construct the header word
+    header = GULONG_FROM_BE(*((gulong *)(data+offset)));
+    // if it's a valid header, go ahead and send off the frame
+    if (head_check(header)) {
+      // calculate the bpf of the frame
+      bpf = bpf_from_header(mp3parse, header);
+
+      /********************************************************************************
+      * robust seek support
+      * - This performs additional frame validation if the in_flush flag is set
+      *   (indicating a discontinuous stream).
+      * - The current frame header is not accepted as valid unless the NEXT frame
+      *   header has the same values for most fields.  This significantly increases
+      *   the probability that we aren't processing random data.
+      * - It is not clear if this is sufficient for robust seeking of Layer III
+      *   streams which utilize the concept of a "bit reservoir" by borrow bitrate
+      *   from previous frames.  In this case, seeking may be more complicated because
+      *   the frames are not independently coded.
+      ********************************************************************************/
+      if ( mp3parse->in_flush ) {
+        unsigned long header2;
+
+        if ((size-offset)<(bpf+4)) { if (mp3parse->in_flush) break; } // wait until we have the the entire current frame as well as the next frame header
+
+        header2 = GULONG_FROM_BE(*((gulong *)(data+offset+bpf)));
+        GST_DEBUG(0,"mp3parse: header=%08lX, header2=%08lX, bpf=%d\n", header, header2, bpf );
+
+        #define HDRMASK ~( (0xF<<12)/*bitrate*/ | (1<<9)/*padding*/ | (3<<4)/*mode extension*/ ) // mask the bits which are allowed to differ between frames
+
+        if ( (header2&HDRMASK) != (header&HDRMASK) ) { // require 2 matching headers in a row
+           GST_DEBUG(0,"mp3parse: next header doesn't match (header=%08lX, header2=%08lX, bpf=%d)\n", header, header2, bpf );
+           offset++; // This frame is invalid.  Start looking for a valid frame at the next position in the stream
+           continue;
+        }
+
+      }
+
+      // if we don't have the whole frame...
+      if ((size - offset) < bpf) {
+        GST_DEBUG (0,"mp3parse: partial buffer needed %ld < %d \n",(size-offset), bpf);
+	break;
+      } else {
+
+        outbuf = gst_buffer_create_sub(mp3parse->partialbuf,offset,bpf);
+
+        offset += bpf;
+	if (mp3parse->skip == 0) {
+          GST_DEBUG (0,"mp3parse: pushing buffer of %d bytes\n",GST_BUFFER_SIZE(outbuf));
+	  if (mp3parse->in_flush) {
+	    GST_BUFFER_FLAG_SET(outbuf, GST_BUFFER_FLUSH);
+	    mp3parse->in_flush = FALSE;
+	  }
+	  else {
+	    GST_BUFFER_FLAG_UNSET(outbuf, GST_BUFFER_FLUSH);
+	  }
+	  GST_BUFFER_TIMESTAMP(outbuf) = last_ts;
+          gst_pad_push(mp3parse->srcpad,outbuf);
+	}
+	else {
+          GST_DEBUG (0,"mp3parse: skipping buffer of %d bytes\n",GST_BUFFER_SIZE(outbuf));
+          gst_buffer_unref(outbuf);
+	  mp3parse->skip--;
+	}
+      }
+    } else {
+      offset++;
+      if (!mp3parse->in_flush) GST_DEBUG (0,"mp3parse: *** wrong header, skipping byte (FIXME?)\n");
+    }
+  }
+  // if we have processed this block and there are still
+  // bytes left not in a partial block, copy them over.
+  if (size-offset > 0) {
+    glong remainder = (size - offset);
+    GST_DEBUG (0,"mp3parse: partial buffer needed %ld for trailing bytes\n",remainder);
+
+    outbuf = gst_buffer_create_sub(mp3parse->partialbuf,offset,remainder);
+    gst_buffer_unref(mp3parse->partialbuf);
+    mp3parse->partialbuf = outbuf;
+  }
+  else {
+    gst_buffer_unref(mp3parse->partialbuf);
+    mp3parse->partialbuf = NULL;
+  }
+}
+
+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;
+  long bpf;
+
+  //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;
+
+  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;
+  }
+
+  //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;
+}
+
+static gboolean
+head_check (unsigned long head)
+{
+  GST_DEBUG (0,"checking mp3 header 0x%08lx\n",head);
+  /* if it's not a valid sync */
+  if ((head & 0xffe00000) != 0xffe00000) {
+    GST_DEBUG (0,"invalid sync\n");return FALSE; }
+  /* if it's an invalid MPEG version */
+  if (((head >> 19) & 3) == 0x1) {
+    GST_DEBUG (0,"invalid MPEG version\n");return FALSE; }
+  /* if it's an invalid layer */
+  if (!((head >> 17) & 3)) {
+    GST_DEBUG (0,"invalid layer\n");return FALSE; }
+  /* if it's an invalid bitrate */
+  if (((head >> 12) & 0xf) == 0x0) {
+    GST_DEBUG (0,"invalid bitrate\n");return FALSE; }
+  if (((head >> 12) & 0xf) == 0xf) {
+    GST_DEBUG (0,"invalid bitrate\n");return FALSE; }
+  /* if it's an invalid samplerate */
+  if (((head >> 10) & 0x3) == 0x3) {
+    GST_DEBUG (0,"invalid samplerate\n");return FALSE; }
+  if ((head & 0xffff0000) == 0xfffe0000) { 
+    GST_DEBUG (0,"invalid sync\n");return FALSE; }
+  if (head & 0x00000002) {
+        GST_DEBUG (0,"invalid emphasis\n");return FALSE; }
+
+  return TRUE;
+}
+
+static void
+gst_mp3parse_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstMPEGAudioParse *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_MP3PARSE(object));
+  src = GST_MP3PARSE(object);
+
+  switch (prop_id) {
+    case ARG_SKIP:
+      src->skip = g_value_get_int (value);
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+gst_mp3parse_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstMPEGAudioParse *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_MP3PARSE(object));
+  src = GST_MP3PARSE(object);
+
+  switch (prop_id) {
+    case ARG_SKIP:
+      g_value_set_int (value, src->skip);
+      break;
+    case ARG_BIT_RATE:
+      g_value_set_int (value, src->bit_rate * 1000);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* create an elementfactory for the mp3parse element */
+  factory = gst_elementfactory_new ("mp3parse",
+		                    GST_TYPE_MP3PARSE,
+                                    &mp3parse_details);
+  g_return_val_if_fail (factory != NULL, FALSE);
+
+  sink_temp = mp3_sink_factory ();
+  gst_elementfactory_add_padtemplate (factory, sink_temp);
+
+  src_temp = mp3_src_factory ();
+  gst_elementfactory_add_padtemplate (factory, src_temp);
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "mp3parse",
+  plugin_init
+};
diff --git a/gst/mpegaudioparse/gstmpegaudioparse.h b/gst/mpegaudioparse/gstmpegaudioparse.h
new file mode 100644
index 00000000..fbd1047e
--- /dev/null
+++ b/gst/mpegaudioparse/gstmpegaudioparse.h
@@ -0,0 +1,71 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 __MP3PARSE_H__
+#define __MP3PARSE_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_MP3PARSE \
+  (gst_mp3parse_get_type())
+#define GST_MP3PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MP3PARSE,GstMPEGAudioParse))
+#define GST_MP3PARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MP3PARSE,GstMPEGAudioParse))
+#define GST_IS_MP3PARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MP3PARSE))
+#define GST_IS_MP3PARSE_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MP3PARSE))
+
+typedef struct _GstMPEGAudioParse GstMPEGAudioParse;
+typedef struct _GstMPEGAudioParseClass GstMPEGAudioParseClass;
+
+struct _GstMPEGAudioParse {
+  GstElement element;
+
+  GstPad *sinkpad,*srcpad;
+
+  GstBuffer *partialbuf;	// previous buffer (if carryover)
+  guint skip; /* number of frames to skip */
+  guint bit_rate;
+  gboolean in_flush;
+};
+
+struct _GstMPEGAudioParseClass {
+  GstElementClass parent_class;
+};
+
+GType gst_mp3parse_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __MP3PARSE_H__ */
diff --git a/gst/passthrough/.gitignore b/gst/passthrough/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/passthrough/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/passthrough/Makefile.am b/gst/passthrough/Makefile.am
new file mode 100644
index 00000000..500d4679
--- /dev/null
+++ b/gst/passthrough/Makefile.am
@@ -0,0 +1,10 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstpassthrough.la
+
+libgstpassthrough_la_SOURCES = gstpassthrough.c
+libgstpassthrough_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstpassthrough.h filter.func
+
+EXTRA_DIST = 
diff --git a/gst/passthrough/filter.func b/gst/passthrough/filter.func
new file mode 100644
index 00000000..99a9308b
--- /dev/null
+++ b/gst/passthrough/filter.func
@@ -0,0 +1,18 @@
+{
+  guint j;
+  static long int sample = 0;	/* you can use this to count samples */
+
+  /*
+   * process data here  
+   * *data contains the original 8 or 16 bit samples and is modified in place
+   * channels are interleaved in input data
+   */
+  
+  /* do nothing */
+  
+  for (j = 0; j < num_samples; j++) 
+  {
+     data[j] = data[j];
+  }
+  sample += num_samples;
+}
diff --git a/gst/passthrough/gstpassthrough.c b/gst/passthrough/gstpassthrough.c
new file mode 100644
index 00000000..dc50e626
--- /dev/null
+++ b/gst/passthrough/gstpassthrough.c
@@ -0,0 +1,351 @@
+/* -*- c-basic-offset: 2 -*-
+ * GStreamer
+ * Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <gst/gst.h>
+#include <libs/audio/gstaudio.h>
+#include "gstpassthrough.h"
+
+
+
+static GstElementDetails passthrough_details = {
+  "Passthrough",
+  "Filter/Effect",
+  "Transparent filter for audio/raw (boilerplate for effects)",
+  VERSION,
+  "Thomas <thomas@apestaart.org>, "\
+  "Andy Wingo <apwingo@eos.ncsu.edu>",
+  "(C) 2001",
+};
+
+
+/* Filter signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_SILENT
+};
+
+static GstPadTemplate*                    
+passthrough_sink_factory (void)            
+{                                         
+  static GstPadTemplate *template = NULL; 
+                                          
+  if (!template) {                        
+    template = gst_padtemplate_new 
+      ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
+      gst_caps_append(gst_caps_new ("sink_int",  "audio/raw",
+                                    GST_AUDIO_INT_PAD_TEMPLATE_PROPS),
+                      gst_caps_new ("sink_float", "audio/raw",
+                                    GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS)),
+      NULL);
+  }                                       
+  return template;                        
+}
+
+static GstPadTemplate*
+passthrough_src_factory (void)
+{
+  static GstPadTemplate *template = NULL;
+  
+  if (!template)
+    template = gst_padtemplate_new 
+      ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
+       gst_caps_append (gst_caps_new ("src_float", "audio/raw",
+                                      GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS),
+                        gst_caps_new ("src_int", "audio/raw",
+                                      GST_AUDIO_INT_PAD_TEMPLATE_PROPS)),
+       NULL);
+  
+  return template;
+}
+
+static void		passthrough_class_init		(GstPassthroughClass *klass);
+static void		passthrough_init		(GstPassthrough *filter);
+
+static void		passthrough_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void		passthrough_get_property        (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static gint             passthrough_parse_caps          (GstPassthrough *filter, GstCaps *caps);
+
+static void		passthrough_chain               (GstPad *pad, GstBuffer *buf);
+static void inline 	passthrough_fast_float_chain 	(gfloat* data, guint numsamples);
+static void inline 	passthrough_fast_16bit_chain 	(gint16* data, guint numsamples);
+static void inline 	passthrough_fast_8bit_chain     (gint8* data, guint numsamples);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_filter_signals[LAST_SIGNAL] = { 0 };
+
+static GstBufferPool*
+passthrough_get_bufferpool (GstPad *pad)
+{
+  GstPassthrough *filter;
+
+  filter = GST_PASSTHROUGH (gst_pad_get_parent (pad));
+
+  return gst_pad_get_bufferpool (filter->srcpad);
+}
+
+static GstPadNegotiateReturn
+passthrough_negotiate_src (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstPassthrough* filter = GST_PASSTHROUGH (gst_pad_get_parent (pad));
+  
+  if (*caps==NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  if (passthrough_parse_caps(filter, *caps))
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad,filter->sinkpad,caps);
+}
+
+static GstPadNegotiateReturn
+passthrough_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstPassthrough* filter = GST_PASSTHROUGH (gst_pad_get_parent (pad));
+  
+  if (*caps==NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  if (passthrough_parse_caps(filter, *caps))
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad,filter->srcpad,caps);
+}	
+
+static gint
+passthrough_parse_caps (GstPassthrough *filter, GstCaps *caps)
+{
+  const gchar *format;
+  
+  g_return_val_if_fail(filter!=NULL,-1);
+  g_return_val_if_fail(caps!=NULL,-1);
+  
+  format = gst_caps_get_string(caps, "format");
+  
+  filter->rate       = gst_caps_get_int (caps, "rate");
+  filter->channels   = gst_caps_get_int (caps, "channels");
+  
+  if (strcmp(format, "int")==0) {
+    filter->format        = GST_PASSTHROUGH_FORMAT_INT;
+    filter->width         = gst_caps_get_int (caps, "width");
+    filter->depth         = gst_caps_get_int (caps, "depth");
+    filter->law           = gst_caps_get_int (caps, "law");
+    filter->endianness    = gst_caps_get_int (caps, "endianness");
+    filter->is_signed     = gst_caps_get_int (caps, "signed");
+    if (!filter->silent) {
+      g_print ("Passthrough : channels %d, rate %d\n",  
+               filter->channels, filter->rate);
+      g_print ("Passthrough : format int, bit width %d, endianness %d, signed %s\n",
+               filter->width, filter->endianness, filter->is_signed ? "yes" : "no");
+    }
+  } else if (strcmp(format, "float")==0) {
+    filter->format     = GST_PASSTHROUGH_FORMAT_FLOAT;
+    filter->layout     = gst_caps_get_string(caps, "layout");
+    filter->intercept  = gst_caps_get_float(caps, "intercept");
+    filter->slope      = gst_caps_get_float(caps, "slope");
+    if (!filter->silent) {
+      g_print ("Passthrough : channels %d, rate %d\n",  
+               filter->channels, filter->rate);
+      g_print ("Passthrough : format float, layout %s, intercept %f, slope %f\n",
+               filter->layout, filter->intercept, filter->slope);
+    }
+  } else  {
+    return -1;
+  }
+  return 0;
+}
+
+
+GType
+gst_passthrough_get_type(void) {
+  static GType passthrough_type = 0;
+
+  if (!passthrough_type) {
+    static const GTypeInfo passthrough_info = {
+      sizeof(GstPassthroughClass),      NULL,
+      NULL,
+      (GClassInitFunc)passthrough_class_init,
+      NULL,
+      NULL,
+      sizeof(GstPassthrough),
+      0,
+      (GInstanceInitFunc)passthrough_init,
+    };
+    passthrough_type = g_type_register_static(GST_TYPE_ELEMENT, "GstPassthrough", &passthrough_info, 0);
+  }
+  return passthrough_type;
+}
+
+static void
+passthrough_class_init (GstPassthroughClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SILENT,
+    g_param_spec_boolean("silent","silent","silent",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+
+  gobject_class->set_property = passthrough_set_property;
+  gobject_class->get_property = passthrough_get_property;
+}
+
+static void
+passthrough_init (GstPassthrough *filter)
+{
+  filter->sinkpad = gst_pad_new_from_template(passthrough_sink_factory (),"sink");
+  gst_pad_set_negotiate_function(filter->sinkpad,passthrough_negotiate_sink);
+  gst_pad_set_bufferpool_function(filter->sinkpad,passthrough_get_bufferpool);
+  filter->srcpad = gst_pad_new_from_template(passthrough_src_factory (),"src");
+  gst_pad_set_negotiate_function(filter->srcpad,passthrough_negotiate_src);
+  
+  gst_element_add_pad(GST_ELEMENT(filter),filter->sinkpad);
+  gst_element_add_pad(GST_ELEMENT(filter),filter->srcpad);
+  gst_pad_set_chain_function(filter->sinkpad,passthrough_chain);
+  filter->silent = FALSE;
+}
+
+static void
+passthrough_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstPassthrough *filter;
+  gint16 *int_data;
+  gfloat *float_data;
+  
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+  
+  filter = GST_PASSTHROUGH(GST_OBJECT_PARENT (pad));
+  g_return_if_fail(filter != NULL);
+  g_return_if_fail(GST_IS_PASSTHROUGH(filter));
+  
+  switch (filter->format) {
+  case GST_PASSTHROUGH_FORMAT_INT:
+    int_data = (gint16 *)GST_BUFFER_DATA(buf);
+
+    switch (filter->width) {
+    case 16:
+      passthrough_fast_16bit_chain(int_data,GST_BUFFER_SIZE(buf)/2);
+      break;
+    case 8:
+      passthrough_fast_8bit_chain((gint8*)int_data,GST_BUFFER_SIZE(buf));
+      break;
+    }
+
+    break;
+  case GST_PASSTHROUGH_FORMAT_FLOAT:
+    float_data = (gfloat *)GST_BUFFER_DATA(buf);
+    
+    passthrough_fast_float_chain(float_data,GST_BUFFER_SIZE(buf)/sizeof(float));
+    
+    break;
+  }
+  
+  gst_pad_push(filter->srcpad,buf);
+}
+
+static void inline
+passthrough_fast_float_chain(gfloat* data,
+			         guint num_samples)
+#include "filter.func"
+
+static void inline
+passthrough_fast_16bit_chain(gint16* data,
+			         guint num_samples)
+#include "filter.func"
+
+static void inline
+passthrough_fast_8bit_chain(gint8* data,
+                                guint num_samples)
+#include "filter.func"
+
+static void
+passthrough_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstPassthrough *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_PASSTHROUGH(object));
+  filter = GST_PASSTHROUGH(object);
+
+  switch (prop_id) 
+  {
+    case ARG_SILENT:
+      filter->silent = g_value_get_boolean (value);
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+passthrough_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstPassthrough *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_PASSTHROUGH(object));
+  filter = GST_PASSTHROUGH(object);
+
+  switch (prop_id) {
+    case ARG_SILENT:
+      g_value_set_boolean (value, filter->silent);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  factory = gst_elementfactory_new("passthrough",GST_TYPE_PASSTHROUGH,
+                                   &passthrough_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+  
+  gst_elementfactory_add_padtemplate (factory, passthrough_src_factory ());
+  gst_elementfactory_add_padtemplate (factory, passthrough_sink_factory ());
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "passthrough",
+  plugin_init
+};
diff --git a/gst/passthrough/gstpassthrough.h b/gst/passthrough/gstpassthrough.h
new file mode 100644
index 00000000..d8c2f63e
--- /dev/null
+++ b/gst/passthrough/gstpassthrough.h
@@ -0,0 +1,103 @@
+/* -*- c-basic-offset: 2 -*-
+ * GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_PASSTHROUGH_H__
+#define __GST_PASSTHROUGH_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+// #include <gst/meta/audioraw.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_PASSTHROUGH \
+  (gst_passthrough_get_type())
+#define GST_PASSTHROUGH(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PASSTHROUGH,GstPassthrough))
+#define GST_PASSTHROUGH_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstPassthrough))
+#define GST_IS_PASSTHROUGH(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PASSTHROUGH))
+#define GST_IS_PASSTHROUGH_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PASSTHROUGH))
+
+typedef struct _GstPassthrough GstPassthrough;
+typedef struct _GstPassthroughClass GstPassthroughClass;
+typedef enum _GstPassthroughFormat GstPassthroughFormat;
+
+enum _GstPassthroughFormat {
+  GST_PASSTHROUGH_FORMAT_INT,
+  GST_PASSTHROUGH_FORMAT_FLOAT
+};
+
+struct _GstPassthrough {
+  GstElement element;
+
+  GstPad *sinkpad, *srcpad;
+
+  gboolean silent;
+  
+  /* the next three are valid for both int and float */
+  
+  GstPassthroughFormat format;
+  
+  guint rate;
+  
+  guint channels;
+  
+  /* the next five are valid only for format==GST_PASSTHROUGH_FORMAT_INT */
+  
+  guint width;
+  
+  guint depth;
+
+  guint endianness;
+  
+  guint law;
+  
+  gboolean is_signed;
+  
+  /* the next three are valid only for format==GST_PASSTHROUGH_FORMAT_FLOAT */
+  
+  const gchar *layout;
+  
+  gfloat slope;
+  
+  gfloat intercept;
+};
+
+struct _GstPassthroughClass {
+  GstElementClass parent_class;
+};
+
+GType gst_passthrough_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_PASSTHROUGH_H__ */
diff --git a/gst/playondemand/Makefile.am b/gst/playondemand/Makefile.am
new file mode 100644
index 00000000..fc2b93b9
--- /dev/null
+++ b/gst/playondemand/Makefile.am
@@ -0,0 +1,10 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstplayondemand.la
+
+libgstplayondemand_la_SOURCES = gstplayondemand.c
+libgstplayondemand_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstplayondemand.h filter.func
+
+# EXTRA_DIST = README
diff --git a/gst/playondemand/filter.func b/gst/playondemand/filter.func
new file mode 100644
index 00000000..6f81c975
--- /dev/null
+++ b/gst/playondemand/filter.func
@@ -0,0 +1,120 @@
+/* -*- C -*- */
+
+_TYPE_ *data_in, *data_out, *filter_data;
+
+filter_data = (_TYPE_ *) filter->buffer;
+num_filter = filter->buffer_size / sizeof(_TYPE_);
+
+/******************************************************************************/
+/* see if we've got any events coming through ... */
+
+do {
+  GST_DEBUG(0, "--- going to events\n");
+
+  while (! filter->eos && GST_IS_EVENT(in)) {
+    if (GST_EVENT_TYPE(in) == GST_EVENT_EOS) {
+      filter->eos = TRUE;
+    } else {
+      gst_pad_push(filter->srcpad, in);
+    }
+
+    in = gst_pad_pull(filter->sinkpad);
+  }
+
+  /******************************************************************************/
+  /* first handle data from the input buffer. */
+
+  GST_DEBUG(0, "--- done with events, going to input\n");
+
+  /* only update the input if there hasn't been an eos yet. */
+  if (! filter->eos) {
+    data_in = (_TYPE_ *) GST_BUFFER_DATA(in);
+    num_in = GST_BUFFER_SIZE(in) / sizeof(_TYPE_);
+
+    w = filter->write;
+
+    /* copy the input data to the filter's internal buffer. */
+    if (filter->follow_stream_tail) {
+      for (j = 0; j < num_in; j++) {
+        filter_data[(w + j) % num_filter] = data_in[j];
+      }
+
+      filter->write = (w + j) % num_filter;
+      
+      /* update the start pointer */
+      if ((filter->start != 0) || ((w + j) >= num_filter)) {
+        filter->start = (filter->write + 1) % num_filter;
+      }
+    } else {
+      for (j = 0; (j < num_in) && ((w + j) < num_filter); j++) {
+        filter_data[w + j] = data_in[j];
+      }
+
+      filter->write += j;
+
+      /* if we're not following the stream tail, the buffer is just a straight
+         buffer. so we need to set eos if we've passed the limit of the internal
+         buffer size. */
+      if ((w + j) >= num_filter) {
+        filter->eos = TRUE;
+      }
+    }
+
+    out = in;
+  } else {
+    j = 0;
+
+    if (filter->srcpool) {
+      out = gst_buffer_new_from_pool(filter->srcpool, 0, 0);
+    } else {
+      out = gst_buffer_new();
+  
+      GST_BUFFER_DATA(out) = (gchar *) g_new(_TYPE_, POD_GSTBUFSIZE / sizeof(_TYPE_));
+      GST_BUFFER_SIZE(out) = POD_GSTBUFSIZE;
+    }
+  }
+
+  /******************************************************************************/
+  /* now handle output data. */
+
+  GST_DEBUG(0, "--- done with input, going to output\n");
+
+  data_out = (_TYPE_ *) GST_BUFFER_DATA(out);
+  num_out = GST_BUFFER_SIZE(out) / sizeof(_TYPE_);
+
+  for (k = 0; k < num_out; k++) {
+    data_out[k] = zero;
+  }
+  
+  /* output play pointer data. */
+  for (t = 0; t < POD_MAX_PLAYS; t++) {
+    offset = filter->plays[t];
+
+    if (offset != G_MAXUINT) {
+      if (filter->follow_stream_tail) {
+        for (k = 0; k < num_out; k++) {
+          data_out[k] = CLAMP(data_out[k] + filter_data[(offset + k) % num_filter], min, max);
+        }
+      } else {
+        for (k = 0; (k < num_out) && ((offset + k) < (w + j)); k++) {
+          data_out[k] = CLAMP(data_out[k] + filter_data[offset + k], min, max);
+        }
+      }
+
+      if ((offset < w) && ((offset + k) >= (w + j))) {
+        filter->plays[t] = G_MAXUINT;
+      } else {
+        filter->plays[t] = (filter->plays[t] + k) % num_filter;
+      }
+    }
+  }
+
+  GST_DEBUG(0, "--- done with output, pushing buffer %p\n", out);
+
+  gst_pad_push(filter->srcpad, out);
+
+  if (! filter->eos) {
+    in = gst_pad_pull(filter->sinkpad);
+  }
+
+} while (! GST_ELEMENT_IS_COTHREAD_STOPPING(elem));
diff --git a/gst/playondemand/gstplayondemand.c b/gst/playondemand/gstplayondemand.c
new file mode 100644
index 00000000..9d2ebff3
--- /dev/null
+++ b/gst/playondemand/gstplayondemand.c
@@ -0,0 +1,448 @@
+/* GStreamer
+ * Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <gst/gst.h>
+#include <libs/audio/gstaudio.h>
+#include "gstplayondemand.h"
+
+
+#define POD_MAX_PLAYS     192     /* maximum number of simultaneous plays */
+#define POD_GSTBUFSIZE    4096    /* gstreamer buffer size to make if no
+                                     bufferpool is available, must be divisible
+                                     by sizeof(gfloat) */
+#define POD_BUFSPERCHUNK  6       /* number of buffers to allocate per chunk in
+                                     sink buffer pool */
+#define POD_BUFFER_SIZE   882000  /* enough space for 10 seconds of 16-bit audio
+                                     at 44100 samples per second ... */
+
+static GstElementDetails play_on_demand_details = {
+  "Play On Demand",
+  "Filter/Effect",
+  "Plays a stream whenever it receives a certain signal",
+  VERSION,
+  "Leif Morgan Johnson <lmjohns3@eos.ncsu.edu>",
+  "(C) 2001",
+};
+
+
+/* Filter signals and args */
+enum {
+  /* FILL ME */
+  PLAY_SIGNAL,
+  RESET_SIGNAL,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_SILENT,
+  ARG_FOLLOWTAIL,
+  ARG_BUFFERSIZE
+};
+
+static GstPadTemplate*                    
+play_on_demand_sink_factory (void)            
+{                                         
+  static GstPadTemplate *template = NULL; 
+                                          
+  if (!template) {                        
+    template = gst_padtemplate_new 
+      ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
+      gst_caps_append(gst_caps_new ("sink_int",  "audio/raw",
+                                    GST_AUDIO_INT_PAD_TEMPLATE_PROPS),
+                      gst_caps_new ("sink_float", "audio/raw",
+                                    GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS)),
+      NULL);
+  }                                       
+  return template;                        
+}
+
+static GstPadTemplate*
+play_on_demand_src_factory (void)
+{
+  static GstPadTemplate *template = NULL;
+  
+  if (!template)
+    template = gst_padtemplate_new 
+      ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
+       gst_caps_append (gst_caps_new ("src_float", "audio/raw",
+                                      GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS),
+                        gst_caps_new ("src_int", "audio/raw",
+                                      GST_AUDIO_INT_PAD_TEMPLATE_PROPS)),
+       NULL);
+  
+  return template;
+}
+
+static void		play_on_demand_class_init	 (GstPlayOnDemandClass *klass);
+static void		play_on_demand_init		 (GstPlayOnDemand *filter);
+
+static void		play_on_demand_set_property	 (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void		play_on_demand_get_property      (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static gint             play_on_demand_parse_caps        (GstPlayOnDemand *filter, GstCaps *caps);
+
+static void		play_on_demand_loop              (GstElement *elem);
+
+static void             play_on_demand_play_handler      (GstElement *elem);
+static void             play_on_demand_reset_handler     (GstElement *elem);
+
+static GstElementClass *parent_class = NULL;
+static guint gst_pod_filter_signals[LAST_SIGNAL] = { 0 };
+
+static GstBufferPool*
+play_on_demand_get_bufferpool (GstPad *pad)
+{
+  GstPlayOnDemand *filter;
+
+  filter = GST_PLAYONDEMAND(gst_pad_get_parent(pad));
+
+  return gst_pad_get_bufferpool(filter->srcpad);
+}
+
+static GstPadNegotiateReturn
+play_on_demand_negotiate_src (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstPlayOnDemand* filter = GST_PLAYONDEMAND(gst_pad_get_parent(pad));
+  
+  if (*caps == NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  if (play_on_demand_parse_caps(filter, *caps))
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad, filter->sinkpad, caps);
+}
+
+static GstPadNegotiateReturn
+play_on_demand_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstPlayOnDemand* filter = GST_PLAYONDEMAND(gst_pad_get_parent(pad));
+  
+  if (*caps == NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  if (play_on_demand_parse_caps(filter, *caps))
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad, filter->srcpad, caps);
+}	
+
+static gint
+play_on_demand_parse_caps (GstPlayOnDemand *filter, GstCaps *caps)
+{
+  const gchar *format;
+  
+  g_return_val_if_fail(filter != NULL, -1);
+  g_return_val_if_fail(caps   != NULL, -1);
+  
+  format = gst_caps_get_string(caps, "format");
+  
+  filter->rate       = gst_caps_get_int(caps, "rate");
+  filter->channels   = gst_caps_get_int(caps, "channels");
+  
+  if (strcmp(format, "int") == 0) {
+    filter->format     = GST_PLAYONDEMAND_FORMAT_INT;
+    filter->width      = gst_caps_get_int(caps, "width");
+    filter->depth      = gst_caps_get_int(caps, "depth");
+    filter->law        = gst_caps_get_int(caps, "law");
+    filter->endianness = gst_caps_get_int(caps, "endianness");
+    filter->is_signed  = gst_caps_get_int(caps, "signed");
+    if (!filter->silent) {
+      g_print ("PlayOnDemand : channels %d, rate %d\n",  
+               filter->channels, filter->rate);
+      g_print ("PlayOnDemand : format int, bit width %d, endianness %d, signed %s\n",
+               filter->width, filter->endianness, filter->is_signed ? "yes" : "no");
+    }
+  } else if (strcmp(format, "float")==0) {
+    filter->format     = GST_PLAYONDEMAND_FORMAT_FLOAT;
+    filter->layout     = gst_caps_get_string(caps, "layout");
+    filter->intercept  = gst_caps_get_float(caps, "intercept");
+    filter->slope      = gst_caps_get_float(caps, "slope");
+    if (!filter->silent) {
+      g_print ("PlayOnDemand : channels %d, rate %d\n",  
+               filter->channels, filter->rate);
+      g_print ("PlayOnDemand : format float, layout %s, intercept %f, slope %f\n",
+               filter->layout, filter->intercept, filter->slope);
+    }
+  } else  {
+    return -1;
+  }
+  return 0;
+}
+
+
+GType
+gst_play_on_demand_get_type(void) {
+  static GType play_on_demand_type = 0;
+
+  if (! play_on_demand_type) {
+    static const GTypeInfo play_on_demand_info = {
+      sizeof(GstPlayOnDemandClass),
+      NULL,
+      NULL,
+      (GClassInitFunc) play_on_demand_class_init,
+      NULL,
+      NULL,
+      sizeof(GstPlayOnDemand),
+      0,
+      (GInstanceInitFunc) play_on_demand_init,
+    };
+    play_on_demand_type = g_type_register_static(GST_TYPE_ELEMENT, "GstPlayOnDemand", &play_on_demand_info, 0);
+  }
+  return play_on_demand_type;
+}
+
+static void
+play_on_demand_class_init (GstPlayOnDemandClass *klass)
+{
+  GObjectClass    *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class    = (GObjectClass *)    klass;
+  gstelement_class = (GstElementClass *) klass;
+
+  gst_pod_filter_signals[PLAY_SIGNAL] =
+    g_signal_new("play",
+                 G_TYPE_FROM_CLASS(klass),
+                 G_SIGNAL_RUN_LAST,
+                 G_STRUCT_OFFSET(GstPlayOnDemandClass, play),
+                 NULL, NULL,
+                 g_cclosure_marshal_VOID__VOID,
+                 G_TYPE_NONE, 0);
+
+  gst_pod_filter_signals[RESET_SIGNAL] =
+    g_signal_new("reset",
+                 G_TYPE_FROM_CLASS(klass),
+                 G_SIGNAL_RUN_LAST,
+                 G_STRUCT_OFFSET(GstPlayOnDemandClass, reset),
+                 NULL, NULL,
+                 g_cclosure_marshal_VOID__VOID,
+                 G_TYPE_NONE, 0);
+
+  klass->play  = play_on_demand_play_handler;
+  klass->reset = play_on_demand_reset_handler;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SILENT,
+    g_param_spec_boolean("silent","silent","silent",
+                         TRUE, G_PARAM_READWRITE)); // CHECKME
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FOLLOWTAIL,
+    g_param_spec_boolean("follow-stream-tail","follow-stream-tail","follow-stream-tail",
+                         FALSE, G_PARAM_READWRITE));
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BUFFERSIZE,
+    g_param_spec_uint("buffer-size","buffer-size","buffer-size",
+                      0, G_MAXUINT - 1, POD_BUFFER_SIZE, G_PARAM_READWRITE));
+
+  gobject_class->set_property = play_on_demand_set_property;
+  gobject_class->get_property = play_on_demand_get_property;
+}
+
+static void
+play_on_demand_init (GstPlayOnDemand *filter)
+{
+  guint i;
+  
+  filter->sinkpad = gst_pad_new_from_template(play_on_demand_sink_factory(), "sink");
+  gst_pad_set_negotiate_function(filter->sinkpad, play_on_demand_negotiate_sink);
+  gst_pad_set_bufferpool_function(filter->sinkpad, play_on_demand_get_bufferpool);
+
+  filter->srcpad = gst_pad_new_from_template(play_on_demand_src_factory(), "src");
+  gst_pad_set_negotiate_function(filter->srcpad, play_on_demand_negotiate_src);
+  
+  gst_element_add_pad(GST_ELEMENT(filter), filter->sinkpad);
+  gst_element_add_pad(GST_ELEMENT(filter), filter->srcpad);
+
+  gst_element_set_loop_function(GST_ELEMENT(filter), play_on_demand_loop);
+
+  filter->sinkpool = gst_buffer_pool_get_default(POD_GSTBUFSIZE, POD_BUFSPERCHUNK);
+
+  filter->follow_stream_tail = FALSE;  
+  filter->silent      = TRUE;
+
+  filter->buffer      = g_new(gchar, POD_BUFFER_SIZE);
+  filter->buffer_size = POD_BUFFER_SIZE;
+  filter->start       = 0;
+  filter->write       = 0;
+
+  filter->eos         = FALSE;
+
+  /* the plays are stored as an array of buffer offsets. this initializes the
+     array to `blank' values (G_MAXUINT is an invalid index for this filter). */
+  filter->plays  = g_new(guint, POD_MAX_PLAYS);
+  for (i = 0; i < POD_MAX_PLAYS; i++) {
+    filter->plays[i] = G_MAXUINT;
+  }
+}
+
+static void
+play_on_demand_loop (GstElement *elem)
+{
+  GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
+  guint            num_in, num_out, num_filter;
+  GstBuffer       *in, *out;
+  register guint   j, k, t;
+  guint            w, offset;
+  
+  g_return_if_fail(filter != NULL);
+  g_return_if_fail(GST_IS_PLAYONDEMAND(filter));
+
+  filter->srcpool = gst_pad_get_bufferpool(filter->srcpad);
+
+  in = gst_pad_pull(filter->sinkpad);
+
+  if (filter->format == GST_PLAYONDEMAND_FORMAT_INT) {
+    if (filter->width == 16) {
+      gint16 min = -32768;
+      gint16 max = 32767;
+      gint16 zero = 0;
+#define _TYPE_ gint16
+#include "filter.func"
+#undef _TYPE_
+    } else if (filter->width == 8) {
+      gint8 min = -128;
+      gint8 max = 127;
+      gint8 zero = 0;
+#define _TYPE_ gint8
+#include "filter.func"
+#undef _TYPE_
+    }
+  } else if (filter->format == GST_PLAYONDEMAND_FORMAT_FLOAT) {
+    gfloat min = -1.0;
+    gfloat max = 1.0;
+    gfloat zero = 0.0;
+#define _TYPE_ gfloat
+#include "filter.func"
+#undef _TYPE_
+  }
+}
+
+static void
+play_on_demand_play_handler(GstElement *elem)
+{
+  GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
+  register guint i;
+
+  for (i = 0; i < POD_MAX_PLAYS; i++) {
+    if (filter->plays[i] == G_MAXUINT) {
+      filter->plays[i] = filter->start;
+      break;
+    }
+  }
+}
+
+static void
+play_on_demand_reset_handler(GstElement *elem)
+{
+  GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
+  register guint i;
+  
+  for (i = 0; i < POD_MAX_PLAYS; i++) {
+    filter->plays[i] = G_MAXUINT;
+  }
+
+  filter->start = 0;
+  filter->write = 0;
+}
+
+static void
+play_on_demand_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstPlayOnDemand *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_PLAYONDEMAND(object));
+  filter = GST_PLAYONDEMAND(object);
+
+  switch (prop_id) {
+  case ARG_BUFFERSIZE:
+    filter->buffer_size = g_value_get_uint(value);
+
+    /* reallocate space for the buffer with the new size values. */
+    g_free(filter->buffer);
+    filter->buffer = g_new(gchar, filter->buffer_size);
+
+    /* reset the play pointers and read/write indexes. */
+    play_on_demand_reset_handler(GST_ELEMENT(filter));
+    break;
+  case ARG_SILENT:
+    filter->silent = g_value_get_boolean(value);
+    break;
+  case ARG_FOLLOWTAIL:
+    filter->follow_stream_tail = g_value_get_boolean(value);
+    play_on_demand_reset_handler(GST_ELEMENT(filter));
+    break;
+  default:
+    break;
+  }
+}
+
+static void
+play_on_demand_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstPlayOnDemand *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_PLAYONDEMAND(object));
+  filter = GST_PLAYONDEMAND(object);
+
+  switch (prop_id) {
+  case ARG_BUFFERSIZE:
+    g_value_set_uint(value, filter->buffer_size);
+    break;
+  case ARG_SILENT:
+    g_value_set_boolean(value, filter->silent);
+    break;
+  case ARG_FOLLOWTAIL:
+    g_value_set_boolean(value, filter->follow_stream_tail);
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  factory = gst_elementfactory_new("playondemand",
+                                   GST_TYPE_PLAYONDEMAND,
+                                   &play_on_demand_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+  
+  gst_elementfactory_add_padtemplate(factory, play_on_demand_src_factory());
+  gst_elementfactory_add_padtemplate(factory, play_on_demand_sink_factory());
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE(factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "playondemand",
+  plugin_init
+};
diff --git a/gst/playondemand/gstplayondemand.h b/gst/playondemand/gstplayondemand.h
new file mode 100644
index 00000000..7ca8206e
--- /dev/null
+++ b/gst/playondemand/gstplayondemand.h
@@ -0,0 +1,112 @@
+/* -*- c-basic-offset: 2 -*-
+ * GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_PLAYONDEMAND_H__
+#define __GST_PLAYONDEMAND_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+/* #include <gst/meta/audioraw.h> */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_PLAYONDEMAND \
+  (gst_play_on_demand_get_type())
+#define GST_PLAYONDEMAND(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PLAYONDEMAND,GstPlayOnDemand))
+#define GST_PLAYONDEMAND_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstPlayOnDemand))
+#define GST_IS_PLAYONDEMAND(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PLAYONDEMAND))
+#define GST_IS_PLAYONDEMAND_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PLAYONDEMAND))
+
+typedef struct _GstPlayOnDemand       GstPlayOnDemand;
+typedef struct _GstPlayOnDemandClass  GstPlayOnDemandClass;
+typedef enum   _GstPlayOnDemandFormat GstPlayOnDemandFormat;
+
+enum _GstPlayOnDemandFormat {
+  GST_PLAYONDEMAND_FORMAT_INT,
+  GST_PLAYONDEMAND_FORMAT_FLOAT
+};
+
+struct _GstPlayOnDemand {
+  GstElement element;
+
+  GstPad *sinkpad, *srcpad;
+  GstBufferPool *sinkpool, *srcpool;
+
+  /* these next data elements are for the filter's internal buffers and list of
+     play pointers (offsets in the internal buffers). there are also flags for
+     repeating from the beginning or end of the input stream, and a max buffer
+     size. */
+  gchar    *buffer;
+  guint     buffer_size;
+
+  guint     write;
+  guint     start;
+
+  guint    *plays;
+
+  gboolean  eos;
+
+  gboolean  follow_stream_tail;
+  
+  gboolean  silent;
+  
+  /* the next three are valid for both int and float */
+  GstPlayOnDemandFormat format;
+  guint                 rate;
+  guint                 channels;
+  
+  /* the next five are valid only for format == GST_PLAYONDEMAND_FORMAT_INT */
+  guint    width;
+  guint    depth;
+  guint    endianness;
+  guint    law;
+  gboolean is_signed;
+  
+  /* the next three are valid only for format == GST_PLAYONDEMAND_FORMAT_FLOAT */
+  const gchar *layout;
+  gfloat       slope;
+  gfloat       intercept;
+};
+
+struct _GstPlayOnDemandClass {
+  GstElementClass parent_class;
+
+  void (*play)  (GstElement *elem);
+  void (*reset) (GstElement *elem);
+};
+
+GType gst_play_on_demand_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_PLAYONDEMAND_H__ */
diff --git a/gst/rtjpeg/.gitignore b/gst/rtjpeg/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/rtjpeg/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/rtjpeg/Makefile.am b/gst/rtjpeg/Makefile.am
new file mode 100644
index 00000000..157ac760
--- /dev/null
+++ b/gst/rtjpeg/Makefile.am
@@ -0,0 +1,8 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstrtjpeg.la
+
+libgstrtjpeg_la_SOURCES = gstrtjpeg.c rtjpegenc.c rtjpegdec.c RTjpeg.c
+libgstrtjpeg_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstrtjpegenc.h gstrtjpegdec.h RTjpeg.h
diff --git a/gst/rtjpeg/README b/gst/rtjpeg/README
new file mode 100644
index 00000000..34796867
--- /dev/null
+++ b/gst/rtjpeg/README
@@ -0,0 +1,12 @@
+This plugin contains elements necessary for doing RTjpeg compression and
+decompression, as well as conversion from RGB to YUV and back, based
+entirely on functions supplied by RTjpeg.c.
+
+You can find RTjpeg at Justin Schoeman's site:
+http://www.ee.up.ac.za/~justin/bttv/
+
+The idea is to start out with the code elements reading and writing YUV420
+images, with external elements to do the conversion.  Eventually (when
+typing is a bit more sane/globally used) the codec elements will
+automatically convert images to/from the proper format based on what their
+peer wants to be dealing with.
diff --git a/gst/rtjpeg/RTjpeg.c b/gst/rtjpeg/RTjpeg.c
new file mode 100644
index 00000000..38d3ce12
--- /dev/null
+++ b/gst/rtjpeg/RTjpeg.c
@@ -0,0 +1,3434 @@
+/* 
+    This program is free software; you can redristibute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   This file is a modified version of RTjpeg 0.1.2, (C) Justin Schoeman 1998
+
+   (991101) Wim Taymans : added MMX dct and idct from intels site.
+*/
+
+
+/*
+
+Main Routines
+
+This file contains most of the initialisation and control functions
+
+(C) Justin Schoeman 1998
+
+*/
+
+#include <config.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef unsigned char __u8;
+typedef signed char __s8;
+typedef unsigned short __u16;
+typedef signed short __s16;
+typedef unsigned long __u32;
+typedef signed long __s32;
+typedef unsigned long long __u64;
+
+//#define MMX_TRACE
+
+
+#ifdef HAVE_LIBMMX
+#include "mmx.h"
+#endif
+
+static const unsigned char RTjpeg_ZZ[64]={
+0,
+8, 1,
+2, 9, 16,
+24, 17, 10, 3,
+4, 11, 18, 25, 32,
+40, 33, 26, 19, 12, 5,
+6, 13, 20, 27, 34, 41, 48,
+56, 49, 42, 35, 28, 21, 14, 7,
+15, 22, 29, 36, 43, 50, 57,
+58, 51, 44, 37, 30, 23,
+31, 38, 45, 52, 59,
+60, 53, 46, 39,
+47, 54, 61,
+62, 55,
+63 };
+
+static const __u64 RTjpeg_aan_tab[64]={
+4294967296ULL, 5957222912ULL, 5611718144ULL, 5050464768ULL, 4294967296ULL, 3374581504ULL, 2324432128ULL, 1184891264ULL, 
+5957222912ULL, 8263040512ULL, 7783580160ULL, 7005009920ULL, 5957222912ULL, 4680582144ULL, 3224107520ULL, 1643641088ULL, 
+5611718144ULL, 7783580160ULL, 7331904512ULL, 6598688768ULL, 5611718144ULL, 4408998912ULL, 3036936960ULL, 1548224000ULL, 
+5050464768ULL, 7005009920ULL, 6598688768ULL, 5938608128ULL, 5050464768ULL, 3968072960ULL, 2733115392ULL, 1393296000ULL, 
+4294967296ULL, 5957222912ULL, 5611718144ULL, 5050464768ULL, 4294967296ULL, 3374581504ULL, 2324432128ULL, 1184891264ULL, 
+3374581504ULL, 4680582144ULL, 4408998912ULL, 3968072960ULL, 3374581504ULL, 2651326208ULL, 1826357504ULL, 931136000ULL, 
+2324432128ULL, 3224107520ULL, 3036936960ULL, 2733115392ULL, 2324432128ULL, 1826357504ULL, 1258030336ULL, 641204288ULL, 
+1184891264ULL, 1643641088ULL, 1548224000ULL, 1393296000ULL, 1184891264ULL, 931136000ULL, 641204288ULL, 326894240ULL, 
+};
+
+#ifndef HAVE_LIBMMX
+static __s32 RTjpeg_ws[64+31];
+#endif
+__u8 RTjpeg_alldata[2*64+4*64+4*64+4*64+4*64+32];
+
+__s16 *RTjpeg_block;
+__s32 *RTjpeg_lqt;
+__s32 *RTjpeg_cqt;
+__u32 *RTjpeg_liqt;
+__u32 *RTjpeg_ciqt;
+
+unsigned char RTjpeg_lb8;
+unsigned char RTjpeg_cb8;
+int RTjpeg_width, RTjpeg_height;
+int RTjpeg_Ywidth, RTjpeg_Cwidth;
+int RTjpeg_Ysize, RTjpeg_Csize;
+
+__s16 *RTjpeg_old=NULL;
+
+#ifdef HAVE_LIBMMX
+mmx_t RTjpeg_lmask;
+mmx_t RTjpeg_cmask;
+#else
+__u16 RTjpeg_lmask;
+__u16 RTjpeg_cmask;
+#endif
+int RTjpeg_mtest=0;
+
+static const unsigned char RTjpeg_lum_quant_tbl[64] = {
+    16,  11,  10,  16,  24,  40,  51,  61,
+    12,  12,  14,  19,  26,  58,  60,  55,
+    14,  13,  16,  24,  40,  57,  69,  56,
+    14,  17,  22,  29,  51,  87,  80,  62,
+    18,  22,  37,  56,  68, 109, 103,  77,
+    24,  35,  55,  64,  81, 104, 113,  92,
+    49,  64,  78,  87, 103, 121, 120, 101,
+    72,  92,  95,  98, 112, 100, 103,  99
+ };
+
+static const unsigned char RTjpeg_chrom_quant_tbl[64] = {
+    17,  18,  24,  47,  99,  99,  99,  99,
+    18,  21,  26,  66,  99,  99,  99,  99,
+    24,  26,  56,  99,  99,  99,  99,  99,
+    47,  66,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99
+ };
+ 
+int RTjpeg_b2s(__s16 *data, __s8 *strm, __u8 bt8)
+{
+ register int ci, co=1, tmp;
+ register __s16 ZZvalue;
+
+ (__u8)strm[0]=(__u8)(data[RTjpeg_ZZ[0]]>254) ? 254:((data[RTjpeg_ZZ[0]]<0)?0:data[RTjpeg_ZZ[0]]);
+ 
+ for(ci=1; ci<=bt8; ci++) 
+ {
+	ZZvalue = data[RTjpeg_ZZ[ci]];
+
+   if(ZZvalue>0) 
+	{
+     strm[co++]=(__s8)(ZZvalue>127)?127:ZZvalue;
+   } 
+	else 
+	{
+     strm[co++]=(__s8)(ZZvalue<-128)?-128:ZZvalue;
+   }
+ }
+
+ for(; ci<64; ci++) 
+ {
+  ZZvalue = data[RTjpeg_ZZ[ci]];
+
+  if(ZZvalue>0)
+  {
+   strm[co++]=(__s8)(ZZvalue>63)?63:ZZvalue;
+  } 
+  else if(ZZvalue<0)
+  {
+   strm[co++]=(__s8)(ZZvalue<-64)?-64:ZZvalue;
+  } 
+  else /* compress zeros */
+  {
+   tmp=ci;
+   do
+   {
+    ci++;
+   } 
+	while((ci<64)&&(data[RTjpeg_ZZ[ci]]==0));
+
+   strm[co++]=(__s8)(63+(ci-tmp));
+   ci--;
+  }
+ }
+ return (int)co;
+}
+
+int RTjpeg_s2b(__s16 *data, __s8 *strm, __u8 bt8, __u32 *qtbl)
+{
+ int ci=1, co=1, tmp;
+ register int i;
+
+ i=RTjpeg_ZZ[0];
+ data[i]=((__u8)strm[0])*qtbl[i];
+
+ for(co=1; co<=bt8; co++)
+ {
+  i=RTjpeg_ZZ[co];
+  data[i]=strm[ci++]*qtbl[i];
+ }
+ 
+ for(; co<64; co++)
+ {
+  if(strm[ci]>63)
+  {
+   tmp=co+strm[ci]-63;
+   for(; co<tmp; co++)data[RTjpeg_ZZ[co]]=0;
+   co--;
+  } else
+  {
+   i=RTjpeg_ZZ[co];
+   data[i]=strm[ci]*qtbl[i];
+  }
+  ci++;
+ }
+ return (int)ci;
+}
+
+#if defined(HAVE_LIBMMX)
+void RTjpeg_quant_init(void)
+{
+ int i;
+ __s16 *qtbl;
+ 
+ qtbl=(__s16 *)RTjpeg_lqt;
+ for(i=0; i<64; i++)qtbl[i]=(__s16)RTjpeg_lqt[i];
+
+ qtbl=(__s16 *)RTjpeg_cqt;
+ for(i=0; i<64; i++)qtbl[i]=(__s16)RTjpeg_cqt[i];
+}
+
+static mmx_t RTjpeg_ones=(mmx_t)(long long)0x0001000100010001LL;
+static mmx_t RTjpeg_half=(mmx_t)(long long)0x7fff7fff7fff7fffLL;
+
+void RTjpeg_quant(__s16 *block, __s32 *qtbl)
+{
+ int i;
+ mmx_t *bl, *ql;
+ 
+ ql=(mmx_t *)qtbl;
+ bl=(mmx_t *)block;
+ 
+ movq_m2r(RTjpeg_ones, mm6);
+ movq_m2r(RTjpeg_half, mm7);
+
+ for(i=16; i; i--) 
+ {
+  movq_m2r(*(ql++), mm0); /* quant vals (4) */
+  movq_m2r(*bl, mm2); /* block vals (4) */
+  movq_r2r(mm0, mm1);
+  movq_r2r(mm2, mm3);
+  
+  punpcklwd_r2r(mm6, mm0); /*           1 qb 1 qa */
+  punpckhwd_r2r(mm6, mm1); /* 1 qd 1 qc */
+  
+  punpcklwd_r2r(mm7, mm2); /*                   32767 bb 32767 ba */
+  punpckhwd_r2r(mm7, mm3); /* 32767 bd 32767 bc */
+  
+  pmaddwd_r2r(mm2, mm0); /*                         32767+bb*qb 32767+ba*qa */
+  pmaddwd_r2r(mm3, mm1); /* 32767+bd*qd 32767+bc*qc */
+  
+  psrad_i2r(16, mm0);
+  psrad_i2r(16, mm1);
+  
+  packssdw_r2r(mm1, mm0);
+  
+  movq_r2m(mm0, *(bl++));
+  
+ }
+}
+#else
+void RTjpeg_quant_init(void)
+{
+}
+
+void RTjpeg_quant(__s16 *block, __s32 *qtbl)
+{
+ int i;
+ 
+ for(i=0; i<64; i++)
+   block[i]=(__s16)((block[i]*qtbl[i]+32767)>>16);
+}
+#endif
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+#ifdef HAVE_LIBMMX
+static mmx_t RTjpeg_C4   =(mmx_t)(long long)0x2D412D412D412D41LL;
+static mmx_t RTjpeg_C6   =(mmx_t)(long long)0x187E187E187E187ELL;
+static mmx_t RTjpeg_C2mC6=(mmx_t)(long long)0x22A322A322A322A3LL;
+static mmx_t RTjpeg_C2pC6=(mmx_t)(long long)0x539F539F539F539FLL;
+static mmx_t RTjpeg_zero =(mmx_t)(long long)0x0000000000000000LL;
+
+#else
+
+#define FIX_0_382683433  ((__s32)   98)		/* FIX(0.382683433) */
+#define FIX_0_541196100  ((__s32)  139)		/* FIX(0.541196100) */
+#define FIX_0_707106781  ((__s32)  181)		/* FIX(0.707106781) */
+#define FIX_1_306562965  ((__s32)  334)		/* FIX(1.306562965) */
+
+#define DESCALE10(x) (__s16)( ((x)+128) >> 8)
+#define DESCALE20(x)  (__s16)(((x)+32768) >> 16)
+#define D_MULTIPLY(var,const)  ((__s32) ((var) * (const)))
+#endif
+
+void RTjpeg_dct_init(void)
+{
+ int i;
+ 
+ for(i=0; i<64; i++)
+ {
+  RTjpeg_lqt[i]=(((__u64)RTjpeg_lqt[i]<<32)/RTjpeg_aan_tab[i]);
+  RTjpeg_cqt[i]=(((__u64)RTjpeg_cqt[i]<<32)/RTjpeg_aan_tab[i]);
+ }
+}
+
+void RTjpeg_dctY(__u8 *idata, __s16 *odata, int rskip)
+{
+#ifndef HAVE_LIBMMX
+  __s32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __s32 tmp10, tmp11, tmp12, tmp13;
+  __s32 z1, z2, z3, z4, z5, z11, z13;
+  __u8 *idataptr;
+  __s16 *odataptr;
+  __s32 *wsptr;
+  int ctr;
+
+  idataptr = idata;
+  wsptr = RTjpeg_ws;
+  for (ctr = 7; ctr >= 0; ctr--) {
+    tmp0 = idataptr[0] + idataptr[7];
+    tmp7 = idataptr[0] - idataptr[7];
+    tmp1 = idataptr[1] + idataptr[6];
+    tmp6 = idataptr[1] - idataptr[6];
+    tmp2 = idataptr[2] + idataptr[5];
+    tmp5 = idataptr[2] - idataptr[5];
+    tmp3 = idataptr[3] + idataptr[4];
+    tmp4 = idataptr[3] - idataptr[4];
+    
+    tmp10 = (tmp0 + tmp3);	/* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = (tmp1 + tmp2);
+    tmp12 = tmp1 - tmp2;
+    
+    wsptr[0] = (tmp10 + tmp11)<<8; /* phase 3 */
+    wsptr[4] = (tmp10 - tmp11)<<8;
+    
+    z1 = D_MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+    wsptr[2] = (tmp13<<8) + z1;	/* phase 5 */
+    wsptr[6] = (tmp13<<8) - z1;
+    
+    tmp10 = tmp4 + tmp5;	/* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    z5 = D_MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+    z2 = D_MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+    z4 = D_MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+    z3 = D_MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+    z11 = (tmp7<<8) + z3;		/* phase 5 */
+    z13 = (tmp7<<8) - z3;
+
+    wsptr[5] = z13 + z2;	/* phase 6 */
+    wsptr[3] = z13 - z2;
+    wsptr[1] = z11 + z4;
+    wsptr[7] = z11 - z4;
+
+    idataptr += rskip<<3;		/* advance pointer to next row */
+    wsptr += 8;
+  }
+
+  wsptr = RTjpeg_ws;
+  odataptr=odata;
+  for (ctr = 7; ctr >= 0; ctr--) {
+    tmp0 = wsptr[0] + wsptr[56];
+    tmp7 = wsptr[0] - wsptr[56];
+    tmp1 = wsptr[8] + wsptr[48];
+    tmp6 = wsptr[8] - wsptr[48];
+    tmp2 = wsptr[16] + wsptr[40];
+    tmp5 = wsptr[16] - wsptr[40];
+    tmp3 = wsptr[24] + wsptr[32];
+    tmp4 = wsptr[24] - wsptr[32];
+    
+    tmp10 = tmp0 + tmp3;	/* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+    
+    odataptr[0] = DESCALE10(tmp10 + tmp11); /* phase 3 */
+    odataptr[32] = DESCALE10(tmp10 - tmp11);
+    
+    z1 = D_MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+    odataptr[16] = DESCALE20((tmp13<<8) + z1); /* phase 5 */
+    odataptr[48] = DESCALE20((tmp13<<8) - z1);
+
+    tmp10 = tmp4 + tmp5;	/* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    z5 = D_MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+    z2 = D_MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+    z4 = D_MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+    z3 = D_MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+    z11 = (tmp7<<8) + z3;		/* phase 5 */
+    z13 = (tmp7<<8) - z3;
+
+    odataptr[40] = DESCALE20(z13 + z2); /* phase 6 */
+    odataptr[24] = DESCALE20(z13 - z2);
+    odataptr[8] = DESCALE20(z11 + z4);
+    odataptr[56] = DESCALE20(z11 - z4);
+
+    odataptr++;			/* advance pointer to next column */
+    wsptr++;
+  }
+#else
+  mmx_t tmp6, tmp7;
+  register mmx_t *dataptr = (mmx_t *)odata;
+  mmx_t *idata2 = (mmx_t *)idata;
+
+   // first copy the input 8 bit to the destination 16 bits
+
+   movq_m2r(RTjpeg_zero, mm2);
+
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+1));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+2));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+3));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+4));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+5));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+6));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+7));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+8));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+9));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+10));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+11));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+12));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+13));
+	
+	idata2 += rskip;
+
+	movq_m2r(*idata2, mm0);		 
+	movq_r2r(mm0, mm1);		 			
+
+	punpcklbw_r2r(mm2, mm0);
+	movq_r2m(mm0, *(dataptr+14));
+
+	punpckhbw_r2r(mm2, mm1);
+	movq_r2m(mm1, *(dataptr+15));
+
+/*  Start Transpose to do calculations on rows */
+
+	movq_m2r(*(dataptr+9), mm7);		 	// m03:m02|m01:m00 - first line (line 4)and copy into m5
+
+	movq_m2r(*(dataptr+13), mm6);	    	// m23:m22|m21:m20 - third line (line 6)and copy into m2
+	movq_r2r(mm7, mm5);		 			
+
+	punpcklwd_m2r(*(dataptr+11), mm7); 	// m11:m01|m10:m00 - interleave first and second lines
+	movq_r2r(mm6, mm2);						 
+
+	punpcklwd_m2r(*(dataptr+15), mm6);  // m31:m21|m30:m20 - interleave third and fourth lines
+	movq_r2r(mm7, mm1);
+
+	movq_m2r(*(dataptr+11), mm3);	      // m13:m13|m11:m10 - second line	 
+	punpckldq_r2r(mm6, mm7);				// m30:m20|m10:m00 - interleave to produce result 1
+
+	movq_m2r(*(dataptr+15), mm0);	      // m13:m13|m11:m10 - fourth line
+	punpckhdq_r2r(mm6, mm1);				// m31:m21|m11:m01 - interleave to produce result 2
+
+	movq_r2m(mm7,*(dataptr+9));			// write result 1
+	punpckhwd_r2r(mm3, mm5);				// m13:m03|m12:m02 - interleave first and second lines
+	
+	movq_r2m(mm1,*(dataptr+11));			// write result 2
+	punpckhwd_r2r(mm0, mm2);				// m33:m23|m32:m22 - interleave third and fourth lines
+
+	movq_r2r(mm5, mm1);
+	punpckldq_r2r(mm2, mm5);				// m32:m22|m12:m02 - interleave to produce result 3
+
+	movq_m2r(*(dataptr+1), mm0);			// m03:m02|m01:m00 - first line, 4x4
+	punpckhdq_r2r(mm2, mm1);				// m33:m23|m13:m03 - interleave to produce result 4
+
+	movq_r2m(mm5,*(dataptr+13));			// write result 3
+
+	// last 4x4 done
+
+	movq_r2m(mm1, *(dataptr+15));			// write result 4, last 4x4
+
+	movq_m2r(*(dataptr+5), mm2);			// m23:m22|m21:m20 - third line
+	movq_r2r(mm0, mm6);
+
+	punpcklwd_m2r(*(dataptr+3), mm0);  	// m11:m01|m10:m00 - interleave first and second lines
+	movq_r2r(mm2, mm7);
+
+	punpcklwd_m2r(*(dataptr+7), mm2);  	// m31:m21|m30:m20 - interleave third and fourth lines
+	movq_r2r(mm0, mm4);
+
+	//
+	movq_m2r(*(dataptr+8), mm1);			// n03:n02|n01:n00 - first line 
+	punpckldq_r2r(mm2, mm0);				// m30:m20|m10:m00 - interleave to produce first result
+
+	movq_m2r(*(dataptr+12), mm3);			// n23:n22|n21:n20 - third line
+	punpckhdq_r2r(mm2, mm4);				// m31:m21|m11:m01 - interleave to produce second result
+
+	punpckhwd_m2r(*(dataptr+3), mm6);  	// m13:m03|m12:m02 - interleave first and second lines
+	movq_r2r(mm1, mm2);               	// copy first line
+
+	punpckhwd_m2r(*(dataptr+7), mm7);  	// m33:m23|m32:m22 - interleave third and fourth lines
+	movq_r2r(mm6, mm5);						// copy first intermediate result
+
+	movq_r2m(mm0, *(dataptr+8));			// write result 1
+	punpckhdq_r2r(mm7, mm5);				// m33:m23|m13:m03 - produce third result
+
+	punpcklwd_m2r(*(dataptr+10), mm1);  // n11:n01|n10:n00 - interleave first and second lines
+	movq_r2r(mm3, mm0);						// copy third line
+
+	punpckhwd_m2r(*(dataptr+10), mm2);  // n13:n03|n12:n02 - interleave first and second lines
+
+	movq_r2m(mm4, *(dataptr+10));			// write result 2 out
+	punpckldq_r2r(mm7, mm6);				// m32:m22|m12:m02 - produce fourth result
+
+	punpcklwd_m2r(*(dataptr+14), mm3);  // n31:n21|n30:n20 - interleave third and fourth lines
+	movq_r2r(mm1, mm4);
+
+	movq_r2m(mm6, *(dataptr+12));			// write result 3 out
+	punpckldq_r2r(mm3, mm1);				// n30:n20|n10:n00 - produce first result
+
+	punpckhwd_m2r(*(dataptr+14), mm0);  // n33:n23|n32:n22 - interleave third and fourth lines
+	movq_r2r(mm2, mm6);
+
+	movq_r2m(mm5, *(dataptr+14));			// write result 4 out
+	punpckhdq_r2r(mm3, mm4);				// n31:n21|n11:n01- produce second result
+
+	movq_r2m(mm1, *(dataptr+1));			// write result 5 out - (first result for other 4 x 4 block)
+	punpckldq_r2r(mm0, mm2);				// n32:n22|n12:n02- produce third result
+
+	movq_r2m(mm4, *(dataptr+3));			// write result 6 out
+	punpckhdq_r2r(mm0, mm6);				// n33:n23|n13:n03 - produce fourth result
+
+	movq_r2m(mm2, *(dataptr+5));			// write result 7 out
+
+	movq_m2r(*dataptr, mm0);				// m03:m02|m01:m00 - first line, first 4x4
+
+	movq_r2m(mm6, *(dataptr+7));			// write result 8 out
+
+
+// Do first 4x4 quadrant, which is used in the beginning of the DCT:
+
+	movq_m2r(*(dataptr+4), mm7);			// m23:m22|m21:m20 - third line
+	movq_r2r(mm0, mm2);
+
+	punpcklwd_m2r(*(dataptr+2), mm0);  	// m11:m01|m10:m00 - interleave first and second lines
+	movq_r2r(mm7, mm4);
+
+	punpcklwd_m2r(*(dataptr+6), mm7);  	// m31:m21|m30:m20 - interleave third and fourth lines
+	movq_r2r(mm0, mm1);
+
+	movq_m2r(*(dataptr+2), mm6);			// m13:m12|m11:m10 - second line
+	punpckldq_r2r(mm7, mm0);				// m30:m20|m10:m00 - interleave to produce result 1
+
+	movq_m2r(*(dataptr+6), mm5);			// m33:m32|m31:m30 - fourth line
+	punpckhdq_r2r(mm7, mm1);				// m31:m21|m11:m01 - interleave to produce result 2
+
+	movq_r2r(mm0, mm7);						// write result 1
+	punpckhwd_r2r(mm6, mm2);				// m13:m03|m12:m02 - interleave first and second lines
+
+	psubw_m2r(*(dataptr+14), mm7);		// tmp07=x0-x7	/* Stage 1 */
+	movq_r2r(mm1, mm6);						// write result 2
+
+	paddw_m2r(*(dataptr+14), mm0);		// tmp00=x0+x7	/* Stage 1 */
+	punpckhwd_r2r(mm5, mm4);   			// m33:m23|m32:m22 - interleave third and fourth lines
+
+	paddw_m2r(*(dataptr+12), mm1);		// tmp01=x1+x6	/* Stage 1 */
+	movq_r2r(mm2, mm3);						// copy first intermediate result
+
+	psubw_m2r(*(dataptr+12), mm6);		// tmp06=x1-x6	/* Stage 1 */
+	punpckldq_r2r(mm4, mm2);				// m32:m22|m12:m02 - interleave to produce result 3
+
+   movq_r2m(mm7, tmp7);
+	movq_r2r(mm2, mm5);						// write result 3
+
+   movq_r2m(mm6, tmp6);
+	punpckhdq_r2r(mm4, mm3);				// m33:m23|m13:m03 - interleave to produce result 4
+
+	paddw_m2r(*(dataptr+10), mm2);     	// tmp02=x2+5 /* Stage 1 */
+	movq_r2r(mm3, mm4);						// write result 4
+
+/************************************************************************************************
+					End of Transpose
+************************************************************************************************/
+
+
+   paddw_m2r(*(dataptr+8), mm3);    	// tmp03=x3+x4 /* stage 1*/
+   movq_r2r(mm0, mm7);
+
+   psubw_m2r(*(dataptr+8), mm4);    	// tmp04=x3-x4 /* stage 1*/
+   movq_r2r(mm1, mm6);
+
+	paddw_r2r(mm3, mm0);  					// tmp10 = tmp00 + tmp03 /* even 2 */
+	psubw_r2r(mm3, mm7);  					// tmp13 = tmp00 - tmp03 /* even 2 */
+
+	psubw_r2r(mm2, mm6);  					// tmp12 = tmp01 - tmp02 /* even 2 */
+	paddw_r2r(mm2, mm1);  					// tmp11 = tmp01 + tmp02 /* even 2 */
+
+   psubw_m2r(*(dataptr+10), mm5);    	// tmp05=x2-x5 /* stage 1*/
+	paddw_r2r(mm7, mm6);						// tmp12 + tmp13
+
+	/* stage 3 */
+
+   movq_m2r(tmp6, mm2);
+   movq_r2r(mm0, mm3);
+
+	psllw_i2r(2, mm6);			// m8 * 2^2
+	paddw_r2r(mm1, mm0);		
+
+	pmulhw_m2r(RTjpeg_C4, mm6);			// z1
+	psubw_r2r(mm1, mm3);		
+
+   movq_r2m(mm0, *dataptr);
+   movq_r2r(mm7, mm0);
+   
+    /* Odd part */
+   movq_r2m(mm3, *(dataptr+8));
+	paddw_r2r(mm5, mm4);						// tmp10
+
+   movq_m2r(tmp7, mm3);
+	paddw_r2r(mm6, mm0);						// tmp32
+
+	paddw_r2r(mm2, mm5);						// tmp11
+	psubw_r2r(mm6, mm7);						// tmp33
+
+   movq_r2m(mm0, *(dataptr+4));
+	paddw_r2r(mm3, mm2);						// tmp12
+
+	/* stage 4 */
+
+   movq_r2m(mm7, *(dataptr+12));
+	movq_r2r(mm4, mm1);						// copy of tmp10
+
+	psubw_r2r(mm2, mm1);						// tmp10 - tmp12
+	psllw_i2r(2, mm4);			// m8 * 2^2
+
+	movq_m2r(RTjpeg_C2mC6, mm0);		
+	psllw_i2r(2, mm1);
+
+	pmulhw_m2r(RTjpeg_C6, mm1);			// z5
+	psllw_i2r(2, mm2);
+
+	pmulhw_r2r(mm0, mm4);					// z5
+
+	/* stage 5 */
+
+	pmulhw_m2r(RTjpeg_C2pC6, mm2);
+	psllw_i2r(2, mm5);
+
+	pmulhw_m2r(RTjpeg_C4, mm5);			// z3
+	movq_r2r(mm3, mm0);						// copy tmp7
+
+   movq_m2r(*(dataptr+1), mm7);
+	paddw_r2r(mm1, mm4);						// z2
+
+	paddw_r2r(mm1, mm2);						// z4
+
+	paddw_r2r(mm5, mm0);						// z11
+	psubw_r2r(mm5, mm3);						// z13
+
+	/* stage 6 */
+
+	movq_r2r(mm3, mm5);						// copy z13
+	psubw_r2r(mm4, mm3);						// y3=z13 - z2
+
+	paddw_r2r(mm4, mm5);						// y5=z13 + z2
+	movq_r2r(mm0, mm6);						// copy z11
+
+   movq_r2m(mm3, *(dataptr+6)); 			//save y3
+	psubw_r2r(mm2, mm0);						// y7=z11 - z4
+
+   movq_r2m(mm5, *(dataptr+10)); 		//save y5
+	paddw_r2r(mm2, mm6);						// y1=z11 + z4
+
+   movq_r2m(mm0, *(dataptr+14)); 		//save y7
+
+	/************************************************
+	 *  End of 1st 4 rows
+	 ************************************************/
+
+   movq_m2r(*(dataptr+3), mm1); 			// load x1   /* stage 1 */
+	movq_r2r(mm7, mm0);						// copy x0
+
+   movq_r2m(mm6, *(dataptr+2)); 			//save y1
+
+   movq_m2r(*(dataptr+5), mm2); 			// load x2   /* stage 1 */
+	movq_r2r(mm1, mm6);						// copy x1
+
+   paddw_m2r(*(dataptr+15), mm0);  		// tmp00 = x0 + x7
+
+   movq_m2r(*(dataptr+7), mm3); 			// load x3   /* stage 1 */
+	movq_r2r(mm2, mm5);						// copy x2
+
+   psubw_m2r(*(dataptr+15), mm7);  		// tmp07 = x0 - x7
+	movq_r2r(mm3, mm4);						// copy x3
+
+   paddw_m2r(*(dataptr+13), mm1);  		// tmp01 = x1 + x6
+
+	movq_r2m(mm7, tmp7);						// save tmp07
+	movq_r2r(mm0, mm7);						// copy tmp00
+
+   psubw_m2r(*(dataptr+13), mm6);  		// tmp06 = x1 - x6
+
+   /* stage 2, Even Part */
+
+   paddw_m2r(*(dataptr+9), mm3);  		// tmp03 = x3 + x4
+
+	movq_r2m(mm6, tmp6);						// save tmp07
+	movq_r2r(mm1, mm6);						// copy tmp01
+
+   paddw_m2r(*(dataptr+11), mm2);  		// tmp02 = x2 + x5
+	paddw_r2r(mm3, mm0);              	// tmp10 = tmp00 + tmp03
+
+	psubw_r2r(mm3, mm7);              	// tmp13 = tmp00 - tmp03
+
+   psubw_m2r(*(dataptr+9), mm4);  		// tmp04 = x3 - x4
+	psubw_r2r(mm2, mm6);              	// tmp12 = tmp01 - tmp02
+
+	paddw_r2r(mm2, mm1);              	// tmp11 = tmp01 + tmp02
+
+   psubw_m2r(*(dataptr+11), mm5);  		// tmp05 = x2 - x5
+	paddw_r2r(mm7, mm6);              	//  tmp12 + tmp13
+
+   /* stage 3, Even and stage 4 & 5 even */
+
+	movq_m2r(tmp6, mm2);            		// load tmp6
+	movq_r2r(mm0, mm3);						// copy tmp10
+
+	psllw_i2r(2, mm6);			// shift z1
+	paddw_r2r(mm1, mm0);    				// y0=tmp10 + tmp11
+
+	pmulhw_m2r(RTjpeg_C4, mm6);    		// z1
+	psubw_r2r(mm1, mm3);    				// y4=tmp10 - tmp11
+
+   movq_r2m(mm0, *(dataptr+1)); 			//save y0
+	movq_r2r(mm7, mm0);						// copy tmp13
+  
+	/* odd part */
+
+   movq_r2m(mm3, *(dataptr+9)); 			//save y4
+	paddw_r2r(mm5, mm4);              	// tmp10 = tmp4 + tmp5
+
+	movq_m2r(tmp7, mm3);            		// load tmp7
+	paddw_r2r(mm6, mm0);              	// tmp32 = tmp13 + z1
+
+	paddw_r2r(mm2, mm5);              	// tmp11 = tmp5 + tmp6
+	psubw_r2r(mm6, mm7);              	// tmp33 = tmp13 - z1
+
+   movq_r2m(mm0, *(dataptr+5)); 			//save y2
+	paddw_r2r(mm3, mm2);              	// tmp12 = tmp6 + tmp7
+
+	/* stage 4 */
+
+   movq_r2m(mm7, *(dataptr+13)); 		//save y6
+	movq_r2r(mm4, mm1);						// copy tmp10
+
+	psubw_r2r(mm2, mm1);    				// tmp10 - tmp12
+	psllw_i2r(2, mm4);			// shift tmp10
+
+	movq_m2r(RTjpeg_C2mC6, mm0);			// load C2mC6
+	psllw_i2r(2, mm1);			// shift (tmp10-tmp12)
+
+	pmulhw_m2r(RTjpeg_C6, mm1);    		// z5
+	psllw_i2r(2, mm5);			// prepare for multiply 
+
+	pmulhw_r2r(mm0, mm4);					// multiply by converted real
+
+	/* stage 5 */
+
+	pmulhw_m2r(RTjpeg_C4, mm5);			// z3
+	psllw_i2r(2, mm2);			// prepare for multiply 
+
+	pmulhw_m2r(RTjpeg_C2pC6, mm2);		// multiply
+	movq_r2r(mm3, mm0);						// copy tmp7
+
+	movq_m2r(*(dataptr+9), mm7);		 	// m03:m02|m01:m00 - first line (line 4)and copy into mm7
+	paddw_r2r(mm1, mm4);						// z2
+
+	paddw_r2r(mm5, mm0);						// z11
+	psubw_r2r(mm5, mm3);						// z13
+
+	/* stage 6 */
+
+	movq_r2r(mm3, mm5);						// copy z13
+	paddw_r2r(mm1, mm2);						// z4
+
+	movq_r2r(mm0, mm6);						// copy z11
+	psubw_r2r(mm4, mm5);						// y3
+
+	paddw_r2r(mm2, mm6);						// y1
+	paddw_r2r(mm4, mm3);						// y5
+
+   movq_r2m(mm5, *(dataptr+7)); 			//save y3
+
+   movq_r2m(mm6, *(dataptr+3)); 			//save y1
+	psubw_r2r(mm2, mm0);						// y7
+	
+/************************************************************************************************
+					Start of Transpose
+************************************************************************************************/
+
+ 	movq_m2r(*(dataptr+13), mm6);		 	// m23:m22|m21:m20 - third line (line 6)and copy into m2
+	movq_r2r(mm7, mm5);						// copy first line
+
+	punpcklwd_r2r(mm3, mm7); 				// m11:m01|m10:m00 - interleave first and second lines
+	movq_r2r(mm6, mm2);						// copy third line
+
+	punpcklwd_r2r(mm0, mm6);  				// m31:m21|m30:m20 - interleave third and fourth lines
+	movq_r2r(mm7, mm1);						// copy first intermediate result
+
+	punpckldq_r2r(mm6, mm7);				// m30:m20|m10:m00 - interleave to produce result 1
+
+	punpckhdq_r2r(mm6, mm1);				// m31:m21|m11:m01 - interleave to produce result 2
+
+	movq_r2m(mm7, *(dataptr+9));			// write result 1
+	punpckhwd_r2r(mm3, mm5);				// m13:m03|m12:m02 - interleave first and second lines
+
+	movq_r2m(mm1, *(dataptr+11));			// write result 2
+	punpckhwd_r2r(mm0, mm2);				// m33:m23|m32:m22 - interleave third and fourth lines
+
+	movq_r2r(mm5, mm1);						// copy first intermediate result
+	punpckldq_r2r(mm2, mm5);				// m32:m22|m12:m02 - interleave to produce result 3
+
+	movq_m2r(*(dataptr+1), mm0);			// m03:m02|m01:m00 - first line, 4x4
+	punpckhdq_r2r(mm2, mm1);				// m33:m23|m13:m03 - interleave to produce result 4
+
+	movq_r2m(mm5, *(dataptr+13));			// write result 3
+
+	/****** last 4x4 done */
+
+	movq_r2m(mm1, *(dataptr+15));			// write result 4, last 4x4
+
+	movq_m2r(*(dataptr+5), mm2);			// m23:m22|m21:m20 - third line
+	movq_r2r(mm0, mm6);						// copy first line
+
+	punpcklwd_m2r(*(dataptr+3), mm0);  	// m11:m01|m10:m00 - interleave first and second lines
+	movq_r2r(mm2, mm7);						// copy third line
+
+	punpcklwd_m2r(*(dataptr+7), mm2);  	// m31:m21|m30:m20 - interleave third and fourth lines
+	movq_r2r(mm0, mm4);						// copy first intermediate result
+
+	
+
+	movq_m2r(*(dataptr+8), mm1);			// n03:n02|n01:n00 - first line 
+	punpckldq_r2r(mm2, mm0);				// m30:m20|m10:m00 - interleave to produce first result
+
+	movq_m2r(*(dataptr+12), mm3);			// n23:n22|n21:n20 - third line
+	punpckhdq_r2r(mm2, mm4);				// m31:m21|m11:m01 - interleave to produce second result
+
+	punpckhwd_m2r(*(dataptr+3), mm6);  	// m13:m03|m12:m02 - interleave first and second lines
+	movq_r2r(mm1, mm2);						// copy first line
+
+	punpckhwd_m2r(*(dataptr+7), mm7);  	// m33:m23|m32:m22 - interleave third and fourth lines
+	movq_r2r(mm6, mm5);						// copy first intermediate result
+
+	movq_r2m(mm0, *(dataptr+8));			// write result 1
+	punpckhdq_r2r(mm7, mm5);				// m33:m23|m13:m03 - produce third result
+
+	punpcklwd_m2r(*(dataptr+10), mm1);  // n11:n01|n10:n00 - interleave first and second lines
+	movq_r2r(mm3, mm0);						// copy third line
+
+	punpckhwd_m2r(*(dataptr+10), mm2);  // n13:n03|n12:n02 - interleave first and second lines
+
+	movq_r2m(mm4, *(dataptr+10));			// write result 2 out
+	punpckldq_r2r(mm7, mm6);				// m32:m22|m12:m02 - produce fourth result
+
+	punpcklwd_m2r(*(dataptr+14), mm3);  // n33:n23|n32:n22 - interleave third and fourth lines
+	movq_r2r(mm1, mm4);						// copy second intermediate result
+
+	movq_r2m(mm6, *(dataptr+12));			// write result 3 out
+	punpckldq_r2r(mm3, mm1);				// 
+
+	punpckhwd_m2r(*(dataptr+14), mm0);  // n33:n23|n32:n22 - interleave third and fourth lines
+	movq_r2r(mm2, mm6);						// copy second intermediate result
+
+	movq_r2m(mm5, *(dataptr+14));			// write result 4 out
+	punpckhdq_r2r(mm3, mm4);				// n31:n21|n11:n01- produce second result
+
+	movq_r2m(mm1, *(dataptr+1));			// write result 5 out - (first result for other 4 x 4 block)
+	punpckldq_r2r(mm0, mm2);				// n32:n22|n12:n02- produce third result
+
+	movq_r2m(mm4, *(dataptr+3));			// write result 6 out
+	punpckhdq_r2r(mm0, mm6);				// n33:n23|n13:n03 - produce fourth result
+
+	movq_r2m(mm2, *(dataptr+5));			// write result 7 out
+
+	movq_m2r(*dataptr, mm0);				// m03:m02|m01:m00 - first line, first 4x4
+
+	movq_r2m(mm6, *(dataptr+7));			// write result 8 out
+
+// Do first 4x4 quadrant, which is used in the beginning of the DCT:
+
+	movq_m2r(*(dataptr+4), mm7);			// m23:m22|m21:m20 - third line
+	movq_r2r(mm0, mm2);						// copy first line
+
+	punpcklwd_m2r(*(dataptr+2), mm0);  	// m11:m01|m10:m00 - interleave first and second lines
+	movq_r2r(mm7, mm4);						// copy third line
+	
+	punpcklwd_m2r(*(dataptr+6), mm7);  	// m31:m21|m30:m20 - interleave third and fourth lines
+	movq_r2r(mm0, mm1);						// copy first intermediate result
+
+	movq_m2r(*(dataptr+2), mm6);			// m13:m12|m11:m10 - second line
+	punpckldq_r2r(mm7, mm0);				// m30:m20|m10:m00 - interleave to produce result 1
+
+	movq_m2r(*(dataptr+6), mm5);			// m33:m32|m31:m30 - fourth line
+	punpckhdq_r2r(mm7, mm1);				// m31:m21|m11:m01 - interleave to produce result 2
+
+	movq_r2r(mm0, mm7);						// write result 1
+	punpckhwd_r2r(mm6, mm2);				// m13:m03|m12:m02 - interleave first and second lines
+
+	psubw_m2r(*(dataptr+14), mm7);		// tmp07=x0-x7	/* Stage 1 */
+	movq_r2r(mm1, mm6);						// write result 2
+
+	paddw_m2r(*(dataptr+14), mm0);		// tmp00=x0+x7	/* Stage 1 */
+	punpckhwd_r2r(mm5, mm4);   			// m33:m23|m32:m22 - interleave third and fourth lines
+
+	paddw_m2r(*(dataptr+12), mm1);		// tmp01=x1+x6	/* Stage 1 */
+	movq_r2r(mm2, mm3);						// copy first intermediate result
+
+	psubw_m2r(*(dataptr+12), mm6);		// tmp06=x1-x6	/* Stage 1 */
+	punpckldq_r2r(mm4, mm2);				// m32:m22|m12:m02 - interleave to produce result 3
+
+	movq_r2m(mm7, tmp7);						// save tmp07
+	movq_r2r(mm2, mm5);						// write result 3
+
+	movq_r2m(mm6, tmp6);						// save tmp06
+
+	punpckhdq_r2r(mm4, mm3);				// m33:m23|m13:m03 - interleave to produce result 4
+
+	paddw_m2r(*(dataptr+10), mm2);   	// tmp02=x2+x5 /* stage 1 */
+	movq_r2r(mm3, mm4);						// write result 4
+
+/************************************************************************************************
+					End of Transpose 2
+************************************************************************************************/
+
+   paddw_m2r(*(dataptr+8), mm3);    	// tmp03=x3+x4 /* stage 1*/
+   movq_r2r(mm0, mm7);
+
+   psubw_m2r(*(dataptr+8), mm4);    	// tmp04=x3-x4 /* stage 1*/
+   movq_r2r(mm1, mm6);
+
+	paddw_r2r(mm3, mm0);  					// tmp10 = tmp00 + tmp03 /* even 2 */
+	psubw_r2r(mm3, mm7);  					// tmp13 = tmp00 - tmp03 /* even 2 */
+
+	psubw_r2r(mm2, mm6);  					// tmp12 = tmp01 - tmp02 /* even 2 */
+	paddw_r2r(mm2, mm1);  					// tmp11 = tmp01 + tmp02 /* even 2 */
+
+   psubw_m2r(*(dataptr+10), mm5);    	// tmp05=x2-x5 /* stage 1*/
+	paddw_r2r(mm7, mm6);						// tmp12 + tmp13
+
+	/* stage 3 */
+
+   movq_m2r(tmp6, mm2);
+   movq_r2r(mm0, mm3);
+
+	psllw_i2r(2, mm6);			// m8 * 2^2
+	paddw_r2r(mm1, mm0);		
+
+	pmulhw_m2r(RTjpeg_C4, mm6);			// z1
+	psubw_r2r(mm1, mm3);		
+
+   movq_r2m(mm0, *dataptr);
+   movq_r2r(mm7, mm0);
+   
+    /* Odd part */
+   movq_r2m(mm3, *(dataptr+8));
+	paddw_r2r(mm5, mm4);						// tmp10
+
+   movq_m2r(tmp7, mm3);
+	paddw_r2r(mm6, mm0);						// tmp32
+
+	paddw_r2r(mm2, mm5);						// tmp11
+	psubw_r2r(mm6, mm7);						// tmp33
+
+   movq_r2m(mm0, *(dataptr+4));
+	paddw_r2r(mm3, mm2);						// tmp12
+
+	/* stage 4 */
+   movq_r2m(mm7, *(dataptr+12));
+	movq_r2r(mm4, mm1);						// copy of tmp10
+
+	psubw_r2r(mm2, mm1);						// tmp10 - tmp12
+	psllw_i2r(2, mm4);			// m8 * 2^2
+
+	movq_m2r(RTjpeg_C2mC6, mm0);
+	psllw_i2r(2, mm1);
+
+	pmulhw_m2r(RTjpeg_C6, mm1);			// z5
+	psllw_i2r(2, mm2);
+
+	pmulhw_r2r(mm0, mm4);					// z5
+
+	/* stage 5 */
+
+	pmulhw_m2r(RTjpeg_C2pC6, mm2);
+	psllw_i2r(2, mm5);
+
+	pmulhw_m2r(RTjpeg_C4, mm5);			// z3
+	movq_r2r(mm3, mm0);						// copy tmp7
+
+   movq_m2r(*(dataptr+1), mm7);
+	paddw_r2r(mm1, mm4);						// z2
+
+	paddw_r2r(mm1, mm2);						// z4
+
+	paddw_r2r(mm5, mm0);						// z11
+	psubw_r2r(mm5, mm3);						// z13
+
+	/* stage 6 */
+
+	movq_r2r(mm3, mm5);						// copy z13
+	psubw_r2r(mm4, mm3);						// y3=z13 - z2
+
+	paddw_r2r(mm4, mm5);						// y5=z13 + z2
+	movq_r2r(mm0, mm6);						// copy z11
+
+   movq_r2m(mm3, *(dataptr+6)); 			//save y3
+	psubw_r2r(mm2, mm0);						// y7=z11 - z4
+
+   movq_r2m(mm5, *(dataptr+10)); 		//save y5
+	paddw_r2r(mm2, mm6);						// y1=z11 + z4
+
+   movq_r2m(mm0, *(dataptr+14)); 		//save y7
+
+	/************************************************
+	 *  End of 1st 4 rows
+	 ************************************************/
+
+   movq_m2r(*(dataptr+3), mm1); 			// load x1   /* stage 1 */
+	movq_r2r(mm7, mm0);						// copy x0
+
+   movq_r2m(mm6, *(dataptr+2)); 			//save y1
+
+   movq_m2r(*(dataptr+5), mm2); 			// load x2   /* stage 1 */
+	movq_r2r(mm1, mm6);						// copy x1
+
+   paddw_m2r(*(dataptr+15), mm0);  		// tmp00 = x0 + x7
+
+   movq_m2r(*(dataptr+7), mm3); 			// load x3   /* stage 1 */
+	movq_r2r(mm2, mm5);						// copy x2
+
+   psubw_m2r(*(dataptr+15), mm7);  		// tmp07 = x0 - x7
+	movq_r2r(mm3, mm4);						// copy x3
+
+   paddw_m2r(*(dataptr+13), mm1);  		// tmp01 = x1 + x6
+
+	movq_r2m(mm7, tmp7);						// save tmp07
+	movq_r2r(mm0, mm7);						// copy tmp00
+
+   psubw_m2r(*(dataptr+13), mm6);  		// tmp06 = x1 - x6
+
+   /* stage 2, Even Part */
+
+   paddw_m2r(*(dataptr+9), mm3);  		// tmp03 = x3 + x4
+
+	movq_r2m(mm6, tmp6);						// save tmp07
+	movq_r2r(mm1, mm6);						// copy tmp01
+
+   paddw_m2r(*(dataptr+11), mm2);  		// tmp02 = x2 + x5
+	paddw_r2r(mm3, mm0);              	// tmp10 = tmp00 + tmp03
+
+	psubw_r2r(mm3, mm7);              	// tmp13 = tmp00 - tmp03
+
+   psubw_m2r(*(dataptr+9), mm4);  		// tmp04 = x3 - x4
+	psubw_r2r(mm2, mm6);              	// tmp12 = tmp01 - tmp02
+
+	paddw_r2r(mm2, mm1);              	// tmp11 = tmp01 + tmp02
+
+   psubw_m2r(*(dataptr+11), mm5);  		// tmp05 = x2 - x5
+	paddw_r2r(mm7, mm6);              	//  tmp12 + tmp13
+
+   /* stage 3, Even and stage 4 & 5 even */
+
+	movq_m2r(tmp6, mm2);            		// load tmp6
+	movq_r2r(mm0, mm3);						// copy tmp10
+
+	psllw_i2r(2, mm6);			// shift z1
+	paddw_r2r(mm1, mm0);    				// y0=tmp10 + tmp11
+
+	pmulhw_m2r(RTjpeg_C4, mm6);    		// z1
+	psubw_r2r(mm1, mm3);    				// y4=tmp10 - tmp11
+
+   movq_r2m(mm0, *(dataptr+1)); 			//save y0
+	movq_r2r(mm7, mm0);						// copy tmp13
+  
+	/* odd part */
+
+   movq_r2m(mm3, *(dataptr+9)); 			//save y4
+	paddw_r2r(mm5, mm4);              	// tmp10 = tmp4 + tmp5
+
+	movq_m2r(tmp7, mm3);            		// load tmp7
+	paddw_r2r(mm6, mm0);              	// tmp32 = tmp13 + z1
+
+	paddw_r2r(mm2, mm5);              	// tmp11 = tmp5 + tmp6
+	psubw_r2r(mm6, mm7);              	// tmp33 = tmp13 - z1
+
+   movq_r2m(mm0, *(dataptr+5)); 			//save y2
+	paddw_r2r(mm3, mm2);              	// tmp12 = tmp6 + tmp7
+
+	/* stage 4 */
+
+   movq_r2m(mm7, *(dataptr+13)); 		//save y6
+	movq_r2r(mm4, mm1);						// copy tmp10
+
+	psubw_r2r(mm2, mm1);    				// tmp10 - tmp12
+	psllw_i2r(2, mm4);			// shift tmp10
+
+	movq_m2r(RTjpeg_C2mC6, mm0);			// load C2mC6
+	psllw_i2r(2, mm1);			// shift (tmp10-tmp12)
+
+	pmulhw_m2r(RTjpeg_C6, mm1);    		// z5
+	psllw_i2r(2, mm5);			// prepare for multiply 
+
+	pmulhw_r2r(mm0, mm4);					// multiply by converted real
+
+	/* stage 5 */
+
+	pmulhw_m2r(RTjpeg_C4, mm5);			// z3
+	psllw_i2r(2, mm2);			// prepare for multiply 
+
+	pmulhw_m2r(RTjpeg_C2pC6, mm2);		// multiply
+	movq_r2r(mm3, mm0);						// copy tmp7
+
+	movq_m2r(*(dataptr+9), mm7);		 	// m03:m02|m01:m00 - first line (line 4)and copy into mm7
+	paddw_r2r(mm1, mm4);						// z2
+
+	paddw_r2r(mm5, mm0);						// z11
+	psubw_r2r(mm5, mm3);						// z13
+
+	/* stage 6 */
+
+	movq_r2r(mm3, mm5);						// copy z13
+	paddw_r2r(mm1, mm2);						// z4
+
+	movq_r2r(mm0, mm6);						// copy z11
+	psubw_r2r(mm4, mm5);						// y3
+
+	paddw_r2r(mm2, mm6);						// y1
+	paddw_r2r(mm4, mm3);						// y5
+
+   movq_r2m(mm5, *(dataptr+7)); 			//save y3
+	psubw_r2r(mm2, mm0);						// yè=z11 - z4
+
+   movq_r2m(mm3, *(dataptr+11)); 		//save y5
+
+   movq_r2m(mm6, *(dataptr+3)); 			//save y1
+
+   movq_r2m(mm0, *(dataptr+15)); 		//save y7
+	
+
+#endif
+}
+
+#define FIX_1_082392200  ((__s32)  277)		/* FIX(1.082392200) */
+#define FIX_1_414213562  ((__s32)  362)		/* FIX(1.414213562) */
+#define FIX_1_847759065  ((__s32)  473)		/* FIX(1.847759065) */
+#define FIX_2_613125930  ((__s32)  669)		/* FIX(2.613125930) */
+
+#define DESCALE(x) (__s16)( ((x)+4) >> 3)
+
+/* clip yuv to 16..235 (should be 16..240 for cr/cb but ... */
+
+#define RL(x) ((x)>235) ? 235 : (((x)<16) ? 16 : (x))
+#define MULTIPLY(var,const)  (((__s32) ((var) * (const)) + 128)>>8)
+
+void RTjpeg_idct_init(void)
+{
+ int i;
+ 
+ for(i=0; i<64; i++)
+ {
+  RTjpeg_liqt[i]=((__u64)RTjpeg_liqt[i]*RTjpeg_aan_tab[i])>>32;
+  RTjpeg_ciqt[i]=((__u64)RTjpeg_ciqt[i]*RTjpeg_aan_tab[i])>>32;
+ }
+}
+
+void RTjpeg_idct(__u8 *odata, __s16 *data, int rskip)
+{
+#ifdef HAVE_LIBMMX
+
+static mmx_t fix_141			= (mmx_t)(long long)0x5a825a825a825a82LL;
+static mmx_t fix_184n261	= (mmx_t)(long long)0xcf04cf04cf04cf04LL;
+static mmx_t fix_184			= (mmx_t)(long long)0x7641764176417641LL;
+static mmx_t fix_n184		= (mmx_t)(long long)0x896f896f896f896fLL;
+static mmx_t fix_108n184	= (mmx_t)(long long)0xcf04cf04cf04cf04LL;
+
+  mmx_t workspace[64];
+  mmx_t *wsptr = workspace;
+  register mmx_t *dataptr = (mmx_t *)odata;
+  mmx_t *idata = (mmx_t *)data;
+
+  rskip = rskip>>3;
+/*
+ * Perform inverse DCT on one block of coefficients.
+ */
+
+    /* Odd part */
+
+	movq_m2r(*(idata+10), mm1);	// load idata[DCTSIZE*5]
+
+	movq_m2r(*(idata+6), mm0);		// load idata[DCTSIZE*3]
+
+	movq_m2r(*(idata+2), mm3);		// load idata[DCTSIZE*1]
+
+	movq_r2r(mm1, mm2);				// copy tmp6	/* phase 6 */
+
+	movq_m2r(*(idata+14), mm4);	// load idata[DCTSIZE*7]
+
+	paddw_r2r(mm0, mm1);				// z13 = tmp6 + tmp5;
+
+	psubw_r2r(mm0, mm2);				// z10 = tmp6 - tmp5   
+
+	psllw_i2r(2, mm2);				// shift z10
+	movq_r2r(mm2, mm0); 				// copy z10
+
+	pmulhw_m2r(fix_184n261, mm2);	// MULTIPLY( z12, FIX_1_847759065); /* 2*c2 */
+	movq_r2r(mm3, mm5);				// copy tmp4
+
+	pmulhw_m2r(fix_n184, mm0);		// MULTIPLY(z10, -FIX_1_847759065); /* 2*c2 */
+	paddw_r2r(mm4, mm3);				// z11 = tmp4 + tmp7;
+
+	movq_r2r(mm3, mm6);				// copy z11			/* phase 5 */
+	psubw_r2r(mm4, mm5);				// z12 = tmp4 - tmp7;
+
+	psubw_r2r(mm1, mm6);				// z11-z13
+	psllw_i2r(2, mm5);				//	shift z12
+
+	movq_m2r(*(idata+12), mm4);	// load idata[DCTSIZE*6], even part
+ 	movq_r2r(mm5, mm7);				//	copy z12
+
+	pmulhw_m2r(fix_108n184, mm5); //	MULT(z12, (FIX_1_08-FIX_1_84)) //- z5; /* 2*(c2-c6) */ even part
+	paddw_r2r(mm1, mm3);				// tmp7 = z11 + z13;	
+
+	//ok
+
+    /* Even part */
+	pmulhw_m2r(fix_184, mm7);		// MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) //+ z5; /* -2*(c2+c6) */
+	psllw_i2r(2, mm6);
+
+	movq_m2r(*(idata+4), mm1);		// load idata[DCTSIZE*2]
+
+	paddw_r2r(mm5, mm0);				//	tmp10
+
+	paddw_r2r(mm7, mm2);				// tmp12
+
+	pmulhw_m2r(fix_141, mm6);		// tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+	psubw_r2r(mm3, mm2);				// tmp6 = tmp12 - tmp7
+
+	movq_r2r(mm1, mm5);				// copy tmp1
+	paddw_r2r(mm4, mm1);				// tmp13= tmp1 + tmp3;	/* phases 5-3 */
+
+	psubw_r2r(mm4, mm5);				// tmp1-tmp3
+	psubw_r2r(mm2, mm6);				// tmp5 = tmp11 - tmp6;
+
+	movq_r2m(mm1, *(wsptr));		// save tmp13 in workspace
+	psllw_i2r(2, mm5);	// shift tmp1-tmp3
+    
+	movq_m2r(*(idata), mm7); 		// load idata[DCTSIZE*0]
+
+	pmulhw_m2r(fix_141, mm5);		// MULTIPLY(tmp1 - tmp3, FIX_1_414213562)
+	paddw_r2r(mm6, mm0);				// tmp4 = tmp10 + tmp5;
+
+	movq_m2r(*(idata+8), mm4); 	// load idata[DCTSIZE*4]
+	
+	psubw_r2r(mm1, mm5);				// tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */
+
+	movq_r2m(mm0, *(wsptr+4));		// save tmp4 in workspace
+	movq_r2r(mm7, mm1);			 	// copy tmp0	/* phase 3 */
+
+	movq_r2m(mm5, *(wsptr+2));		// save tmp12 in workspace
+	psubw_r2r(mm4, mm1);				// tmp11 = tmp0 - tmp2; 
+
+	paddw_r2r(mm4, mm7);				// tmp10 = tmp0 + tmp2;
+   movq_r2r(mm1, mm5);				// copy tmp11
+	
+	paddw_m2r(*(wsptr+2), mm1);	// tmp1 = tmp11 + tmp12;
+	movq_r2r(mm7, mm4);				// copy tmp10		/* phase 2 */
+
+	paddw_m2r(*(wsptr), mm7);		// tmp0 = tmp10 + tmp13;	
+
+	psubw_m2r(*(wsptr), mm4);		// tmp3 = tmp10 - tmp13;
+	movq_r2r(mm7, mm0);				//	copy tmp0
+
+	psubw_m2r(*(wsptr+2), mm5);	// tmp2 = tmp11 - tmp12;
+	paddw_r2r(mm3, mm7);				//	wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7);
+	
+	psubw_r2r(mm3, mm0);				// wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7);
+
+	movq_r2m(mm7, *(wsptr));		//	wsptr[DCTSIZE*0]
+	movq_r2r(mm1, mm3);				//	copy tmp1
+
+	movq_r2m(mm0, *(wsptr+14));		// wsptr[DCTSIZE*7]
+	paddw_r2r(mm2, mm1);				// wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6);
+
+	psubw_r2r(mm2, mm3);				// wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6);
+
+	movq_r2m(mm1, *(wsptr+2));		// wsptr[DCTSIZE*1]
+	movq_r2r(mm4, mm1);				//	copy tmp3
+
+	movq_r2m(mm3, *(wsptr+12));		// wsptr[DCTSIZE*6]
+
+	paddw_m2r(*(wsptr+4), mm4);	// wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4);
+
+	psubw_m2r(*(wsptr+4), mm1); 	// wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4);
+
+	movq_r2m(mm4, *(wsptr+8));		
+	movq_r2r(mm5, mm7);				// copy tmp2
+
+	paddw_r2r(mm6, mm5);				// wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5)
+
+	movq_r2m(mm1, *(wsptr+6));	
+	psubw_r2r(mm6, mm7);				//	wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5);
+
+	movq_r2m(mm5, *(wsptr+4));	
+
+	movq_r2m(mm7, *(wsptr+10));		
+
+	//ok
+
+
+/*****************************************************************/
+
+	idata++;
+	wsptr++;
+
+/*****************************************************************/
+
+	movq_m2r(*(idata+10), mm1);	// load idata[DCTSIZE*5]
+
+	movq_m2r(*(idata+6), mm0);		// load idata[DCTSIZE*3]
+
+	movq_m2r(*(idata+2),	mm3);		// load idata[DCTSIZE*1]
+	movq_r2r(mm1, mm2);				//	copy tmp6	/* phase 6 */
+
+	movq_m2r(*(idata+14),	mm4);		// load idata[DCTSIZE*7]
+	paddw_r2r(mm0, mm1);				//	z13 = tmp6 + tmp5;
+
+	psubw_r2r(mm0, mm2);				//	z10 = tmp6 - tmp5   
+
+	psllw_i2r(2, mm2);				//	shift z10
+	movq_r2r(mm2, mm0);				//	copy z10
+
+	pmulhw_m2r(fix_184n261, mm2);	// MULTIPLY( z12, FIX_1_847759065); /* 2*c2 */
+	movq_r2r(mm3, mm5);				//	copy tmp4
+
+	pmulhw_m2r(fix_n184, mm0);		// MULTIPLY(z10, -FIX_1_847759065); /* 2*c2 */
+	paddw_r2r(mm4, mm3);				// z11 = tmp4 + tmp7;
+
+	movq_r2r(mm3, mm6);				// copy z11			/* phase 5 */
+	psubw_r2r(mm4, mm5);				//	z12 = tmp4 - tmp7;
+
+	psubw_r2r(mm1, mm6);				// z11-z13
+	psllw_i2r(2, mm5);				//	shift z12
+
+	movq_m2r(*(idata+12), mm4);	// load idata[DCTSIZE*6], even part
+ 	movq_r2r(mm5, mm7);				// copy z12
+
+	pmulhw_m2r(fix_108n184, mm5);	// MULT(z12, (FIX_1_08-FIX_1_84)) //- z5; /* 2*(c2-c6) */ even part
+	paddw_r2r(mm1, mm3);				// tmp7 = z11 + z13;	
+
+	//ok
+
+    /* Even part */
+	pmulhw_m2r(fix_184, mm7);		// MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) //+ z5; /* -2*(c2+c6) */
+	psllw_i2r(2, mm6);
+
+	movq_m2r(*(idata+4), mm1);		// load idata[DCTSIZE*2]
+
+	paddw_r2r(mm5, mm0);				//	tmp10
+
+	paddw_r2r(mm7, mm2);				// tmp12
+
+	pmulhw_m2r(fix_141, mm6);		// tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+	psubw_r2r(mm3, mm2);				// tmp6 = tmp12 - tmp7
+
+	movq_r2r(mm1, mm5);				// copy tmp1
+	paddw_r2r(mm4, mm1);				// tmp13= tmp1 + tmp3;	/* phases 5-3 */
+
+	psubw_r2r(mm4, mm5);				// tmp1-tmp3
+	psubw_r2r(mm2, mm6);				// tmp5 = tmp11 - tmp6;
+
+	movq_r2m(mm1, *(wsptr));		// save tmp13 in workspace
+	psllw_i2r(2, mm5); 				// shift tmp1-tmp3
+    
+	movq_m2r(*(idata), mm7);		// load idata[DCTSIZE*0]
+	paddw_r2r(mm6, mm0);				// tmp4 = tmp10 + tmp5;
+
+	pmulhw_m2r(fix_141, mm5);		// MULTIPLY(tmp1 - tmp3, FIX_1_414213562)
+
+	movq_m2r(*(idata+8), mm4);    // load idata[DCTSIZE*4]
+	
+	psubw_r2r(mm1, mm5);				// tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */
+
+	movq_r2m(mm0, *(wsptr+4));		// save tmp4 in workspace
+	movq_r2r(mm7, mm1);				// copy tmp0	/* phase 3 */
+
+	movq_r2m(mm5, *(wsptr+2));		// save tmp12 in workspace
+	psubw_r2r(mm4, mm1);				// tmp11 = tmp0 - tmp2; 
+
+	paddw_r2r(mm4, mm7);				// tmp10 = tmp0 + tmp2;
+   movq_r2r(mm1, mm5);				// copy tmp11
+	
+	paddw_m2r(*(wsptr+2), mm1);	// tmp1 = tmp11 + tmp12;
+	movq_r2r(mm7, mm4);				// copy tmp10		/* phase 2 */
+
+	paddw_m2r(*(wsptr), mm7);		// tmp0 = tmp10 + tmp13;	
+
+	psubw_m2r(*(wsptr), mm4);		// tmp3 = tmp10 - tmp13;
+	movq_r2r(mm7, mm0);				// copy tmp0
+
+	psubw_m2r(*(wsptr+2), mm5);	// tmp2 = tmp11 - tmp12;
+	paddw_r2r(mm3, mm7);				// wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7);
+	
+	psubw_r2r(mm3, mm0);				// wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7);
+
+	movq_r2m(mm7, *(wsptr));		// wsptr[DCTSIZE*0]
+	movq_r2r(mm1, mm3);				// copy tmp1
+
+	movq_r2m(mm0, *(wsptr+14));		// wsptr[DCTSIZE*7]
+	paddw_r2r(mm2, mm1);				// wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6);
+
+	psubw_r2r(mm2, mm3);				// wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6);
+
+	movq_r2m(mm1, *(wsptr+2));		// wsptr[DCTSIZE*1]
+	movq_r2r(mm4, mm1);				// copy tmp3
+
+	movq_r2m(mm3, *(wsptr+12));		// wsptr[DCTSIZE*6]
+
+	paddw_m2r(*(wsptr+4), mm4);	// wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4);
+
+	psubw_m2r(*(wsptr+4), mm1);	// wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4);
+
+	movq_r2m(mm4, *(wsptr+8));		
+	movq_r2r(mm5, mm7);				// copy tmp2
+
+	paddw_r2r(mm6, mm5);				// wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5)
+
+	movq_r2m(mm1, *(wsptr+6));		
+	psubw_r2r(mm6, mm7);				// wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5);
+
+	movq_r2m(mm5, *(wsptr+4));	
+
+	movq_r2m(mm7, *(wsptr+10));
+
+/*****************************************************************/
+
+  /* Pass 2: process rows from work array, store into output array. */
+  /* Note that we must descale the results by a factor of 8 == 2**3, */
+  /* and also undo the PASS1_BITS scaling. */
+
+/*****************************************************************/
+    /* Even part */
+
+	wsptr--;
+
+//    tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]);
+//    tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]);
+//    tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]);
+//    tmp14 = ((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6]);
+	movq_m2r(*(wsptr), mm0);		// wsptr[0,0],[0,1],[0,2],[0,3]
+
+	movq_m2r(*(wsptr+1),	mm1);		// wsptr[0,4],[0,5],[0,6],[0,7]
+	movq_r2r(mm0, mm2);
+	
+	movq_m2r(*(wsptr+2), mm3);		// wsptr[1,0],[1,1],[1,2],[1,3]
+	paddw_r2r(mm1, mm0);				// wsptr[0,tmp10],[xxx],[0,tmp13],[xxx]
+
+	movq_m2r(*(wsptr+3), mm4);		// wsptr[1,4],[1,5],[1,6],[1,7]
+	psubw_r2r(mm1, mm2);				// wsptr[0,tmp11],[xxx],[0,tmp14],[xxx]
+
+	movq_r2r(mm0, mm6);
+	movq_r2r(mm3, mm5);
+	
+	paddw_r2r(mm4, mm3);				// wsptr[1,tmp10],[xxx],[1,tmp13],[xxx]
+	movq_r2r(mm2, mm1);
+
+	psubw_r2r(mm4, mm5);				// wsptr[1,tmp11],[xxx],[1,tmp14],[xxx]
+	punpcklwd_r2r(mm3, mm0);		// wsptr[0,tmp10],[1,tmp10],[xxx],[xxx]
+
+	movq_m2r(*(wsptr+7), mm7);		// wsptr[3,4],[3,5],[3,6],[3,7]
+	punpckhwd_r2r(mm3, mm6);		// wsptr[0,tmp13],[1,tmp13],[xxx],[xxx]
+
+	movq_m2r(*(wsptr+4), mm3);		// wsptr[2,0],[2,1],[2,2],[2,3]
+	punpckldq_r2r(mm6, mm0);		// wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13]
+
+	punpcklwd_r2r(mm5, mm1);		// wsptr[0,tmp11],[1,tmp11],[xxx],[xxx]
+	movq_r2r(mm3, mm4);
+
+	movq_m2r(*(wsptr+6), mm6);		// wsptr[3,0],[3,1],[3,2],[3,3]
+	punpckhwd_r2r(mm5, mm2);		// wsptr[0,tmp14],[1,tmp14],[xxx],[xxx]
+
+	movq_m2r(*(wsptr+5), mm5);		// wsptr[2,4],[2,5],[2,6],[2,7]
+	punpckldq_r2r(mm2, mm1);		// wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14]
+
+	
+	paddw_r2r(mm5, mm3);				// wsptr[2,tmp10],[xxx],[2,tmp13],[xxx]
+	movq_r2r(mm6, mm2);
+
+	psubw_r2r(mm5, mm4);				// wsptr[2,tmp11],[xxx],[2,tmp14],[xxx]
+	paddw_r2r(mm7, mm6);				// wsptr[3,tmp10],[xxx],[3,tmp13],[xxx]
+
+	movq_r2r(mm3, mm5);
+	punpcklwd_r2r(mm6, mm3);		// wsptr[2,tmp10],[3,tmp10],[xxx],[xxx]
+	
+	psubw_r2r(mm7, mm2);				// wsptr[3,tmp11],[xxx],[3,tmp14],[xxx]
+	punpckhwd_r2r(mm6, mm5);		// wsptr[2,tmp13],[3,tmp13],[xxx],[xxx]
+
+	movq_r2r(mm4, mm7);
+	punpckldq_r2r(mm5, mm3);		// wsptr[2,tmp10],[3,tmp10],[2,tmp13],[3,tmp13]
+						 
+	punpcklwd_r2r(mm2, mm4);		// wsptr[2,tmp11],[3,tmp11],[xxx],[xxx]
+
+	punpckhwd_r2r(mm2, mm7);		// wsptr[2,tmp14],[3,tmp14],[xxx],[xxx]
+
+	punpckldq_r2r(mm7, mm4);		// wsptr[2,tmp11],[3,tmp11],[2,tmp14],[3,tmp14]
+	movq_r2r(mm1, mm6);
+
+	//ok
+
+//	mm0 = 	;wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13]
+//	mm1 =	;wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14]
+
+
+	movq_r2r(mm0, mm2);
+	punpckhdq_r2r(mm4, mm6);		// wsptr[0,tmp14],[1,tmp14],[2,tmp14],[3,tmp14]
+
+	punpckldq_r2r(mm4, mm1);		// wsptr[0,tmp11],[1,tmp11],[2,tmp11],[3,tmp11]
+	psllw_i2r(2, mm6);
+
+	pmulhw_m2r(fix_141, mm6);
+	punpckldq_r2r(mm3, mm0);		// wsptr[0,tmp10],[1,tmp10],[2,tmp10],[3,tmp10]
+
+	punpckhdq_r2r(mm3, mm2);		// wsptr[0,tmp13],[1,tmp13],[2,tmp13],[3,tmp13]
+	movq_r2r(mm0, mm7);
+
+//    tmp0 = tmp10 + tmp13;
+//    tmp3 = tmp10 - tmp13;
+	paddw_r2r(mm2, mm0);				// [0,tmp0],[1,tmp0],[2,tmp0],[3,tmp0]
+	psubw_r2r(mm2, mm7);				// [0,tmp3],[1,tmp3],[2,tmp3],[3,tmp3]
+
+//    tmp12 = MULTIPLY(tmp14, FIX_1_414213562) - tmp13;
+	psubw_r2r(mm2, mm6);				// wsptr[0,tmp12],[1,tmp12],[2,tmp12],[3,tmp12]
+//    tmp1 = tmp11 + tmp12;
+//    tmp2 = tmp11 - tmp12;
+	movq_r2r(mm1, mm5);
+
+	//OK
+
+    /* Odd part */
+
+//    z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3];
+//    z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3];
+//    z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7];
+//    z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7];
+	movq_m2r(*(wsptr), mm3);		// wsptr[0,0],[0,1],[0,2],[0,3]
+	paddw_r2r(mm6, mm1);				// [0,tmp1],[1,tmp1],[2,tmp1],[3,tmp1]
+
+	movq_m2r(*(wsptr+1), mm4);		// wsptr[0,4],[0,5],[0,6],[0,7]
+	psubw_r2r(mm6, mm5);				// [0,tmp2],[1,tmp2],[2,tmp2],[3,tmp2]
+
+	movq_r2r(mm3, mm6);
+	punpckldq_r2r(mm4, mm3);		// wsptr[0,0],[0,1],[0,4],[0,5]
+
+	punpckhdq_r2r(mm6, mm4);		// wsptr[0,6],[0,7],[0,2],[0,3]
+	movq_r2r(mm3, mm2);
+
+//Save tmp0 and tmp1 in wsptr
+	movq_r2m(mm0, *(wsptr));		// save tmp0
+	paddw_r2r(mm4, mm2);				// wsptr[xxx],[0,z11],[xxx],[0,z13]
+
+	
+//Continue with z10 --- z13
+	movq_m2r(*(wsptr+2), mm6);		// wsptr[1,0],[1,1],[1,2],[1,3]
+	psubw_r2r(mm4, mm3);				// wsptr[xxx],[0,z12],[xxx],[0,z10]
+
+	movq_m2r(*(wsptr+3), mm0);		// wsptr[1,4],[1,5],[1,6],[1,7]
+	movq_r2r(mm6, mm4);
+
+	movq_r2m(mm1, *(wsptr+1));		// save tmp1
+	punpckldq_r2r(mm0, mm6);		// wsptr[1,0],[1,1],[1,4],[1,5]
+
+	punpckhdq_r2r(mm4, mm0);		// wsptr[1,6],[1,7],[1,2],[1,3]
+	movq_r2r(mm6, mm1);
+	
+//Save tmp2 and tmp3 in wsptr
+	paddw_r2r(mm0, mm6);				// wsptr[xxx],[1,z11],[xxx],[1,z13]
+	movq_r2r(mm2, mm4);
+	
+//Continue with z10 --- z13
+	movq_r2m(mm5, *(wsptr+2));		// save tmp2
+	punpcklwd_r2r(mm6, mm2);		// wsptr[xxx],[xxx],[0,z11],[1,z11]
+
+	psubw_r2r(mm0, mm1);				// wsptr[xxx],[1,z12],[xxx],[1,z10]
+	punpckhwd_r2r(mm6, mm4);		// wsptr[xxx],[xxx],[0,z13],[1,z13]
+
+	movq_r2r(mm3, mm0);
+	punpcklwd_r2r(mm1, mm3);		// wsptr[xxx],[xxx],[0,z12],[1,z12]
+
+	movq_r2m(mm7, *(wsptr+3));		// save tmp3
+	punpckhwd_r2r(mm1, mm0);		// wsptr[xxx],[xxx],[0,z10],[1,z10]
+
+	movq_m2r(*(wsptr+4), mm6);		// wsptr[2,0],[2,1],[2,2],[2,3]
+	punpckhdq_r2r(mm2, mm0);		// wsptr[0,z10],[1,z10],[0,z11],[1,z11]
+
+	movq_m2r(*(wsptr+5), mm7);	// wsptr[2,4],[2,5],[2,6],[2,7]
+	punpckhdq_r2r(mm4, mm3);		// wsptr[0,z12],[1,z12],[0,z13],[1,z13]
+
+	movq_m2r(*(wsptr+6), mm1);	// wsptr[3,0],[3,1],[3,2],[3,3]
+	movq_r2r(mm6, mm4);
+
+	punpckldq_r2r(mm7, mm6);		// wsptr[2,0],[2,1],[2,4],[2,5]
+	movq_r2r(mm1, mm5);
+
+	punpckhdq_r2r(mm4, mm7);		// wsptr[2,6],[2,7],[2,2],[2,3]
+	movq_r2r(mm6, mm2);
+	
+	movq_m2r(*(wsptr+7), mm4);	// wsptr[3,4],[3,5],[3,6],[3,7]
+	paddw_r2r(mm7, mm6);				// wsptr[xxx],[2,z11],[xxx],[2,z13]
+
+	psubw_r2r(mm7, mm2);				// wsptr[xxx],[2,z12],[xxx],[2,z10]
+	punpckldq_r2r(mm4, mm1);		// wsptr[3,0],[3,1],[3,4],[3,5]
+
+	punpckhdq_r2r(mm5, mm4);		// wsptr[3,6],[3,7],[3,2],[3,3]
+	movq_r2r(mm1, mm7);
+
+	paddw_r2r(mm4, mm1);				// wsptr[xxx],[3,z11],[xxx],[3,z13]
+	psubw_r2r(mm4, mm7);				// wsptr[xxx],[3,z12],[xxx],[3,z10]
+
+	movq_r2r(mm6, mm5);
+	punpcklwd_r2r(mm1, mm6);		// wsptr[xxx],[xxx],[2,z11],[3,z11]
+
+	punpckhwd_r2r(mm1, mm5);		// wsptr[xxx],[xxx],[2,z13],[3,z13]
+	movq_r2r(mm2, mm4);
+
+	punpcklwd_r2r(mm7, mm2);		// wsptr[xxx],[xxx],[2,z12],[3,z12]
+
+	punpckhwd_r2r(mm7, mm4);		// wsptr[xxx],[xxx],[2,z10],[3,z10]
+
+	punpckhdq_r2r(mm6, mm4);		/// wsptr[2,z10],[3,z10],[2,z11],[3,z11]
+
+	punpckhdq_r2r(mm5, mm2);		// wsptr[2,z12],[3,z12],[2,z13],[3,z13]
+	movq_r2r(mm0, mm5);
+
+	punpckldq_r2r(mm4, mm0);		// wsptr[0,z10],[1,z10],[2,z10],[3,z10]
+
+	punpckhdq_r2r(mm4, mm5);		// wsptr[0,z11],[1,z11],[2,z11],[3,z11]
+	movq_r2r(mm3, mm4);
+
+	punpckhdq_r2r(mm2, mm4);		// wsptr[0,z13],[1,z13],[2,z13],[3,z13]
+	movq_r2r(mm5, mm1);
+
+	punpckldq_r2r(mm2, mm3);		// wsptr[0,z12],[1,z12],[2,z12],[3,z12]
+//    tmp7 = z11 + z13;		/* phase 5 */
+//    tmp8 = z11 - z13;		/* phase 5 */
+	psubw_r2r(mm4, mm1);				// tmp8
+
+	paddw_r2r(mm4, mm5);				// tmp7
+//    tmp21 = MULTIPLY(tmp8, FIX_1_414213562); /* 2*c4 */
+	psllw_i2r(2, mm1);
+
+	psllw_i2r(2, mm0);
+
+	pmulhw_m2r(fix_141, mm1);		// tmp21
+//    tmp20 = MULTIPLY(z12, (FIX_1_082392200- FIX_1_847759065))  /* 2*(c2-c6) */
+//			+ MULTIPLY(z10, - FIX_1_847759065); /* 2*c2 */
+	psllw_i2r(2, mm3);
+	movq_r2r(mm0, mm7);
+
+	pmulhw_m2r(fix_n184, mm7);
+	movq_r2r(mm3, mm6);
+
+	movq_m2r(*(wsptr), mm2);		// tmp0,final1
+
+	pmulhw_m2r(fix_108n184, mm6);
+//	 tmp22 = MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) /* -2*(c2+c6) */
+//			+ MULTIPLY(z12, FIX_1_847759065); /* 2*c2 */
+	movq_r2r(mm2, mm4);				// final1
+  
+	pmulhw_m2r(fix_184n261, mm0);
+	paddw_r2r(mm5, mm2);				// tmp0+tmp7,final1
+
+	pmulhw_m2r(fix_184, mm3);
+	psubw_r2r(mm5, mm4);				// tmp0-tmp7,final1
+
+//    tmp6 = tmp22 - tmp7;	/* phase 2 */
+	psraw_i2r(3, mm2);				// outptr[0,0],[1,0],[2,0],[3,0],final1
+
+	paddw_r2r(mm6, mm7);				// tmp20
+	psraw_i2r(3, mm4);				// outptr[0,7],[1,7],[2,7],[3,7],final1
+
+	paddw_r2r(mm0, mm3);				// tmp22
+
+//    tmp5 = tmp21 - tmp6;
+	psubw_r2r(mm5, mm3);				// tmp6
+
+//    tmp4 = tmp20 + tmp5;
+	movq_m2r(*(wsptr+1), mm0);		// tmp1,final2
+	psubw_r2r(mm3, mm1);				// tmp5
+
+	movq_r2r(mm0, mm6);				// final2
+	paddw_r2r(mm3, mm0);				// tmp1+tmp6,final2
+
+    /* Final output stage: scale down by a factor of 8 and range-limit */
+
+
+//    outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3)
+//			    & RANGE_MASK];	final1
+
+
+//    outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3)
+//			    & RANGE_MASK];	final2
+	psubw_r2r(mm3, mm6);				// tmp1-tmp6,final2
+	psraw_i2r(3, mm0);				// outptr[0,1],[1,1],[2,1],[3,1]
+
+	psraw_i2r(3, mm6);				// outptr[0,6],[1,6],[2,6],[3,6]
+	
+	packuswb_r2r(mm4, mm0);			// out[0,1],[1,1],[2,1],[3,1],[0,7],[1,7],[2,7],[3,7]
+	
+	movq_m2r(*(wsptr+2), mm5);		// tmp2,final3
+	packuswb_r2r(mm6, mm2);			// out[0,0],[1,0],[2,0],[3,0],[0,6],[1,6],[2,6],[3,6]
+
+//    outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3)
+//			    & RANGE_MASK];	final3
+	paddw_r2r(mm1, mm7);				// tmp4
+	movq_r2r(mm5, mm3);
+
+	paddw_r2r(mm1, mm5);				// tmp2+tmp5
+	psubw_r2r(mm1, mm3);				// tmp2-tmp5
+
+	psraw_i2r(3, mm5);				// outptr[0,2],[1,2],[2,2],[3,2]
+
+	movq_m2r(*(wsptr+3), mm4);		// tmp3,final4
+	psraw_i2r(3, mm3);				// outptr[0,5],[1,5],[2,5],[3,5]
+
+
+
+//    outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3)
+//			    & RANGE_MASK];	final4
+	movq_r2r(mm4, mm6);
+	paddw_r2r(mm7, mm4);				// tmp3+tmp4
+
+	psubw_r2r(mm7, mm6);				// tmp3-tmp4
+	psraw_i2r(3, mm4);				// outptr[0,4],[1,4],[2,4],[3,4]
+
+	// mov			ecx, [dataptr]
+
+	psraw_i2r(3, mm6);				// outptr[0,3],[1,3],[2,3],[3,3]
+
+	packuswb_r2r(mm4, mm5);			// out[0,2],[1,2],[2,2],[3,2],[0,4],[1,4],[2,4],[3,4]
+
+	packuswb_r2r(mm3, mm6);			// out[0,3],[1,3],[2,3],[3,3],[0,5],[1,5],[2,5],[3,5]
+	movq_r2r(mm2, mm4);
+
+	movq_r2r(mm5, mm7);
+	punpcklbw_r2r(mm0, mm2);		// out[0,0],[0,1],[1,0],[1,1],[2,0],[2,1],[3,0],[3,1]
+
+	punpckhbw_r2r(mm0, mm4);		// out[0,6],[0,7],[1,6],[1,7],[2,6],[2,7],[3,6],[3,7]
+	movq_r2r(mm2, mm1);
+
+	punpcklbw_r2r(mm6, mm5);		// out[0,2],[0,3],[1,2],[1,3],[2,2],[2,3],[3,2],[3,3]
+
+	// add		 	dataptr, 4
+
+	punpckhbw_r2r(mm6, mm7);		// out[0,4],[0,5],[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]
+
+	punpcklwd_r2r(mm5, mm2);		// out[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3]
+	
+	// add			ecx, output_col
+
+	movq_r2r(mm7, mm6);
+	punpckhwd_r2r(mm5, mm1);		// out[2,0],[2,1],[2,2],[2,3],[3,0],[3,1],[3,2],[3,3]
+
+	movq_r2r(mm2, mm0);
+	punpcklwd_r2r(mm4, mm6);		// out[0,4],[0,5],[0,6],[0,7],[1,4],[1,5],[1,6],[1,7]
+
+	// mov			idata, [dataptr]
+	
+	punpckldq_r2r(mm6, mm2);		// out[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7]
+
+	// add		 	dataptr, 4
+	 
+	movq_r2r(mm1, mm3);
+
+	// add			idata, output_col 
+	
+	punpckhwd_r2r(mm4, mm7);		// out[2,4],[2,5],[2,6],[2,7],[3,4],[3,5],[3,6],[3,7]
+	
+	movq_r2m(mm2, *(dataptr));
+	
+	punpckhdq_r2r(mm6, mm0);		// out[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]
+
+	dataptr += rskip;
+	movq_r2m(mm0, *(dataptr));
+
+	punpckldq_r2r(mm7, mm1);		// out[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7]
+	punpckhdq_r2r(mm7, mm3);		// out[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7]
+	
+	dataptr += rskip;
+	movq_r2m(mm1, *(dataptr));
+
+	dataptr += rskip;
+	movq_r2m(mm3, *(dataptr));
+
+/*******************************************************************/
+
+	wsptr += 8;
+
+/*******************************************************************/
+
+//    tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]);
+//    tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]);
+//    tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]);
+//    tmp14 = ((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6]);
+	movq_m2r(*(wsptr), mm0);		// wsptr[0,0],[0,1],[0,2],[0,3]
+
+	movq_m2r(*(wsptr+1), mm1);		// wsptr[0,4],[0,5],[0,6],[0,7]
+	movq_r2r(mm0, mm2);
+	
+	movq_m2r(*(wsptr+2), mm3);		// wsptr[1,0],[1,1],[1,2],[1,3]
+	paddw_r2r(mm1, mm0);				// wsptr[0,tmp10],[xxx],[0,tmp13],[xxx]
+
+	movq_m2r(*(wsptr+3), mm4);		// wsptr[1,4],[1,5],[1,6],[1,7]
+	psubw_r2r(mm1, mm2);				// wsptr[0,tmp11],[xxx],[0,tmp14],[xxx]
+
+	movq_r2r(mm0, mm6);
+	movq_r2r(mm3, mm5);
+	
+	paddw_r2r(mm4, mm3);				// wsptr[1,tmp10],[xxx],[1,tmp13],[xxx]
+	movq_r2r(mm2, mm1);
+
+	psubw_r2r(mm4, mm5);				// wsptr[1,tmp11],[xxx],[1,tmp14],[xxx]
+	punpcklwd_r2r(mm3, mm0);		// wsptr[0,tmp10],[1,tmp10],[xxx],[xxx]
+
+	movq_m2r(*(wsptr+7), mm7);	// wsptr[3,4],[3,5],[3,6],[3,7]
+	punpckhwd_r2r(mm3, mm6);		// wsptr[0,tmp13],[1,tmp13],[xxx],[xxx]
+
+	movq_m2r(*(wsptr+4),	mm3);		// wsptr[2,0],[2,1],[2,2],[2,3]
+	punpckldq_r2r(mm6, mm0);		// wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13]
+
+	punpcklwd_r2r(mm5, mm1);		// wsptr[0,tmp11],[1,tmp11],[xxx],[xxx]
+	movq_r2r(mm3, mm4);
+
+	movq_m2r(*(wsptr+6), mm6);	// wsptr[3,0],[3,1],[3,2],[3,3]
+	punpckhwd_r2r(mm5, mm2);		// wsptr[0,tmp14],[1,tmp14],[xxx],[xxx]
+
+	movq_m2r(*(wsptr+5), mm5);	// wsptr[2,4],[2,5],[2,6],[2,7]
+	punpckldq_r2r(mm2, mm1);		// wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14]
+
+	paddw_r2r(mm5, mm3);				// wsptr[2,tmp10],[xxx],[2,tmp13],[xxx]
+	movq_r2r(mm6, mm2);
+
+	psubw_r2r(mm5, mm4);				// wsptr[2,tmp11],[xxx],[2,tmp14],[xxx]
+	paddw_r2r(mm7, mm6);				// wsptr[3,tmp10],[xxx],[3,tmp13],[xxx]
+
+	movq_r2r(mm3, mm5);
+	punpcklwd_r2r(mm6, mm3);		// wsptr[2,tmp10],[3,tmp10],[xxx],[xxx]
+	
+	psubw_r2r(mm7, mm2);				// wsptr[3,tmp11],[xxx],[3,tmp14],[xxx]
+	punpckhwd_r2r(mm6, mm5);		// wsptr[2,tmp13],[3,tmp13],[xxx],[xxx]
+
+	movq_r2r(mm4, mm7);
+	punpckldq_r2r(mm5, mm3);		// wsptr[2,tmp10],[3,tmp10],[2,tmp13],[3,tmp13]
+
+	punpcklwd_r2r(mm2, mm4);		// wsptr[2,tmp11],[3,tmp11],[xxx],[xxx]
+
+	punpckhwd_r2r(mm2, mm7);		// wsptr[2,tmp14],[3,tmp14],[xxx],[xxx]
+
+	punpckldq_r2r(mm7, mm4);		// wsptr[2,tmp11],[3,tmp11],[2,tmp14],[3,tmp14]
+	movq_r2r(mm1, mm6);
+
+	//OK
+
+//	mm0 = 	;wsptr[0,tmp10],[1,tmp10],[0,tmp13],[1,tmp13]
+//	mm1 =	;wsptr[0,tmp11],[1,tmp11],[0,tmp14],[1,tmp14]
+
+	movq_r2r(mm0, mm2);
+	punpckhdq_r2r(mm4, mm6);		// wsptr[0,tmp14],[1,tmp14],[2,tmp14],[3,tmp14]
+
+	punpckldq_r2r(mm4, mm1);		// wsptr[0,tmp11],[1,tmp11],[2,tmp11],[3,tmp11]
+	psllw_i2r(2, mm6);
+
+	pmulhw_m2r(fix_141, mm6);
+	punpckldq_r2r(mm3, mm0);		// wsptr[0,tmp10],[1,tmp10],[2,tmp10],[3,tmp10]
+
+	punpckhdq_r2r(mm3, mm2);		// wsptr[0,tmp13],[1,tmp13],[2,tmp13],[3,tmp13]
+	movq_r2r(mm0, mm7);
+
+//    tmp0 = tmp10 + tmp13;
+//    tmp3 = tmp10 - tmp13;
+	paddw_r2r(mm2, mm0);				// [0,tmp0],[1,tmp0],[2,tmp0],[3,tmp0]
+	psubw_r2r(mm2, mm7);				// [0,tmp3],[1,tmp3],[2,tmp3],[3,tmp3]
+
+//    tmp12 = MULTIPLY(tmp14, FIX_1_414213562) - tmp13;
+	psubw_r2r(mm2, mm6);				// wsptr[0,tmp12],[1,tmp12],[2,tmp12],[3,tmp12]
+//    tmp1 = tmp11 + tmp12;
+//    tmp2 = tmp11 - tmp12;
+	movq_r2r(mm1, mm5);
+
+	 //OK
+
+
+    /* Odd part */
+
+//    z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3];
+//    z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3];
+//    z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7];
+//    z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7];
+	movq_m2r(*(wsptr), mm3);		// wsptr[0,0],[0,1],[0,2],[0,3]
+	paddw_r2r(mm6, mm1);				// [0,tmp1],[1,tmp1],[2,tmp1],[3,tmp1]
+
+	movq_m2r(*(wsptr+1),	mm4);		// wsptr[0,4],[0,5],[0,6],[0,7]
+	psubw_r2r(mm6, mm5);				// [0,tmp2],[1,tmp2],[2,tmp2],[3,tmp2]
+
+	movq_r2r(mm3, mm6);
+	punpckldq_r2r(mm4, mm3);		// wsptr[0,0],[0,1],[0,4],[0,5]
+
+	punpckhdq_r2r(mm6, mm4);		// wsptr[0,6],[0,7],[0,2],[0,3]
+	movq_r2r(mm3, mm2);
+
+//Save tmp0 and tmp1 in wsptr
+	movq_r2m(mm0, *(wsptr));		// save tmp0
+	paddw_r2r(mm4, mm2);				// wsptr[xxx],[0,z11],[xxx],[0,z13]
+
+	
+//Continue with z10 --- z13
+	movq_m2r(*(wsptr+2), mm6);		// wsptr[1,0],[1,1],[1,2],[1,3]
+	psubw_r2r(mm4, mm3);				// wsptr[xxx],[0,z12],[xxx],[0,z10]
+
+	movq_m2r(*(wsptr+3), mm0);		// wsptr[1,4],[1,5],[1,6],[1,7]
+	movq_r2r(mm6, mm4);
+
+	movq_r2m(mm1, *(wsptr+1));		// save tmp1
+	punpckldq_r2r(mm0, mm6);		// wsptr[1,0],[1,1],[1,4],[1,5]
+
+	punpckhdq_r2r(mm4, mm0);		// wsptr[1,6],[1,7],[1,2],[1,3]
+	movq_r2r(mm6, mm1);
+	
+//Save tmp2 and tmp3 in wsptr
+	paddw_r2r(mm0, mm6);				// wsptr[xxx],[1,z11],[xxx],[1,z13]
+	movq_r2r(mm2, mm4);
+	
+//Continue with z10 --- z13
+	movq_r2m(mm5, *(wsptr+2));		// save tmp2
+	punpcklwd_r2r(mm6, mm2);		// wsptr[xxx],[xxx],[0,z11],[1,z11]
+
+	psubw_r2r(mm0, mm1);				// wsptr[xxx],[1,z12],[xxx],[1,z10]
+	punpckhwd_r2r(mm6, mm4);		// wsptr[xxx],[xxx],[0,z13],[1,z13]
+
+	movq_r2r(mm3, mm0);
+	punpcklwd_r2r(mm1, mm3);		// wsptr[xxx],[xxx],[0,z12],[1,z12]
+
+	movq_r2m(mm7, *(wsptr+3));		// save tmp3
+	punpckhwd_r2r(mm1, mm0);		// wsptr[xxx],[xxx],[0,z10],[1,z10]
+
+	movq_m2r(*(wsptr+4), mm6);		// wsptr[2,0],[2,1],[2,2],[2,3]
+	punpckhdq_r2r(mm2, mm0);		// wsptr[0,z10],[1,z10],[0,z11],[1,z11]
+
+	movq_m2r(*(wsptr+5), mm7);	// wsptr[2,4],[2,5],[2,6],[2,7]
+	punpckhdq_r2r(mm4, mm3);		// wsptr[0,z12],[1,z12],[0,z13],[1,z13]
+
+	movq_m2r(*(wsptr+6), mm1);	// wsptr[3,0],[3,1],[3,2],[3,3]
+	movq_r2r(mm6, mm4);
+
+	punpckldq_r2r(mm7, mm6);		// wsptr[2,0],[2,1],[2,4],[2,5]
+	movq_r2r(mm1, mm5);
+
+	punpckhdq_r2r(mm4, mm7);		// wsptr[2,6],[2,7],[2,2],[2,3]
+	movq_r2r(mm6, mm2);
+	
+	movq_m2r(*(wsptr+7), mm4);	// wsptr[3,4],[3,5],[3,6],[3,7]
+	paddw_r2r(mm7, mm6);				// wsptr[xxx],[2,z11],[xxx],[2,z13]
+
+	psubw_r2r(mm7, mm2);				// wsptr[xxx],[2,z12],[xxx],[2,z10]
+	punpckldq_r2r(mm4, mm1);		// wsptr[3,0],[3,1],[3,4],[3,5]
+
+	punpckhdq_r2r(mm5, mm4);		// wsptr[3,6],[3,7],[3,2],[3,3]
+	movq_r2r(mm1, mm7);
+
+	paddw_r2r(mm4, mm1);				// wsptr[xxx],[3,z11],[xxx],[3,z13]
+	psubw_r2r(mm4, mm7);				// wsptr[xxx],[3,z12],[xxx],[3,z10]
+
+	movq_r2r(mm6, mm5);
+	punpcklwd_r2r(mm1, mm6);		// wsptr[xxx],[xxx],[2,z11],[3,z11]
+
+	punpckhwd_r2r(mm1, mm5);		// wsptr[xxx],[xxx],[2,z13],[3,z13]
+	movq_r2r(mm2, mm4);
+
+	punpcklwd_r2r(mm7, mm2);		// wsptr[xxx],[xxx],[2,z12],[3,z12]
+
+	punpckhwd_r2r(mm7, mm4);		// wsptr[xxx],[xxx],[2,z10],[3,z10]
+
+	punpckhdq_r2r(mm6, mm4);		// wsptr[2,z10],[3,z10],[2,z11],[3,z11]
+
+	punpckhdq_r2r(mm5, mm2);		// wsptr[2,z12],[3,z12],[2,z13],[3,z13]
+	movq_r2r(mm0, mm5);
+
+	punpckldq_r2r(mm4, mm0);		// wsptr[0,z10],[1,z10],[2,z10],[3,z10]
+
+	punpckhdq_r2r(mm4, mm5);		// wsptr[0,z11],[1,z11],[2,z11],[3,z11]
+	movq_r2r(mm3, mm4);
+
+	punpckhdq_r2r(mm2, mm4);		// wsptr[0,z13],[1,z13],[2,z13],[3,z13]
+	movq_r2r(mm5, mm1);
+
+	punpckldq_r2r(mm2, mm3);		// wsptr[0,z12],[1,z12],[2,z12],[3,z12]
+//    tmp7 = z11 + z13;		/* phase 5 */
+//    tmp8 = z11 - z13;		/* phase 5 */
+	psubw_r2r(mm4, mm1);				// tmp8
+
+	paddw_r2r(mm4, mm5);				// tmp7
+//    tmp21 = MULTIPLY(tmp8, FIX_1_414213562); /* 2*c4 */
+	psllw_i2r(2, mm1);
+
+	psllw_i2r(2, mm0);
+
+	pmulhw_m2r(fix_141, mm1);		// tmp21
+//    tmp20 = MULTIPLY(z12, (FIX_1_082392200- FIX_1_847759065))  /* 2*(c2-c6) */
+//			+ MULTIPLY(z10, - FIX_1_847759065); /* 2*c2 */
+	psllw_i2r(2, mm3);
+	movq_r2r(mm0, mm7);
+
+	pmulhw_m2r(fix_n184, mm7);
+	movq_r2r(mm3, mm6);
+
+	movq_m2r(*(wsptr), mm2);		// tmp0,final1
+
+	pmulhw_m2r(fix_108n184, mm6);
+//	 tmp22 = MULTIPLY(z10,(FIX_1_847759065 - FIX_2_613125930)) /* -2*(c2+c6) */
+//			+ MULTIPLY(z12, FIX_1_847759065); /* 2*c2 */
+	movq_r2r(mm2, mm4);				// final1
+  
+	pmulhw_m2r(fix_184n261, mm0);
+	paddw_r2r(mm5, mm2);				// tmp0+tmp7,final1
+
+	pmulhw_m2r(fix_184, mm3);
+	psubw_r2r(mm5, mm4);				// tmp0-tmp7,final1
+
+//    tmp6 = tmp22 - tmp7;	/* phase 2 */
+	psraw_i2r(3, mm2);				// outptr[0,0],[1,0],[2,0],[3,0],final1
+
+	paddw_r2r(mm6, mm7);				// tmp20
+	psraw_i2r(3, mm4);				// outptr[0,7],[1,7],[2,7],[3,7],final1
+
+	paddw_r2r(mm0, mm3);				// tmp22
+
+//    tmp5 = tmp21 - tmp6;
+	psubw_r2r(mm5, mm3);				// tmp6
+
+//    tmp4 = tmp20 + tmp5;
+	movq_m2r(*(wsptr+1), mm0);		// tmp1,final2
+	psubw_r2r(mm3, mm1);				// tmp5
+
+	movq_r2r(mm0, mm6);				// final2
+	paddw_r2r(mm3, mm0);				// tmp1+tmp6,final2
+
+    /* Final output stage: scale down by a factor of 8 and range-limit */
+
+//    outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3)
+//			    & RANGE_MASK];	final1
+
+
+//    outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3)
+//			    & RANGE_MASK];	final2
+	psubw_r2r(mm3, mm6);				// tmp1-tmp6,final2
+	psraw_i2r(3, mm0);				// outptr[0,1],[1,1],[2,1],[3,1]
+
+	psraw_i2r(3, mm6);				// outptr[0,6],[1,6],[2,6],[3,6]
+	
+	packuswb_r2r(mm4, mm0);			// out[0,1],[1,1],[2,1],[3,1],[0,7],[1,7],[2,7],[3,7]
+	
+	movq_m2r(*(wsptr+2), mm5);		// tmp2,final3
+	packuswb_r2r(mm6, mm2);			// out[0,0],[1,0],[2,0],[3,0],[0,6],[1,6],[2,6],[3,6]
+
+//    outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3)
+//			    & RANGE_MASK];	final3
+	paddw_r2r(mm1, mm7);				// tmp4
+	movq_r2r(mm5, mm3);
+
+	paddw_r2r(mm1, mm5);				// tmp2+tmp5
+	psubw_r2r(mm1, mm3);				// tmp2-tmp5
+
+	psraw_i2r(3, mm5);				// outptr[0,2],[1,2],[2,2],[3,2]
+
+	movq_m2r(*(wsptr+3), mm4);		// tmp3,final4
+	psraw_i2r(3, mm3);				// outptr[0,5],[1,5],[2,5],[3,5]
+
+
+
+//    outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3)
+//			    & RANGE_MASK];
+//    outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3)
+//			    & RANGE_MASK];	final4
+	movq_r2r(mm4, mm6);
+	paddw_r2r(mm7, mm4);				// tmp3+tmp4
+
+	psubw_r2r(mm7, mm6);				// tmp3-tmp4
+	psraw_i2r(3, mm4);				// outptr[0,4],[1,4],[2,4],[3,4]
+
+	psraw_i2r(3, mm6);				// outptr[0,3],[1,3],[2,3],[3,3]
+
+	/*
+   movq_r2m(mm4, *dummy);
+	fprintf(stderr, "3-4 %016llx\n", dummy);
+   movq_r2m(mm4, *dummy);
+	fprintf(stderr, "3+4 %016llx\n", dummy);
+	*/
+	
+
+	packuswb_r2r(mm4, mm5);			// out[0,2],[1,2],[2,2],[3,2],[0,4],[1,4],[2,4],[3,4]
+
+	packuswb_r2r(mm3, mm6);			// out[0,3],[1,3],[2,3],[3,3],[0,5],[1,5],[2,5],[3,5]
+	movq_r2r(mm2, mm4);
+
+	movq_r2r(mm5, mm7);
+	punpcklbw_r2r(mm0, mm2);		// out[0,0],[0,1],[1,0],[1,1],[2,0],[2,1],[3,0],[3,1]
+
+	punpckhbw_r2r(mm0, mm4);		// out[0,6],[0,7],[1,6],[1,7],[2,6],[2,7],[3,6],[3,7]
+	movq_r2r(mm2, mm1);
+
+	punpcklbw_r2r(mm6, mm5);		// out[0,2],[0,3],[1,2],[1,3],[2,2],[2,3],[3,2],[3,3]
+	
+	punpckhbw_r2r(mm6, mm7);		// out[0,4],[0,5],[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]
+
+	punpcklwd_r2r(mm5, mm2);		// out[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3]
+	
+	movq_r2r(mm7, mm6);
+	punpckhwd_r2r(mm5, mm1);		// out[2,0],[2,1],[2,2],[2,3],[3,0],[3,1],[3,2],[3,3]
+
+	movq_r2r(mm2, mm0);
+	punpcklwd_r2r(mm4, mm6);		// out[0,4],[0,5],[0,6],[0,7],[1,4],[1,5],[1,6],[1,7]
+
+	punpckldq_r2r(mm6, mm2);		// out[0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7]
+
+	movq_r2r(mm1, mm3);
+
+	punpckhwd_r2r(mm4, mm7);		// out[2,4],[2,5],[2,6],[2,7],[3,4],[3,5],[3,6],[3,7]
+	
+	dataptr += rskip;
+	movq_r2m(mm2, *(dataptr));
+
+	punpckhdq_r2r(mm6, mm0);		// out[1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]
+
+	dataptr += rskip;
+	movq_r2m(mm0, *(dataptr));
+
+	punpckldq_r2r(mm7, mm1);		// out[2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7]
+	
+	punpckhdq_r2r(mm7, mm3);		// out[3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7]
+
+	dataptr += rskip;
+	movq_r2m(mm1, *(dataptr));
+
+	dataptr += rskip;
+	movq_r2m(mm3, *(dataptr));
+
+#else
+  __s32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  __s32 tmp10, tmp11, tmp12, tmp13;
+  __s32 z5, z10, z11, z12, z13;
+  __s16 *inptr;
+  __s32 *wsptr;
+  __u8 *outptr;
+  int ctr;
+  __s32 dcval;
+  __s32 workspace[64];
+
+  inptr = data;
+  wsptr = workspace;
+  for (ctr = 8; ctr > 0; ctr--) {
+    
+    if ((inptr[8] | inptr[16] | inptr[24] |
+	 inptr[32] | inptr[40] | inptr[48] | inptr[56]) == 0) {
+      dcval = inptr[0];
+      wsptr[0] = dcval;
+      wsptr[8] = dcval;
+      wsptr[16] = dcval;
+      wsptr[24] = dcval;
+      wsptr[32] = dcval;
+      wsptr[40] = dcval;
+      wsptr[48] = dcval;
+      wsptr[56] = dcval;
+      
+      inptr++;	
+      wsptr++;
+      continue;
+    } 
+    
+    tmp0 = inptr[0];
+    tmp1 = inptr[16];
+    tmp2 = inptr[32];
+    tmp3 = inptr[48];
+
+    tmp10 = tmp0 + tmp2;
+    tmp11 = tmp0 - tmp2;
+
+    tmp13 = tmp1 + tmp3;
+    tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13;
+
+    tmp0 = tmp10 + tmp13;
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+    
+    tmp4 = inptr[8];
+    tmp5 = inptr[24];
+    tmp6 = inptr[40];
+    tmp7 = inptr[56];
+
+    z13 = tmp6 + tmp5;
+    z10 = tmp6 - tmp5;
+    z11 = tmp4 + tmp7;
+    z12 = tmp4 - tmp7;
+
+    tmp7 = z11 + z13;
+    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
+
+    z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
+    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
+    tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
+
+    tmp6 = tmp12 - tmp7;
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    wsptr[0] = (__s32) (tmp0 + tmp7);
+    wsptr[56] = (__s32) (tmp0 - tmp7);
+    wsptr[8] = (__s32) (tmp1 + tmp6);
+    wsptr[48] = (__s32) (tmp1 - tmp6);
+    wsptr[16] = (__s32) (tmp2 + tmp5);
+    wsptr[40] = (__s32) (tmp2 - tmp5);
+    wsptr[32] = (__s32) (tmp3 + tmp4);
+    wsptr[24] = (__s32) (tmp3 - tmp4);
+
+    inptr++;
+    wsptr++;
+  }
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < 8; ctr++) {
+    outptr = &(odata[ctr*rskip]);
+
+    tmp10 = wsptr[0] + wsptr[4];
+    tmp11 = wsptr[0] - wsptr[4];
+
+    tmp13 = wsptr[2] + wsptr[6];
+    tmp12 = MULTIPLY(wsptr[2] - wsptr[6], FIX_1_414213562) - tmp13;
+
+    tmp0 = tmp10 + tmp13;
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    z13 = wsptr[5] + wsptr[3];
+    z10 = wsptr[5] - wsptr[3];
+    z11 = wsptr[1] + wsptr[7];
+    z12 = wsptr[1] - wsptr[7];
+
+    tmp7 = z11 + z13;
+    tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
+
+    z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
+    tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
+    tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
+
+    tmp6 = tmp12 - tmp7;
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    outptr[0] = RL(DESCALE(tmp0 + tmp7));
+    outptr[7] = RL(DESCALE(tmp0 - tmp7));
+    outptr[1] = RL(DESCALE(tmp1 + tmp6));
+    outptr[6] = RL(DESCALE(tmp1 - tmp6));
+    outptr[2] = RL(DESCALE(tmp2 + tmp5));
+    outptr[5] = RL(DESCALE(tmp2 - tmp5));
+    outptr[4] = RL(DESCALE(tmp3 + tmp4));
+    outptr[3] = RL(DESCALE(tmp3 - tmp4));
+
+    wsptr += 8;
+  }
+#endif
+}
+/*
+
+Main Routines
+
+This file contains most of the initialisation and control functions
+
+(C) Justin Schoeman 1998
+
+*/
+
+/*
+
+Private function
+
+Initialise all the cache-aliged data blocks
+
+*/
+
+void RTjpeg_init_data(void)
+{
+ unsigned long dptr;
+ 
+ dptr=(unsigned long)&(RTjpeg_alldata[0]);
+ dptr+=32;
+ dptr=dptr>>5;
+ dptr=dptr<<5; /* cache align data */
+ 
+ RTjpeg_block=(__s16 *)dptr;
+ dptr+=sizeof(__s16)*64;
+ RTjpeg_lqt=(__s32 *)dptr;
+ dptr+=sizeof(__s32)*64;
+ RTjpeg_cqt=(__s32 *)dptr;
+ dptr+=sizeof(__s32)*64;
+ RTjpeg_liqt=(__u32 *)dptr;
+ dptr+=sizeof(__u32)*64;
+ RTjpeg_ciqt=(__u32 *)dptr;
+}
+
+/*
+
+External Function
+
+Re-set quality factor
+
+Input: buf -> pointer to 128 ints for quant values store to pass back to
+              init_decompress.
+       Q -> quality factor (192=best, 32=worst)
+*/
+
+void RTjpeg_init_Q(__u8 Q)
+{
+ int i;
+ __u64 qual;
+ 
+ qual=(__u64)Q<<(32-7); /* 32 bit FP, 255=2, 0=0 */
+
+ for(i=0; i<64; i++)
+ {
+  RTjpeg_lqt[i]=(__s32)((qual/((__u64)RTjpeg_lum_quant_tbl[i]<<16))>>3);
+  if(RTjpeg_lqt[i]==0)RTjpeg_lqt[i]=1;
+  RTjpeg_cqt[i]=(__s32)((qual/((__u64)RTjpeg_chrom_quant_tbl[i]<<16))>>3);
+  if(RTjpeg_cqt[i]==0)RTjpeg_cqt[i]=1;
+  RTjpeg_liqt[i]=(1<<16)/(RTjpeg_lqt[i]<<3);
+  RTjpeg_ciqt[i]=(1<<16)/(RTjpeg_cqt[i]<<3);
+  RTjpeg_lqt[i]=((1<<16)/RTjpeg_liqt[i])>>3;
+  RTjpeg_cqt[i]=((1<<16)/RTjpeg_ciqt[i])>>3;
+ }
+ 
+ RTjpeg_lb8=0;
+ while(RTjpeg_liqt[RTjpeg_ZZ[++RTjpeg_lb8]]<=8);
+ RTjpeg_lb8--;
+ RTjpeg_cb8=0;
+ while(RTjpeg_ciqt[RTjpeg_ZZ[++RTjpeg_cb8]]<=8);
+ RTjpeg_cb8--;
+
+ RTjpeg_dct_init();
+ RTjpeg_idct_init();
+ RTjpeg_quant_init();
+}
+
+/*
+
+External Function
+
+Initialise compression.
+
+Input: buf -> pointer to 128 ints for quant values store to pass back to 
+                init_decompress.
+       width -> width of image
+       height -> height of image
+       Q -> quality factor (192=best, 32=worst)
+       
+*/
+
+void RTjpeg_init_compress(__u32 *buf, int width, int height, __u8 Q)
+{
+ int i;
+ __u64 qual;
+ 
+ RTjpeg_init_data();
+ 
+ RTjpeg_width=width;
+ RTjpeg_height=height;
+ RTjpeg_Ywidth = RTjpeg_width>>3;
+ RTjpeg_Ysize=width * height;
+ RTjpeg_Cwidth = RTjpeg_width>>4;
+ RTjpeg_Csize= (width>>1) * height;
+
+ qual=(__u64)Q<<(32-7); /* 32 bit FP, 255=2, 0=0 */
+
+ for(i=0; i<64; i++)
+ {
+  RTjpeg_lqt[i]=(__s32)((qual/((__u64)RTjpeg_lum_quant_tbl[i]<<16))>>3);
+  if(RTjpeg_lqt[i]==0)RTjpeg_lqt[i]=1;
+  RTjpeg_cqt[i]=(__s32)((qual/((__u64)RTjpeg_chrom_quant_tbl[i]<<16))>>3);
+  if(RTjpeg_cqt[i]==0)RTjpeg_cqt[i]=1;
+  RTjpeg_liqt[i]=(1<<16)/(RTjpeg_lqt[i]<<3);
+  RTjpeg_ciqt[i]=(1<<16)/(RTjpeg_cqt[i]<<3);
+  RTjpeg_lqt[i]=((1<<16)/RTjpeg_liqt[i])>>3;
+  RTjpeg_cqt[i]=((1<<16)/RTjpeg_ciqt[i])>>3;
+ }
+ 
+ RTjpeg_lb8=0;
+ while(RTjpeg_liqt[RTjpeg_ZZ[++RTjpeg_lb8]]<=8);
+ RTjpeg_lb8--;
+ RTjpeg_cb8=0;
+ while(RTjpeg_ciqt[RTjpeg_ZZ[++RTjpeg_cb8]]<=8);
+ RTjpeg_cb8--;
+ 
+ RTjpeg_dct_init();
+ RTjpeg_quant_init();
+
+ for(i=0; i<64; i++)
+  buf[i]=RTjpeg_liqt[i];
+ for(i=0; i<64; i++)
+  buf[64+i]=RTjpeg_ciqt[i];
+}
+
+void RTjpeg_init_decompress(__u32 *buf, int width, int height)
+{
+ int i;
+
+ RTjpeg_init_data();
+ 
+ RTjpeg_width=width;
+ RTjpeg_height=height;
+ RTjpeg_Ywidth = RTjpeg_width>>3;
+ RTjpeg_Ysize=width * height;
+ RTjpeg_Cwidth = RTjpeg_width>>4;
+ RTjpeg_Csize= (width>>1) * height;
+
+ for(i=0; i<64; i++)
+ {
+  RTjpeg_liqt[i]=buf[i];
+  RTjpeg_ciqt[i]=buf[i+64];
+ }
+
+ RTjpeg_lb8=0;
+ while(RTjpeg_liqt[RTjpeg_ZZ[++RTjpeg_lb8]]<=8);
+ RTjpeg_lb8--;
+ RTjpeg_cb8=0;
+ while(RTjpeg_ciqt[RTjpeg_ZZ[++RTjpeg_cb8]]<=8);
+ RTjpeg_cb8--;
+
+ RTjpeg_idct_init();
+
+// RTjpeg_color_init();
+}
+
+int RTjpeg_compressYUV420(__s8 *sp, unsigned char *bp)
+{
+ __s8 * sb;
+ register __s8 * bp1 = bp + (RTjpeg_width<<3);
+ register __s8 * bp2 = bp + RTjpeg_Ysize;
+ register __s8 * bp3 = bp2 + (RTjpeg_Csize>>1);
+ register int i, j, k;
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ sb=sp;
+/* Y */
+ for(i=RTjpeg_height>>1; i; i-=8)
+ {
+  for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
+  {
+   RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+
+   RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+
+   RTjpeg_dctY(bp1+j, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+
+   RTjpeg_dctY(bp1+j+8, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+
+   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
+
+   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
+
+  }
+  bp+=RTjpeg_width<<4;
+  bp1+=RTjpeg_width<<4;
+  bp2+=RTjpeg_width<<2;
+  bp3+=RTjpeg_width<<2;
+			 
+ }
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ return (sp-sb);
+}
+
+int RTjpeg_compressYUV422(__s8 *sp, unsigned char *bp)
+{
+ __s8 * sb;
+ register __s8 * bp2 = bp + RTjpeg_Ysize;
+ register __s8 * bp3 = bp2 + RTjpeg_Csize;
+ register int i, j, k;
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ sb=sp;
+/* Y */
+ for(i=RTjpeg_height; i; i-=8)
+ {
+  for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
+  {
+   RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+
+   RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+
+   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
+
+   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
+
+  }
+  bp+=RTjpeg_width<<3;
+  bp2+=RTjpeg_width<<2;
+  bp3+=RTjpeg_width<<2;
+			 
+ }
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ return (sp-sb);
+}
+
+int RTjpeg_compress8(__s8 *sp, unsigned char *bp)
+{
+ __s8 * sb;
+ int i, j;
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ 
+ sb=sp;
+/* Y */
+ for(i=0; i<RTjpeg_height; i+=8)
+ {
+  for(j=0; j<RTjpeg_width; j+=8)
+  {
+   RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_width);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+  }
+  bp+=RTjpeg_width;
+ }
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ return (sp-sb);
+}
+
+void RTjpeg_decompressYUV422(__s8 *sp, __u8 *bp)
+{
+ register __s8 * bp2 = bp + RTjpeg_Ysize;
+ register __s8 * bp3 = bp2 + (RTjpeg_Csize);
+ int i, j,k;
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+
+/* Y */
+ for(i=RTjpeg_height; i; i-=8)
+ {
+  for(k=0, j=0; j<RTjpeg_width; j+=16, k+=8) {
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp+j, RTjpeg_block, RTjpeg_width);
+   }
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp+j+8, RTjpeg_block, RTjpeg_width);
+   }
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
+    RTjpeg_idct(bp2+k, RTjpeg_block, RTjpeg_width>>1);
+   } 
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
+    RTjpeg_idct(bp3+k, RTjpeg_block, RTjpeg_width>>1);
+   } 
+  }
+  bp+=RTjpeg_width<<3;
+  bp2+=RTjpeg_width<<2;
+  bp3+=RTjpeg_width<<2;
+ }
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+}
+
+void RTjpeg_decompressYUV420(__s8 *sp, __u8 *bp)
+{
+ register __s8 * bp1 = bp + (RTjpeg_width<<3);
+ register __s8 * bp2 = bp + RTjpeg_Ysize;
+ register __s8 * bp3 = bp2 + (RTjpeg_Csize>>1);
+ int i, j,k;
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+
+/* Y */
+ for(i=RTjpeg_height>>1; i; i-=8)
+ {
+  for(k=0, j=0; j<RTjpeg_width; j+=16, k+=8) {
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp+j, RTjpeg_block, RTjpeg_width);
+   }
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp+j+8, RTjpeg_block, RTjpeg_width);
+   }
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp1+j, RTjpeg_block, RTjpeg_width);
+   }
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp1+j+8, RTjpeg_block, RTjpeg_width);
+   }
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
+    RTjpeg_idct(bp2+k, RTjpeg_block, RTjpeg_width>>1);
+   } 
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_cb8, RTjpeg_ciqt);
+    RTjpeg_idct(bp3+k, RTjpeg_block, RTjpeg_width>>1);
+   } 
+  }
+  bp+=RTjpeg_width<<4;
+  bp1+=RTjpeg_width<<4;
+  bp2+=RTjpeg_width<<2;
+  bp3+=RTjpeg_width<<2;
+ }
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+}
+
+void RTjpeg_decompress8(__s8 *sp, __u8 *bp)
+{
+ int i, j;
+
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+
+/* Y */
+ for(i=0; i<RTjpeg_height; i+=8)
+ {
+  for(j=0; j<RTjpeg_width; j+=8)
+   if(*sp==-1)sp++;
+   else
+   { 
+    sp+=RTjpeg_s2b(RTjpeg_block, sp, RTjpeg_lb8, RTjpeg_liqt);
+    RTjpeg_idct(bp+j, RTjpeg_block, RTjpeg_width);
+   }
+  bp+=RTjpeg_width<<3;
+ }
+}
+
+/*
+External Function
+
+Initialise additional data structures for motion compensation
+
+*/
+
+void RTjpeg_init_mcompress(void)
+{
+ unsigned long tmp;
+
+ if(!RTjpeg_old)
+ {
+  RTjpeg_old=malloc((4*RTjpeg_width*RTjpeg_height)+32);
+  tmp=(unsigned long)RTjpeg_old;
+  tmp+=32;
+  tmp=tmp>>5;
+  RTjpeg_old=(__s16 *)(tmp<<5);
+ }
+ if (!RTjpeg_old)
+ {
+  fprintf(stderr, "RTjpeg: Could not allocate memory\n");
+  exit(-1);
+ }
+ bzero(RTjpeg_old, ((4*RTjpeg_width*RTjpeg_height)));
+}
+
+#ifdef HAVE_LIBMMX
+
+int RTjpeg_bcomp(__s16 *old, mmx_t *mask)
+{
+ int i;
+ mmx_t *mold=(mmx_t *)old;
+ mmx_t *mblock=(mmx_t *)RTjpeg_block;
+ mmx_t result;
+ static mmx_t neg=(mmx_t)(unsigned long long)0xffffffffffffffffULL;
+ 
+ movq_m2r(*mask, mm7);
+ movq_m2r(neg, mm6);
+ pxor_r2r(mm5, mm5);
+ 
+ for(i=0; i<8; i++)
+ {
+  movq_m2r(*(mblock++), mm0);
+  			movq_m2r(*(mblock++), mm2);
+  movq_m2r(*(mold++), mm1);
+  			movq_m2r(*(mold++), mm3);
+  psubsw_r2r(mm1, mm0);
+  			psubsw_r2r(mm3, mm2);
+  movq_r2r(mm0, mm1);
+  			movq_r2r(mm2, mm3);
+  pcmpgtw_r2r(mm7, mm0);
+  			pcmpgtw_r2r(mm7, mm2);
+  pxor_r2r(mm6, mm1);
+  			pxor_r2r(mm6, mm3);
+  pcmpgtw_r2r(mm7, mm1);
+  			pcmpgtw_r2r(mm7, mm3);
+  por_r2r(mm0, mm5);
+  			por_r2r(mm2, mm5);
+  por_r2r(mm1, mm5);
+  			por_r2r(mm3, mm5);
+ }
+ movq_r2m(mm5, result);
+ 
+ if(result.q)
+ {
+  if(!RTjpeg_mtest)
+   for(i=0; i<16; i++)((__u64 *)old)[i]=((__u64 *)RTjpeg_block)[i];
+  return 0;
+ }
+// printf(".");
+ return 1;
+}
+
+#else
+int RTjpeg_bcomp(__s16 *old, __u16 *mask)
+{
+ int i;
+
+ for(i=0; i<64; i++)
+  if(abs(old[i]-RTjpeg_block[i])>*mask)
+  {
+   if(!RTjpeg_mtest)
+    for(i=0; i<16; i++)((__u64 *)old)[i]=((__u64 *)RTjpeg_block)[i];
+   return 0;
+  }
+ return 1;
+}
+#endif
+
+void RTjpeg_set_test(int i)
+{
+ RTjpeg_mtest=i;
+}
+
+int RTjpeg_mcompress(__s8 *sp, unsigned char *bp, __u16 lmask, __u16 cmask)
+{
+ __s8 * sb;
+ __s16 *block;
+ register __s8 * bp2;
+ register __s8 * bp3;
+ register int i, j, k;
+
+#ifdef HAVE_LIBMMX
+ emms();
+ RTjpeg_lmask=(mmx_t)(((__u64)lmask<<48)|((__u64)lmask<<32)|((__u64)lmask<<16)|lmask);
+ RTjpeg_cmask=(mmx_t)(((__u64)cmask<<48)|((__u64)cmask<<32)|((__u64)cmask<<16)|cmask);
+#else
+ RTjpeg_lmask=lmask;
+ RTjpeg_cmask=cmask;
+#endif
+ 
+ bp = bp - RTjpeg_width*0;
+ bp2 = bp + RTjpeg_Ysize-RTjpeg_width*0;
+ bp3 = bp2 + RTjpeg_Csize;
+
+ sb=sp;
+ block=RTjpeg_old;
+/* Y */
+ for(i=RTjpeg_height; i; i-=8)
+ {
+  for(j=0, k=0; j<RTjpeg_width; j+=16, k+=8)
+  {
+   RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   if(RTjpeg_bcomp(block, &RTjpeg_lmask))
+   {
+    *((__u8 *)sp++)=255;
+   } 
+	else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+   block+=64;
+
+   RTjpeg_dctY(bp+j+8, RTjpeg_block, RTjpeg_Ywidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   if(RTjpeg_bcomp(block, &RTjpeg_lmask))
+   {
+    *((__u8 *)sp++)=255;
+   } 
+	else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+   block+=64;
+
+   RTjpeg_dctY(bp2+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
+   if(RTjpeg_bcomp(block, &RTjpeg_cmask))
+   {
+    *((__u8 *)sp++)=255;
+   } 
+	else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
+   block+=64;
+
+   RTjpeg_dctY(bp3+k, RTjpeg_block, RTjpeg_Cwidth);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_cqt);
+   if(RTjpeg_bcomp(block, &RTjpeg_cmask))
+   {
+    *((__u8 *)sp++)=255;
+   } 
+	else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_cb8);
+   block+=64;
+
+  }
+  bp+=RTjpeg_width<<3;
+  bp2+=RTjpeg_width<<2;
+  bp3+=RTjpeg_width<<2;
+ }
+ //printf ("%d\n", block - RTjpeg_old);
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ return (sp-sb);
+}
+
+int RTjpeg_mcompress8(__s8 *sp, unsigned char *bp, __u16 lmask)
+{
+ __s8 * sb;
+ __s16 *block;
+ int i, j;
+
+#ifdef HAVE_LIBMMX
+ emms();
+ RTjpeg_lmask=(mmx_t)(((__u64)lmask<<48)|((__u64)lmask<<32)|((__u64)lmask<<16)|lmask);
+#else
+ RTjpeg_lmask=lmask;
+#endif
+
+ 
+ sb=sp;
+ block=RTjpeg_old;
+/* Y */
+ for(i=0; i<RTjpeg_height; i+=8)
+ {
+  for(j=0; j<RTjpeg_width; j+=8)
+  {
+   RTjpeg_dctY(bp+j, RTjpeg_block, RTjpeg_width);
+   RTjpeg_quant(RTjpeg_block, RTjpeg_lqt);
+   if(RTjpeg_bcomp(block, &RTjpeg_lmask))
+   {
+    *((__u8 *)sp++)=255;
+//    printf("* %d ", sp[-1]);
+   } else sp+=RTjpeg_b2s(RTjpeg_block, sp, RTjpeg_lb8);
+   block+=64;
+  }
+  bp+=RTjpeg_width<<3;
+ }
+#ifdef HAVE_LIBMMX
+ emms();
+#endif
+ return (sp-sb);
+}
+
+void RTjpeg_color_init(void)
+{
+}  
+
+#define KcrR 76284
+#define KcrG 53281
+#define KcbG 25625
+#define KcbB 132252
+#define Ky 76284
+
+void RTjpeg_yuv422rgb(__u8 *buf, __u8 *rgb)
+{
+ int tmp;
+ int i, j;
+ __s32 y, crR, crG, cbG, cbB;
+ __u8 *bufcr, *bufcb, *bufy, *bufoute;
+ int yskip;
+ 
+ yskip=RTjpeg_width;
+ 
+ bufcb=&buf[RTjpeg_width*RTjpeg_height];
+ bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/2];
+ bufy=&buf[0];
+ bufoute=rgb;
+ 
+ for(i=0; i<(RTjpeg_height); i++)
+ {
+  for(j=0; j<RTjpeg_width; j+=2)
+  {
+   crR=(*bufcr-128)*KcrR;
+   crG=(*(bufcr++)-128)*KcrG;
+   cbG=(*bufcb-128)*KcbG;
+   cbB=(*(bufcb++)-128)*KcbB;
+  
+   y=(bufy[j]-16)*Ky;
+   
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+1]-16)*Ky;
+
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+  }
+  bufy+=yskip;
+ }
+}
+
+
+void RTjpeg_yuv420rgb(__u8 *buf, __u8 *rgb)
+{
+ int tmp;
+ int i, j;
+ __s32 y, crR, crG, cbG, cbB;
+ __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
+ int oskip, yskip;
+ 
+ oskip=RTjpeg_width*3;
+ yskip=RTjpeg_width;
+ 
+ bufcb=&buf[RTjpeg_width*RTjpeg_height];
+ bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/4];
+ bufy=&buf[0];
+ bufoute=rgb;
+ bufouto=rgb+oskip;
+ 
+ for(i=0; i<(RTjpeg_height>>1); i++)
+ {
+  for(j=0; j<RTjpeg_width; j+=2)
+  {
+   crR=(*bufcr-128)*KcrR;
+   crG=(*(bufcr++)-128)*KcrG;
+   cbG=(*bufcb-128)*KcbG;
+   cbB=(*(bufcb++)-128)*KcbB;
+  
+   y=(bufy[j]-16)*Ky;
+   
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+1]-16)*Ky;
+
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+yskip]-16)*Ky;
+
+   tmp=(y+crR)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+cbB)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+1+yskip]-16)*Ky;
+
+   tmp=(y+crR)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+cbB)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   
+  }
+  bufoute+=oskip;
+  bufouto+=oskip;
+  bufy+=yskip<<1;
+ }
+}
+
+
+void RTjpeg_yuvrgb32(__u8 *buf, __u8 *rgb)
+{
+ int tmp;
+ int i, j;
+ __s32 y, crR, crG, cbG, cbB;
+ __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
+ int oskip, yskip;
+ 
+ oskip=RTjpeg_width*4;
+ yskip=RTjpeg_width;
+ 
+ bufcb=&buf[RTjpeg_width*RTjpeg_height];
+ bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/2];
+ bufy=&buf[0];
+ bufoute=rgb;
+ bufouto=rgb+oskip;
+ 
+ for(i=0; i<(RTjpeg_height>>1); i++)
+ {
+  for(j=0; j<RTjpeg_width; j+=2)
+  {
+   crR=(*bufcr-128)*KcrR;
+   crG=(*(bufcr++)-128)*KcrG;
+   cbG=(*bufcb-128)*KcbG;
+   cbB=(*(bufcb++)-128)*KcbB;
+  
+   y=(bufy[j]-16)*Ky;
+   
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   bufoute++;
+
+   y=(bufy[j+1]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   bufoute++;
+
+   y=(bufy[j+yskip]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   bufouto++;
+
+   y=(bufy[j+1+yskip]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   bufouto++;
+   
+  }
+  bufoute+=oskip;
+  bufouto+=oskip;
+  bufy+=yskip<<1;
+ }
+}
+
+void RTjpeg_yuvrgb24(__u8 *buf, __u8 *rgb)
+{
+ int tmp;
+ int i, j;
+ __s32 y, crR, crG, cbG, cbB;
+ __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
+ int oskip, yskip;
+ 
+ oskip=RTjpeg_width*3;
+ yskip=RTjpeg_width;
+ 
+ bufcb=&buf[RTjpeg_width*RTjpeg_height];
+ bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/4];
+ bufy=&buf[0];
+ bufoute=rgb;
+ bufouto=rgb+oskip;
+ 
+ for(i=0; i<(RTjpeg_height>>1); i++)
+ {
+  for(j=0; j<RTjpeg_width; j+=2)
+  {
+   crR=(*bufcr-128)*KcrR;
+   crG=(*(bufcr++)-128)*KcrG;
+   cbG=(*bufcb-128)*KcbG;
+   cbB=(*(bufcb++)-128)*KcbB;
+  
+   y=(bufy[j]-16)*Ky;
+   
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+1]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufoute++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+yskip]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+
+   y=(bufy[j+1+yskip]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   *(bufouto++)=(tmp>255)?255:((tmp<0)?0:tmp);
+   
+  }
+  bufoute+=oskip;
+  bufouto+=oskip;
+  bufy+=yskip<<1;
+ }
+}
+
+void RTjpeg_yuvrgb16(__u8 *buf, __u8 *rgb)
+{
+ int tmp;
+ int i, j;
+ __s32 y, crR, crG, cbG, cbB;
+ __u8 *bufcr, *bufcb, *bufy, *bufoute, *bufouto;
+ int oskip, yskip;
+ unsigned char r, g, b;
+ 
+ oskip=RTjpeg_width*2;
+ yskip=RTjpeg_width;
+ 
+ bufcb=&buf[RTjpeg_width*RTjpeg_height];
+ bufcr=&buf[RTjpeg_width*RTjpeg_height+(RTjpeg_width*RTjpeg_height)/4];
+ bufy=&buf[0];
+ bufoute=rgb;
+ bufouto=rgb+oskip;
+ 
+ for(i=0; i<(RTjpeg_height>>1); i++)
+ {
+  for(j=0; j<RTjpeg_width; j+=2)
+  {
+   crR=(*bufcr-128)*KcrR;
+   crG=(*(bufcr++)-128)*KcrG;
+   cbG=(*bufcb-128)*KcbG;
+   cbB=(*(bufcb++)-128)*KcbB;
+  
+   y=(bufy[j]-16)*Ky;
+   
+   tmp=(y+cbB)>>16;
+   b=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   g=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   r=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(int)((int)b >> 3);
+   tmp|=(int)(((int)g >> 2) << 5);
+   tmp|=(int)(((int)r >> 3) << 11);
+   *(bufoute++)=tmp&0xff;
+   *(bufoute++)=tmp>>8;
+   
+
+   y=(bufy[j+1]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   b=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   g=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   r=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(int)((int)b >> 3);
+   tmp|=(int)(((int)g >> 2) << 5);
+   tmp|=(int)(((int)r >> 3) << 11);
+   *(bufoute++)=tmp&0xff;
+   *(bufoute++)=tmp>>8;
+
+   y=(bufy[j+yskip]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   b=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   g=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   r=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(int)((int)b >> 3);
+   tmp|=(int)(((int)g >> 2) << 5);
+   tmp|=(int)(((int)r >> 3) << 11);
+   *(bufouto++)=tmp&0xff;
+   *(bufouto++)=tmp>>8;
+
+   y=(bufy[j+1+yskip]-16)*Ky;
+
+   tmp=(y+cbB)>>16;
+   b=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y-crG-cbG)>>16;
+   g=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(y+crR)>>16;
+   r=(tmp>255)?255:((tmp<0)?0:tmp);
+   tmp=(int)((int)b >> 3);
+   tmp|=(int)(((int)g >> 2) << 5);
+   tmp|=(int)(((int)r >> 3) << 11);
+   *(bufouto++)=tmp&0xff;
+   *(bufouto++)=tmp>>8;
+
+  }
+  bufoute+=oskip;
+  bufouto+=oskip;
+  bufy+=yskip<<1;
+ }
+}
+
+void RTjpeg_yuvrgb8(__u8 *buf, __u8 *rgb)
+{
+ bcopy(buf, rgb, RTjpeg_width*RTjpeg_height);
+}
+
+void RTjpeg_double32(__u32 *buf)
+{
+ int i, j;
+ 
+ __u32 *iptr, *optr1, *optr2;
+ 
+ iptr=buf+(RTjpeg_width*RTjpeg_height)-1;
+ optr1=buf+(RTjpeg_width*RTjpeg_height*4)-1;
+ optr2=optr1-(2*RTjpeg_width);
+ 
+ for(i=0; i<RTjpeg_height; i++)
+ {
+  for(j=0; j<RTjpeg_width; j++)
+  {
+   *(optr1--)=*iptr;
+   *(optr1--)=*iptr;
+   *(optr2--)=*iptr;
+   *(optr2--)=*(iptr--);
+  }
+  optr2=optr2-2*RTjpeg_width;
+  optr1=optr1-2*RTjpeg_width;
+ } 
+}
+
+void RTjpeg_double24(__u8 *buf)
+{
+}
+
+void RTjpeg_double16(__u16 *buf)
+{
+ int i, j;
+ 
+ __u16 *iptr, *optr1, *optr2;
+ 
+ iptr=buf+(RTjpeg_width*RTjpeg_height)-1;
+ optr1=buf+(RTjpeg_width*RTjpeg_height*4)-1;
+ optr2=optr1-(2*RTjpeg_width);
+ 
+ for(i=0; i<RTjpeg_height; i++)
+ {
+  for(j=0; j<RTjpeg_width; j++)
+  {
+   *(optr1--)=*iptr;
+   *(optr1--)=*iptr;
+   *(optr2--)=*iptr;
+   *(optr2--)=*(iptr--);
+  }
+  optr2=optr2-2*RTjpeg_width;
+  optr1=optr1-2*RTjpeg_width;
+ } 
+}
+
+void RTjpeg_double8(__u8 *buf)
+{
+ int i, j;
+ 
+ __u8 *iptr, *optr1, *optr2;
+ 
+ iptr=buf+(RTjpeg_width*RTjpeg_height)-1;
+ optr1=buf+(RTjpeg_width*RTjpeg_height*4)-1;
+ optr2=optr1-(2*RTjpeg_width);
+ 
+ for(i=0; i<RTjpeg_height; i++)
+ {
+  for(j=0; j<RTjpeg_width; j++)
+  {
+   *(optr1--)=*iptr;
+   *(optr1--)=*iptr;
+   *(optr2--)=*iptr;
+   *(optr2--)=*(iptr--);
+  }
+  optr2=optr2-2*RTjpeg_width;
+  optr1=optr1-2*RTjpeg_width;
+ } 
+}
+
diff --git a/gst/rtjpeg/RTjpeg.h b/gst/rtjpeg/RTjpeg.h
new file mode 100644
index 00000000..90e2a8d5
--- /dev/null
+++ b/gst/rtjpeg/RTjpeg.h
@@ -0,0 +1,53 @@
+/* 
+   bttvgrab 0.15.4 [1999-03-23]
+   (c) 1998, 1999 by Joerg Walter <trouble@moes.pmnet.uni-oldenburg.de>
+   Maintained by: Joerg Walter
+   Current version at http://moes.pmnet.uni-oldenburg.de/bttvgrab/
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   This file is a modified version of RTjpeg 0.1.2, (C) Justin Schoeman 1998
+*/
+
+#include <config.h>
+#include <inttypes.h>
+
+typedef uint8_t  __u8;
+typedef uint32_t __u32;
+typedef int8_t   __s8;
+typedef uint16_t __u16;
+
+extern void RTjpeg_init_Q(__u8 Q);
+extern void RTjpeg_init_compress(long unsigned int *buf, int width, int height, __u8 Q);
+extern void RTjpeg_init_decompress(long unsigned int *buf, int width, int height);
+extern int RTjpeg_compressYUV420(__s8 *sp, unsigned char *bp);
+extern int RTjpeg_compressYUV422(__s8 *sp, unsigned char *bp);
+extern void RTjpeg_decompressYUV420(__s8 *sp, __u8 *bp);
+extern void RTjpeg_decompressYUV422(__s8 *sp, __u8 *bp);
+extern int RTjpeg_compress8(__s8 *sp, unsigned char *bp);
+extern void RTjpeg_decompress8(__s8 *sp, __u8 *bp);
+
+extern void RTjpeg_init_mcompress(void);
+extern int RTjpeg_mcompress(__s8 *sp, unsigned char *bp, __u16 lmask, __u16 cmask);
+extern int RTjpeg_mcompress8(__s8 *sp, unsigned char *bp, __u16 lmask);
+extern void RTjpeg_set_test(int i);
+
+extern void RTjpeg_yuv420rgb(__u8 *buf, __u8 *rgb);
+extern void RTjpeg_yuv422rgb(__u8 *buf, __u8 *rgb);
+extern void RTjpeg_yuvrgb8(__u8 *buf, __u8 *rgb);
+extern void RTjpeg_yuvrgb16(__u8 *buf, __u8 *rgb);
+extern void RTjpeg_yuvrgb24(__u8 *buf, __u8 *rgb);
+extern void RTjpeg_yuvrgb32(__u8 *buf, __u8 *rgb);
+		  
diff --git a/gst/rtjpeg/gstrtjpeg.c b/gst/rtjpeg/gstrtjpeg.c
new file mode 100644
index 00000000..335914f6
--- /dev/null
+++ b/gst/rtjpeg/gstrtjpeg.c
@@ -0,0 +1,62 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstrtjpegenc.h>
+#include <gstrtjpegdec.h>
+
+extern GstElementDetails gst_rtjpegenc_details;
+extern GstElementDetails gst_rtjpegdec_details;
+
+GstTypeDefinition rtjpegdefinition = {
+  "rtjpeg_video/rtjpeg",
+  "video/rtjpeg",
+  ".rtj",
+  NULL,
+};
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *enc, *dec;
+
+  gst_plugin_set_longname(plugin,"Justin Schoeman's RTjpeg codec and \
+conversion utilities");
+
+  /* create an elementfactory for the rtjpegenc element */
+  enc = gst_elementfactory_new("rtjpegenc",GST_TYPE_RTJPEGENC,
+                               &rtjpegenc_details);
+  g_return_val_if_fail(enc != NULL, FALSE);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (enc));
+
+  /* create an elementfactory for the rtjpegdec element */
+  dec = gst_elementfactory_new("rtjpegdec",GST_TYPE_RTJPEGDEC,
+                               &rtjpegdec_details);
+  g_return_val_if_fail(dec != NULL, FALSE);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (dec));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "rtjpeg",
+  plugin_init
+};
diff --git a/gst/rtjpeg/gstrtjpegdec.c b/gst/rtjpeg/gstrtjpegdec.c
new file mode 100644
index 00000000..f5dc5825
--- /dev/null
+++ b/gst/rtjpeg/gstrtjpegdec.c
@@ -0,0 +1,114 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstrtjpegdec.h>
+
+
+
+/* elementfactory information */
+GstElementDetails gst_rtjpegdec_details = {
+  "RTjpeg decoder",
+  "Filter/Video/Decoder",
+  "Decodes video in RTjpeg format",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+/* GstRTJpegDec signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_QUALITY,
+};
+
+
+static void	gst_rtjpegdec_class_init	(GstRTJpegDecClass *klass);
+static void	gst_rtjpegdec_init		(GstRTJpegDec *rtjpegdec);
+
+static void	gst_rtjpegdec_chain		(GstPad *pad, GstBuffer *buf);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_rtjpegdec_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_rtjpegdec_get_type (void)
+{
+  static GType rtjpegdec_type = 0;
+
+  if (!rtjpegdec_type) {
+    static const GTypeInfo rtjpegdec_info = {
+      sizeof(GstRTJpegDecClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_rtjpegdec_class_init,
+      NULL,
+      NULL,
+      sizeof(GstRTJpegDec),
+      0,
+      (GInstanceInitFunc)gst_rtjpegdec_init,
+    };
+    rtjpegdec_type = g_type_register_static(GST_TYPE_ELEMENT, "GstRTJpegDec", &rtjpegdec_info, 0);
+  }
+  return rtjpegdec_type;
+}
+
+static void
+gst_rtjpegdec_class_init (GstRTJpegDecClass *klass)
+{
+  GstElementClass *gstelement_class;
+
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+}
+
+static void
+gst_rtjpegdec_init (GstRTJpegDec *rtjpegdec)
+{
+  rtjpegdec->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(rtjpegdec),rtjpegdec->sinkpad);
+  gst_pad_set_chain_function(rtjpegdec->sinkpad,gst_rtjpegdec_chain);
+  rtjpegdec->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(rtjpegdec),rtjpegdec->srcpad);
+}
+
+static void
+gst_rtjpegdec_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstRTJpegDec *rtjpegdec;
+  guchar *data;
+  gulong size;
+
+  g_return_if_fail (pad != NULL);
+  g_return_if_fail (GST_IS_PAD (pad));
+  g_return_if_fail (buf != NULL);
+
+  rtjpegdec = GST_RTJPEGDEC (GST_OBJECT_PARENT (pad));
+  data = GST_BUFFER_DATA(buf);
+  size = GST_BUFFER_SIZE(buf);
+
+  gst_info("would be encoding frame here\n");
+
+  gst_pad_push(rtjpegdec->srcpad,buf);
+}
diff --git a/gst/rtjpeg/gstrtjpegdec.h b/gst/rtjpeg/gstrtjpegdec.h
new file mode 100644
index 00000000..853bf345
--- /dev/null
+++ b/gst/rtjpeg/gstrtjpegdec.h
@@ -0,0 +1,71 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 __RTJPEGDEC_H__
+#define __RTJPEGDEC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_RTJPEGDEC \
+  (gst_rtjpegdec_get_type())
+#define GST_RTJPEGDEC(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTJPEGDEC,GstRTJpegDec))
+#define GST_RTJPEGDEC_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTJPEGDEC,GstRTJpegDec))
+#define GST_IS_RTJPEGDEC(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTJPEGDEC))
+#define GST_IS_RTJPEGDEC_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTJPEGDEC)))
+
+typedef struct _GstRTJpegDec GstRTJpegDec;
+typedef struct _GstRTJpegDecClass GstRTJpegDecClass;
+
+struct _GstRTJpegDec {
+  GstElement element;
+
+  GstPad *sinkpad,*srcpad;
+
+  gint width,height;
+  gint quality;
+  gint quant[128];
+
+};
+
+struct _GstRTJpegDecClass {
+  GstElementClass parent_class;
+};
+
+GType gst_rtjpegdec_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __RTJPEGDEC_H__ */
diff --git a/gst/rtjpeg/gstrtjpegenc.c b/gst/rtjpeg/gstrtjpegenc.c
new file mode 100644
index 00000000..68b1e843
--- /dev/null
+++ b/gst/rtjpeg/gstrtjpegenc.c
@@ -0,0 +1,112 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#include <gstrtjpegenc.h>
+
+/* elementfactory information */
+GstElementDetails gst_rtjpegenc_details = {
+  "RTjpeg encoder",
+  "Filter/Video/Encoder",
+  "Encodes video in RTjpeg format",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+/* GstRTJpegEnc signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_QUALITY,
+};
+
+
+static void	gst_rtjpegenc_class_init	(GstRTJpegEncClass *klass);
+static void	gst_rtjpegenc_init		(GstRTJpegEnc *rtjpegenc);
+
+static void	gst_rtjpegenc_chain		(GstPad *pad, GstBuffer *buf);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_rtjpegenc_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_rtjpegenc_get_type (void)
+{
+  static GType rtjpegenc_type = 0;
+
+  if (!rtjpegenc_type) {
+    static const GTypeInfo rtjpegenc_info = {
+      sizeof(GstRTJpegEncClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_rtjpegenc_class_init,
+      NULL,
+      NULL,
+      sizeof(GstRTJpegEnc),
+      0,
+      (GInstanceInitFunc)gst_rtjpegenc_init,
+    };
+    rtjpegenc_type = g_type_register_static(GST_TYPE_ELEMENT, "GstRTJpegEnc", &rtjpegenc_info, 0);
+  }
+  return rtjpegenc_type;
+}
+
+static void
+gst_rtjpegenc_class_init (GstRTJpegEncClass *klass)
+{
+  GstElementClass *gstelement_class;
+
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+}
+
+static void
+gst_rtjpegenc_init (GstRTJpegEnc *rtjpegenc)
+{
+  rtjpegenc->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(rtjpegenc),rtjpegenc->sinkpad);
+  gst_pad_set_chain_function(rtjpegenc->sinkpad,gst_rtjpegenc_chain);
+  rtjpegenc->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(rtjpegenc),rtjpegenc->srcpad);
+}
+
+static void
+gst_rtjpegenc_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstRTJpegEnc *rtjpegenc;
+  guchar *data;
+  gulong size;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  rtjpegenc = GST_RTJPEGENC (GST_OBJECT_PARENT (pad));
+  data = GST_BUFFER_DATA(buf);
+  size = GST_BUFFER_SIZE(buf);
+
+  gst_info("would be encoding frame here\n");
+
+  gst_pad_push(rtjpegenc->srcpad,buf);
+}
diff --git a/gst/rtjpeg/gstrtjpegenc.h b/gst/rtjpeg/gstrtjpegenc.h
new file mode 100644
index 00000000..837616ab
--- /dev/null
+++ b/gst/rtjpeg/gstrtjpegenc.h
@@ -0,0 +1,72 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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 __RTJPEGENC_H__
+#define __RTJPEGENC_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+#include "RTjpeg.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_RTJPEGENC \
+  (gst_rtjpegenc_get_type())
+#define GST_RTJPEGENC(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTJPEGENC,GstRTJpegEnc))
+#define GST_RTJPEGENC_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTJPEGENC,GstRTJpegEnc))
+#define GST_IS_RTJPEGENC(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTJPEGENC))
+#define GST_IS_RTJPEGENC_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTJPEGENC))
+
+typedef struct _GstRTJpegEnc GstRTJpegEnc;
+typedef struct _GstRTJpegEncClass GstRTJpegEncClass;
+
+struct _GstRTJpegEnc {
+  GstElement element;
+
+  GstPad *sinkpad,*srcpad;
+
+  gint width,height;
+  gint quality;
+  gint quant[128];
+};
+
+struct _GstRTJpegEncClass {
+  GstElementClass parent_class;
+};
+
+GType gst_rtjpegenc_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __RTJPEGENC_H__ */
diff --git a/gst/smooth/.gitignore b/gst/smooth/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/smooth/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/smooth/Makefile.am b/gst/smooth/Makefile.am
new file mode 100644
index 00000000..f4856a14
--- /dev/null
+++ b/gst/smooth/Makefile.am
@@ -0,0 +1,8 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstsmooth.la
+
+libgstsmooth_la_SOURCES = gstsmooth.c
+libgstsmooth_la_CFLAGS = -O3 $(FOMIT_FRAME_POINTER) -funroll-all-loops -finline-functions -ffast-math $(GST_CFLAGS)
+
+noinst_HEADERS = gstsmooth.h
diff --git a/gst/smooth/gstsmooth.c b/gst/smooth/gstsmooth.c
new file mode 100644
index 00000000..5f1f507c
--- /dev/null
+++ b/gst/smooth/gstsmooth.c
@@ -0,0 +1,362 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <gstsmooth.h>
+
+
+static GstElementDetails smooth_details = {
+  "Smooth effect",
+  "Filter/Effect",
+  "apply a smooth filter to an image",
+  VERSION,
+  "Wim Taymans <wim.taymans@chello.be>",
+  "(C) 2000",
+};
+
+
+/* Smooth signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_ACTIVE,
+  ARG_TOLERANCE,
+  ARG_FILTERSIZE,
+  ARG_LUM_ONLY
+};
+
+GST_PADTEMPLATE_FACTORY (smooth_src_factory,
+  "src",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+   "smooth_src",
+   "video/raw",
+     "format",   GST_PROPS_FOURCC (GST_STR_FOURCC ("I420"))
+  )
+)
+
+GST_PADTEMPLATE_FACTORY (smooth_sink_factory,
+  "sink",
+  GST_PAD_SINK,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+   "smooth_src",
+   "video/raw",
+     "format",   GST_PROPS_FOURCC (GST_STR_FOURCC ("I420"))
+  )
+)
+
+static void	gst_smooth_class_init	(GstSmoothClass *klass);
+static void	gst_smooth_init		(GstSmooth *smooth);
+
+static void	gst_smooth_chain	(GstPad *pad, GstBuffer *buf);
+static void	smooth_filter		(unsigned char* dest, unsigned char* src,
+					 int width, int height, int tolerance, int filtersize);
+
+static void	gst_smooth_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void	gst_smooth_get_property	(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_smooth_signals[LAST_SIGNAL] = { 0 };
+
+static GstPadNegotiateReturn
+smooth_negotiate_src (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstSmooth* filter = GST_SMOOTH (gst_pad_get_parent (pad));
+
+  if (*caps==NULL)
+    return GST_PAD_NEGOTIATE_FAIL;
+
+  return gst_pad_negotiate_proxy (pad, filter->sinkpad, caps);
+}
+
+static GstPadNegotiateReturn
+smooth_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstSmooth* filter = GST_SMOOTH (gst_pad_get_parent (pad));
+
+  if (*caps==NULL)
+    return GST_PAD_NEGOTIATE_FAIL;
+
+  return gst_pad_negotiate_proxy (pad, filter->srcpad, caps);
+}
+
+GType
+gst_smooth_get_type (void)
+{
+  static GType smooth_type = 0;
+
+  if (!smooth_type) {
+    static const GTypeInfo smooth_info = {
+      sizeof(GstSmoothClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_smooth_class_init,
+      NULL,
+      NULL,
+      sizeof(GstSmooth),
+      0,
+      (GInstanceInitFunc)gst_smooth_init,
+    };
+    smooth_type = g_type_register_static(GST_TYPE_ELEMENT, "GstSmooth", &smooth_info, 0);
+  }
+  return smooth_type;
+}
+
+static void
+gst_smooth_class_init (GstSmoothClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_ACTIVE,
+    g_param_spec_boolean("active","active","active",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_TOLERANCE,
+    g_param_spec_int("tolerance","tolerance","tolerance",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FILTERSIZE,
+    g_param_spec_int("filtersize","filtersize","filtersize",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+
+  gobject_class->set_property = gst_smooth_set_property;
+  gobject_class->get_property = gst_smooth_get_property;
+
+}
+
+static void
+gst_smooth_newcaps (GstPad *pad, GstCaps *caps)
+{
+  GstSmooth *filter;
+
+  filter = GST_SMOOTH (gst_pad_get_parent (pad));
+
+  filter->width = gst_caps_get_int (caps, "width");
+  filter->height = gst_caps_get_int (caps, "height");
+}
+
+static void
+gst_smooth_init (GstSmooth *smooth)
+{
+  smooth->sinkpad = gst_pad_new_from_template (
+                  GST_PADTEMPLATE_GET (smooth_sink_factory), "sink");
+  gst_pad_set_negotiate_function (smooth->sinkpad, smooth_negotiate_sink);
+  gst_pad_set_newcaps_function (smooth->sinkpad, gst_smooth_newcaps);
+  gst_pad_set_chain_function (smooth->sinkpad, gst_smooth_chain);
+  gst_element_add_pad (GST_ELEMENT (smooth), smooth->sinkpad);
+
+  smooth->srcpad = gst_pad_new_from_template (
+                  GST_PADTEMPLATE_GET (smooth_src_factory), "src");
+  gst_pad_set_negotiate_function (smooth->srcpad, smooth_negotiate_src);
+  gst_element_add_pad (GST_ELEMENT (smooth), smooth->srcpad);
+
+  smooth->active = TRUE;
+  smooth->tolerance = 8;
+  smooth->filtersize = 3;
+  smooth->lum_only = TRUE;
+}
+
+static void
+smooth_filter (unsigned char* dest, unsigned char* src, int width, int height, int tolerance, int filtersize)
+{
+  int refval, aktval, upperval, lowerval, numvalues, sum;
+  int x, y, fx, fy, fy1, fy2, fx1, fx2;
+  unsigned char *srcp = src;
+
+  fy1 = 0;
+  fy2 = MIN(filtersize+1, height) * width;
+
+  for(y = 0; y < height; y++)
+  {
+    if (y>(filtersize+1)) fy1 += width;
+    if (y<height-(filtersize+1)) fy2 += width;
+
+    for(x = 0; x < width; x++)
+    {
+      refval    = *src;
+      upperval  = refval + tolerance;
+      lowerval  = refval - tolerance;
+
+      numvalues = 1;
+      sum       = refval;
+
+      fx1      = MAX(x-filtersize,   0)     + fy1;
+      fx2      = MIN(x+filtersize+1, width) + fy1;
+
+      for (fy = fy1; fy<fy2; fy+=width)
+      {
+        for (fx = fx1; fx<fx2; fx++)
+        {
+          aktval = srcp[fx];
+          if ((lowerval-aktval)*(upperval-aktval)<0)
+          {
+            numvalues ++;
+            sum += aktval;
+          }
+        } //for fx
+        fx1 += width;
+        fx2 += width;
+      } //for fy
+
+      src++;
+      *dest++ = sum/numvalues;
+    }
+  }
+}
+
+static void
+gst_smooth_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstSmooth *smooth;
+  guchar *data;
+  gulong size;
+  GstBuffer *outbuf;
+  gint lumsize, chromsize;
+
+  g_return_if_fail (pad != NULL);
+  g_return_if_fail (GST_IS_PAD (pad));
+  g_return_if_fail (buf != NULL);
+
+  smooth = GST_SMOOTH (GST_OBJECT_PARENT (pad));
+
+  if (!smooth->active) {
+    gst_pad_push(smooth->srcpad,buf);
+    return;
+  }
+
+  data = GST_BUFFER_DATA (buf);
+  size = GST_BUFFER_SIZE (buf);
+
+  GST_DEBUG (0,"smooth: have buffer of %d\n", GST_BUFFER_SIZE (buf));
+
+  outbuf = gst_buffer_new();
+  GST_BUFFER_DATA (outbuf) = g_malloc (GST_BUFFER_SIZE (buf));
+  GST_BUFFER_SIZE (outbuf) = GST_BUFFER_SIZE (buf);
+
+  lumsize = smooth->width*smooth->height;
+  chromsize = lumsize/4;
+
+  smooth_filter (GST_BUFFER_DATA (outbuf), data, smooth->width, smooth->height, 
+		  smooth->tolerance, smooth->filtersize);
+  if (!smooth->lum_only) {
+    smooth_filter (GST_BUFFER_DATA (outbuf)+lumsize, data+lumsize, smooth->width/2, smooth->height/2, 
+		  smooth->tolerance, smooth->filtersize/2);
+    smooth_filter (GST_BUFFER_DATA (outbuf)+lumsize+chromsize, data+lumsize+chromsize, smooth->width/2, 
+		  smooth->height/2, smooth->tolerance, smooth->filtersize/2);
+  }
+  else {
+    memcpy (GST_BUFFER_DATA (outbuf)+lumsize, data+lumsize, chromsize*2);
+  }
+
+  GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
+
+  gst_buffer_unref (buf);
+
+  gst_pad_push (smooth->srcpad, outbuf);
+}
+
+static void
+gst_smooth_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstSmooth *smooth;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SMOOTH(object));
+  smooth = GST_SMOOTH(object);
+
+  switch (prop_id) {
+    case ARG_ACTIVE:
+      smooth->active = g_value_get_boolean (value);
+      break;
+    case ARG_TOLERANCE:
+      smooth->tolerance = g_value_get_int (value);
+      break;
+    case ARG_FILTERSIZE:
+      smooth->filtersize = g_value_get_int (value);
+      break;
+    case ARG_LUM_ONLY:
+      smooth->lum_only = g_value_get_boolean (value);
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+gst_smooth_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstSmooth *smooth;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SMOOTH(object));
+  smooth = GST_SMOOTH(object);
+
+  switch (prop_id) {
+    case ARG_ACTIVE:
+      g_value_set_boolean (value, smooth->active);
+      break;
+    case ARG_TOLERANCE:
+      g_value_set_int (value, smooth->tolerance);
+      break;
+    case ARG_FILTERSIZE:
+      g_value_set_int (value, smooth->filtersize);
+      break;
+    case ARG_LUM_ONLY:
+      g_value_set_boolean (value, smooth->lum_only);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  factory = gst_elementfactory_new("smooth",GST_TYPE_SMOOTH,
+                                   &smooth_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (smooth_sink_factory));
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (smooth_src_factory));
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "smooth",
+  plugin_init
+};
+
diff --git a/gst/smooth/gstsmooth.h b/gst/smooth/gstsmooth.h
new file mode 100644
index 00000000..239e074f
--- /dev/null
+++ b/gst/smooth/gstsmooth.h
@@ -0,0 +1,75 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_SMOOTH_H__
+#define __GST_SMOOTH_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SMOOTH \
+  (gst_smooth_get_type())
+#define GST_SMOOTH(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SMOOTH,GstSmooth))
+#define GST_SMOOTH_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SMOOTH,GstSmooth))
+#define GST_IS_SMOOTH(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SMOOTH))
+#define GST_IS_SMOOTH_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SMOOTH))
+
+typedef struct _GstSmooth GstSmooth;
+typedef struct _GstSmoothClass GstSmoothClass;
+
+struct _GstSmooth {
+  GstElement element;
+
+  int format;
+  int width;
+  int height;
+
+  gboolean active;
+  int tolerance;
+  int filtersize;
+  gboolean lum_only;
+
+  GstPad *sinkpad,*srcpad;
+};
+
+struct _GstSmoothClass {
+  GstElementClass parent_class;
+};
+
+GType gst_smooth_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SMOOTH_H__ */
diff --git a/gst/spectrum/.gitignore b/gst/spectrum/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/spectrum/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/spectrum/Makefile.am b/gst/spectrum/Makefile.am
new file mode 100644
index 00000000..476c3fd1
--- /dev/null
+++ b/gst/spectrum/Makefile.am
@@ -0,0 +1,10 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstspectrum.la
+
+libgstspectrum_la_SOURCES = gstspectrum.c fix_fft.c
+libgstspectrum_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstspectrum.h
+
+EXTRA_DIST = README
diff --git a/gst/spectrum/README b/gst/spectrum/README
new file mode 100644
index 00000000..87555712
--- /dev/null
+++ b/gst/spectrum/README
@@ -0,0 +1,5 @@
+This is a simple, rather lame spectrum analyzer made from the fix_fft.c
+code, as found I think in xmms-0.9.1 (the 75-wide output sounds like xmms
+to me), which is actually written by other people (see fix_fft.c for
+credits).  It worked last time I had GiST working, which was a while ago.
+Yes, GiST is not included here yet, it will be in 0.1.0.
diff --git a/gst/spectrum/fix_fft.c b/gst/spectrum/fix_fft.c
new file mode 100644
index 00000000..ecd70303
--- /dev/null
+++ b/gst/spectrum/fix_fft.c
@@ -0,0 +1,452 @@
+/*      fix_fft.c - Fixed-point Fast Fourier Transform  */
+/*
+   fix_fft()       perform FFT or inverse FFT
+   window()        applies a Hanning window to the (time) input
+   fix_loud()      calculates the loudness of the signal, for
+   each freq point. Result is an integer array,
+   units are dB (values will be negative).
+   iscale()        scale an integer value by (numer/denom).
+   fix_mpy()       perform fixed-point multiplication.
+   Sinewave[1024]  sinewave normalized to 32767 (= 1.0).
+   Loudampl[100]   Amplitudes for lopudnesses from 0 to -99 dB.
+   Low_pass        Low-pass filter, cutoff at sample_freq / 4.
+
+   All data are fixed-point short integers, in which
+   -32768 to +32768 represent -1.0 to +1.0. Integer arithmetic
+   is used for speed, instead of the more natural floating-point.
+
+   For the forward FFT (time -> freq), fixed scaling is
+   performed to prevent arithmetic overflow, and to map a 0dB
+   sine/cosine wave (i.e. amplitude = 32767) to two -6dB freq
+   coefficients; the one in the lower half is reported as 0dB
+   by fix_loud(). The return value is always 0.
+
+   For the inverse FFT (freq -> time), fixed scaling cannot be
+   done, as two 0dB coefficients would sum to a peak amplitude of
+   64K, overflowing the 32k range of the fixed-point integers.
+   Thus, the fix_fft() routine performs variable scaling, and
+   returns a value which is the number of bits LEFT by which
+   the output must be shifted to get the actual amplitude
+   (i.e. if fix_fft() returns 3, each value of fr[] and fi[]
+   must be multiplied by 8 (2**3) for proper scaling.
+   Clearly, this cannot be done within the fixed-point short
+   integers. In practice, if the result is to be used as a
+   filter, the scale_shift can usually be ignored, as the
+   result will be approximately correctly normalized as is.
+
+   TURBO C, any memory model; uses inline assembly for speed
+   and for carefully-scaled arithmetic.
+
+   Written by:  Tom Roberts  11/8/89
+   Made portable:  Malcolm Slaney 12/15/94 malcolm@interval.com
+
+   Timing on a Macintosh PowerBook 180.... (using Symantec C6.0)
+   fix_fft (1024 points)             8 ticks
+   fft (1024 points - Using SANE)  112 Ticks
+   fft (1024 points - Using FPU)    11
+
+ */
+
+#define fixed short
+
+/* FIX_MPY() - fixed-point multiplication macro.
+   This macro is a statement, not an expression (uses asm).
+   BEWARE: make sure _DX is not clobbered by evaluating (A) or DEST.
+   args are all of type fixed.
+   Scaling ensures that 32767*32767 = 32767. */
+
+#define FIX_MPY(DEST,A,B)       DEST = ((long)(A) * (long)(B))>>15
+
+#define N_WAVE          1024	/* dimension of Sinewave[] */
+#define LOG2_N_WAVE     10	/* log2(N_WAVE) */
+#define N_LOUD          100	/* dimension of Loudampl[] */
+
+extern fixed gst_spectrum_Sinewave[N_WAVE];	/* placed at end of this file for clarity */
+extern fixed gst_spectrum_Loudampl[N_LOUD];
+static int gst_spectrum_db_from_ampl(fixed re, fixed im);
+static fixed gst_spectrum_fix_mpy(fixed a, fixed b);
+
+/*
+   fix_fft() - perform fast Fourier transform.
+
+   if n>0 FFT is done, if n<0 inverse FFT is done
+   fr[n],fi[n] are real,imaginary arrays, INPUT AND RESULT.
+   size of data = 2**m
+   set inverse to 0=dft, 1=idft
+ */
+int gst_spectrum_fix_fft(fixed fr[], fixed fi[], int m, int inverse) {
+	int mr, nn, i, j, l, k, istep, n, scale, shift;
+	fixed qr, qi, tr, ti, wr, wi, t;
+
+	n = 1 << m;
+
+	if (n > N_WAVE)
+		return -1;
+
+	mr = 0;
+	nn = n - 1;
+	scale = 0;
+
+	/* decimation in time - re-order data */
+	for (m = 1; m <= nn; ++m)
+	{
+		l = n;
+		do
+		{
+			l >>= 1;
+		}
+		while (mr + l > nn);
+		mr = (mr & (l - 1)) + l;
+
+		if (mr <= m)
+			continue;
+		tr = fr[m];
+		fr[m] = fr[mr];
+		fr[mr] = tr;
+		ti = fi[m];
+		fi[m] = fi[mr];
+		fi[mr] = ti;
+	}
+
+	l = 1;
+	k = LOG2_N_WAVE - 1;
+	while (l < n)
+	{
+		if (inverse)
+		{
+			/* variable scaling, depending upon data */
+			shift = 0;
+			for (i = 0; i < n; ++i)
+			{
+				j = fr[i];
+				if (j < 0)
+					j = -j;
+				m = fi[i];
+				if (m < 0)
+					m = -m;
+				if (j > 16383 || m > 16383)
+				{
+					shift = 1;
+					break;
+				}
+			}
+			if (shift)
+				++scale;
+		}
+		else
+		{
+			/* fixed scaling, for proper normalization -
+			   there will be log2(n) passes, so this
+			   results in an overall factor of 1/n,
+			   distributed to maximize arithmetic accuracy. */
+			shift = 1;
+		}
+		/* it may not be obvious, but the shift will be performed
+		   on each data point exactly once, during this pass. */
+		istep = l << 1;
+		for (m = 0; m < l; ++m)
+		{
+			j = m << k;
+			/* 0 <= j < N_WAVE/2 */
+			wr = gst_spectrum_Sinewave[j + N_WAVE / 4];
+			wi = -gst_spectrum_Sinewave[j];
+			if (inverse)
+				wi = -wi;
+			if (shift)
+			{
+				wr >>= 1;
+				wi >>= 1;
+			}
+			for (i = m; i < n; i += istep)
+			{
+				j = i + l;
+				tr = gst_spectrum_fix_mpy(wr, fr[j]) -
+					gst_spectrum_fix_mpy(wi, fi[j]);
+				ti = gst_spectrum_fix_mpy(wr, fi[j]) +
+					gst_spectrum_fix_mpy(wi, fr[j]);
+				qr = fr[i];
+				qi = fi[i];
+				if (shift)
+				{
+					qr >>= 1;
+					qi >>= 1;
+				}
+				fr[j] = qr - tr;
+				fi[j] = qi - ti;
+				fr[i] = qr + tr;
+				fi[i] = qi + ti;
+			}
+		}
+		--k;
+		l = istep;
+	}
+
+	return scale;
+}
+
+/*      window() - apply a Hanning window       */
+void gst_spectrum_window(fixed fr[], int n) {
+	int i, j, k;
+
+	j = N_WAVE / n;
+	n >>= 1;
+	for (i = 0, k = N_WAVE / 4; i < n; ++i, k += j)
+		FIX_MPY(fr[i], fr[i], 16384 - (gst_spectrum_Sinewave[k] >> 1));
+	n <<= 1;
+	for (k -= j; i < n; ++i, k -= j)
+		FIX_MPY(fr[i], fr[i], 16384 - (gst_spectrum_Sinewave[k] >> 1));
+}
+
+/*      fix_loud() - compute loudness of freq-vis components.
+   n should be ntot/2, where ntot was passed to fix_fft();
+   6 dB is added to account for the omitted alias components.
+   scale_shift should be the result of fix_fft(), if the time-series
+   was obtained from an inverse FFT, 0 otherwise.
+   loud[] is the loudness, in dB wrt 32767; will be +10 to -N_LOUD.
+ */
+void gst_spectrum_fix_loud(fixed loud[], fixed fr[], fixed fi[], int n, int scale_shift) {
+	int i, max;
+
+	max = 0;
+	if (scale_shift > 0)
+		max = 10;
+	scale_shift = (scale_shift + 1) * 6;
+
+	for (i = 0; i < n; ++i)
+	{
+		loud[i] = gst_spectrum_db_from_ampl(fr[i], fi[i]) + scale_shift;
+		if (loud[i] > max)
+			loud[i] = max;
+	}
+}
+
+/*      db_from_ampl() - find loudness (in dB) from
+   the complex amplitude.
+ */
+int gst_spectrum_db_from_ampl(fixed re, fixed im) {
+	static long loud2[N_LOUD] =
+	{0};
+	long v;
+	int i;
+
+	if (loud2[0] == 0)
+	{
+		loud2[0] = (long) gst_spectrum_Loudampl[0] * (long) gst_spectrum_Loudampl[0];
+		for (i = 1; i < N_LOUD; ++i)
+		{
+			v = (long) gst_spectrum_Loudampl[i] * (long) gst_spectrum_Loudampl[i];
+			loud2[i] = v;
+			loud2[i - 1] = (loud2[i - 1] + v) / 2;
+		}
+	}
+
+	v = (long) re *(long) re + (long) im *(long) im;
+
+	for (i = 0; i < N_LOUD; ++i)
+		if (loud2[i] <= v)
+			break;
+
+	return (-i);
+}
+
+/*
+   fix_mpy() - fixed-point multiplication
+ */
+fixed gst_spectrum_fix_mpy(fixed a, fixed b) {
+	FIX_MPY(a, a, b);
+	return a;
+}
+
+/*
+   iscale() - scale an integer value by (numer/denom)
+ */
+int gst_spectrum_iscale(int value, int numer, int denom) {
+	return (long) value *(long) numer / (long) denom;
+}
+
+/*
+   fix_dot() - dot product of two fixed arrays
+ */
+fixed gst_spectrum_fix_dot(fixed * hpa, fixed * pb, int n) {
+	fixed *pa;
+	long sum;
+	register fixed a, b;
+	unsigned int seg, off;
+
+/*      seg = FP_SEG(hpa);
+   off = FP_OFF(hpa);
+   seg += off>>4;
+   off &= 0x000F;
+   pa = MK_FP(seg,off);
+ */
+	sum = 0L;
+	while (n--)
+	{
+		a = *pa++;
+		b = *pb++;
+		FIX_MPY(a, a, b);
+		sum += a;
+	}
+
+	if (sum > 0x7FFF)
+		sum = 0x7FFF;
+	else if (sum < -0x7FFF)
+		sum = -0x7FFF;
+
+	return (fixed) sum;
+
+}
+
+#if N_WAVE != 1024
+ERROR:N_WAVE != 1024
+#endif
+fixed gst_spectrum_Sinewave[1024] = {
+	0, 201, 402, 603, 804, 1005, 1206, 1406,
+	1607, 1808, 2009, 2209, 2410, 2610, 2811, 3011,
+	3211, 3411, 3611, 3811, 4011, 4210, 4409, 4608,
+	4807, 5006, 5205, 5403, 5601, 5799, 5997, 6195,
+	6392, 6589, 6786, 6982, 7179, 7375, 7571, 7766,
+	7961, 8156, 8351, 8545, 8739, 8932, 9126, 9319,
+	9511, 9703, 9895, 10087, 10278, 10469, 10659, 10849,
+	11038, 11227, 11416, 11604, 11792, 11980, 12166, 12353,
+	12539, 12724, 12909, 13094, 13278, 13462, 13645, 13827,
+	14009, 14191, 14372, 14552, 14732, 14911, 15090, 15268,
+	15446, 15623, 15799, 15975, 16150, 16325, 16499, 16672,
+	16845, 17017, 17189, 17360, 17530, 17699, 17868, 18036,
+	18204, 18371, 18537, 18702, 18867, 19031, 19194, 19357,
+	19519, 19680, 19840, 20000, 20159, 20317, 20474, 20631,
+	20787, 20942, 21096, 21249, 21402, 21554, 21705, 21855,
+	22004, 22153, 22301, 22448, 22594, 22739, 22883, 23027,
+	23169, 23311, 23452, 23592, 23731, 23869, 24006, 24143,
+	24278, 24413, 24546, 24679, 24811, 24942, 25072, 25201,
+	25329, 25456, 25582, 25707, 25831, 25954, 26077, 26198,
+	26318, 26437, 26556, 26673, 26789, 26905, 27019, 27132,
+	27244, 27355, 27466, 27575, 27683, 27790, 27896, 28001,
+	28105, 28208, 28309, 28410, 28510, 28608, 28706, 28802,
+	28897, 28992, 29085, 29177, 29268, 29358, 29446, 29534,
+	29621, 29706, 29790, 29873, 29955, 30036, 30116, 30195,
+	30272, 30349, 30424, 30498, 30571, 30643, 30713, 30783,
+	30851, 30918, 30984, 31049,
+	31113, 31175, 31236, 31297,
+	31356, 31413, 31470, 31525, 31580, 31633, 31684, 31735,
+	31785, 31833, 31880, 31926, 31970, 32014, 32056, 32097,
+	32137, 32176, 32213, 32249, 32284, 32318, 32350, 32382,
+	32412, 32441, 32468, 32495, 32520, 32544, 32567, 32588,
+	32609, 32628, 32646, 32662, 32678, 32692, 32705, 32717,
+	32727, 32736, 32744, 32751, 32757, 32761, 32764, 32766,
+	32767, 32766, 32764, 32761, 32757, 32751, 32744, 32736,
+	32727, 32717, 32705, 32692, 32678, 32662, 32646, 32628,
+	32609, 32588, 32567, 32544, 32520, 32495, 32468, 32441,
+	32412, 32382, 32350, 32318, 32284, 32249, 32213, 32176,
+	32137, 32097, 32056, 32014, 31970, 31926, 31880, 31833,
+	31785, 31735, 31684, 31633, 31580, 31525, 31470, 31413,
+	31356, 31297, 31236, 31175, 31113, 31049, 30984, 30918,
+	30851, 30783, 30713, 30643, 30571, 30498, 30424, 30349,
+	30272, 30195, 30116, 30036, 29955, 29873, 29790, 29706,
+	29621, 29534, 29446, 29358, 29268, 29177, 29085, 28992,
+	28897, 28802, 28706, 28608, 28510, 28410, 28309, 28208,
+	28105, 28001, 27896, 27790, 27683, 27575, 27466, 27355,
+	27244, 27132, 27019, 26905, 26789, 26673, 26556, 26437,
+	26318, 26198, 26077, 25954, 25831, 25707, 25582, 25456,
+	25329, 25201, 25072, 24942, 24811, 24679, 24546, 24413,
+	24278, 24143, 24006, 23869, 23731, 23592, 23452, 23311,
+	23169, 23027, 22883, 22739, 22594, 22448, 22301, 22153,
+	22004, 21855, 21705, 21554, 21402, 21249, 21096, 20942,
+	20787, 20631, 20474, 20317, 20159, 20000, 19840, 19680,
+	19519, 19357, 19194, 19031, 18867, 18702, 18537, 18371,
+	18204, 18036, 17868, 17699, 17530, 17360, 17189, 17017,
+	16845, 16672, 16499, 16325, 16150, 15975, 15799, 15623,
+	15446, 15268, 15090, 14911, 14732, 14552, 14372, 14191,
+	14009, 13827, 13645, 13462, 13278, 13094, 12909, 12724,
+	12539, 12353, 12166, 11980, 11792, 11604, 11416, 11227,
+	11038, 10849, 10659, 10469, 10278, 10087, 9895, 9703,
+	9511, 9319, 9126, 8932, 8739, 8545, 8351, 8156,
+	7961, 7766, 7571, 7375, 7179, 6982, 6786, 6589,
+	6392, 6195, 5997, 5799, 5601, 5403, 5205, 5006,
+	4807, 4608, 4409, 4210, 4011, 3811, 3611, 3411,
+	3211, 3011, 2811, 2610, 2410, 2209, 2009, 1808,
+	1607, 1406, 1206, 1005, 804, 603, 402, 201,
+	0, -201, -402, -603, -804, -1005, -1206, -1406,
+	-1607, -1808, -2009, -2209, -2410, -2610, -2811, -3011,
+	-3211, -3411, -3611, -3811, -4011, -4210, -4409, -4608,
+	-4807, -5006, -5205, -5403, -5601, -5799, -5997, -6195,
+	-6392, -6589, -6786, -6982, -7179, -7375, -7571, -7766,
+	-7961, -8156, -8351, -8545, -8739, -8932, -9126, -9319,
+	-9511, -9703, -9895, -10087, -10278, -10469, -10659, -10849,
+	-11038, -11227, -11416, -11604, -11792, -11980, -12166, -12353,
+	-12539, -12724, -12909, -13094, -13278, -13462, -13645, -13827,
+	-14009, -14191, -14372, -14552, -14732, -14911, -15090, -15268,
+	-15446, -15623, -15799, -15975, -16150, -16325, -16499, -16672,
+	-16845, -17017, -17189, -17360, -17530, -17699, -17868, -18036,
+	-18204, -18371, -18537, -18702, -18867, -19031, -19194, -19357,
+	-19519, -19680, -19840, -20000, -20159, -20317, -20474, -20631,
+	-20787, -20942, -21096, -21249, -21402, -21554, -21705, -21855,
+	-22004, -22153, -22301, -22448, -22594, -22739, -22883, -23027,
+	-23169, -23311, -23452, -23592, -23731, -23869, -24006, -24143,
+	-24278, -24413, -24546, -24679, -24811, -24942, -25072, -25201,
+	-25329, -25456, -25582, -25707, -25831, -25954, -26077, -26198,
+	-26318, -26437, -26556, -26673, -26789, -26905, -27019, -27132,
+	-27244, -27355, -27466, -27575, -27683, -27790, -27896, -28001,
+	-28105, -28208, -28309, -28410, -28510, -28608, -28706, -28802,
+	-28897, -28992, -29085, -29177, -29268, -29358, -29446, -29534,
+	-29621, -29706, -29790, -29873, -29955, -30036, -30116, -30195,
+	-30272, -30349, -30424, -30498, -30571, -30643, -30713, -30783,
+	-30851, -30918, -30984, -31049, -31113, -31175, -31236, -31297,
+	-31356, -31413, -31470, -31525, -31580, -31633, -31684, -31735,
+	-31785, -31833, -31880, -31926, -31970, -32014, -32056, -32097,
+	-32137, -32176, -32213, -32249, -32284, -32318, -32350, -32382,
+	-32412, -32441, -32468, -32495, -32520, -32544, -32567, -32588,
+	-32609, -32628, -32646, -32662, -32678, -32692, -32705, -32717,
+	-32727, -32736, -32744, -32751, -32757, -32761, -32764, -32766,
+	-32767, -32766, -32764, -32761, -32757, -32751, -32744, -32736,
+	-32727, -32717, -32705, -32692, -32678, -32662, -32646, -32628,
+	-32609, -32588, -32567, -32544, -32520, -32495, -32468, -32441,
+	-32412, -32382, -32350, -32318, -32284, -32249, -32213, -32176,
+	-32137, -32097, -32056, -32014, -31970, -31926, -31880, -31833,
+	-31785, -31735, -31684, -31633, -31580, -31525, -31470, -31413,
+	-31356, -31297, -31236, -31175, -31113, -31049, -30984, -30918,
+	-30851, -30783, -30713, -30643, -30571, -30498, -30424, -30349,
+	-30272, -30195, -30116, -30036, -29955, -29873, -29790, -29706,
+	-29621, -29534, -29446, -29358, -29268, -29177, -29085, -28992,
+	-28897, -28802, -28706, -28608, -28510, -28410, -28309, -28208,
+	-28105, -28001, -27896, -27790, -27683, -27575, -27466, -27355,
+	-27244, -27132, -27019, -26905, -26789, -26673, -26556, -26437,
+	-26318, -26198, -26077, -25954, -25831, -25707, -25582, -25456,
+	-25329, -25201, -25072, -24942, -24811, -24679, -24546, -24413,
+	-24278, -24143, -24006, -23869, -23731, -23592, -23452, -23311,
+	-23169, -23027, -22883, -22739, -22594, -22448, -22301, -22153,
+	-22004, -21855, -21705, -21554, -21402, -21249, -21096, -20942,
+	-20787, -20631, -20474, -20317, -20159, -20000, -19840, -19680,
+	-19519, -19357, -19194, -19031, -18867, -18702, -18537, -18371,
+	-18204, -18036, -17868, -17699, -17530, -17360, -17189, -17017,
+	-16845, -16672, -16499, -16325, -16150, -15975, -15799, -15623,
+	-15446, -15268, -15090, -14911, -14732, -14552, -14372, -14191,
+	-14009, -13827, -13645, -13462, -13278, -13094, -12909, -12724,
+	-12539, -12353, -12166, -11980, -11792, -11604, -11416, -11227,
+	-11038, -10849, -10659, -10469, -10278, -10087, -9895, -9703,
+	-9511, -9319, -9126, -8932, -8739, -8545, -8351, -8156,
+	-7961, -7766, -7571, -7375, -7179, -6982, -6786, -6589,
+	-6392, -6195, -5997, -5799, -5601, -5403, -5205, -5006,
+	-4807, -4608, -4409, -4210, -4011, -3811, -3611, -3411,
+	-3211, -3011, -2811, -2610, -2410, -2209, -2009, -1808,
+	-1607, -1406, -1206, -1005, -804, -603, -402, -201,
+};
+
+#if N_LOUD != 100
+ERROR:N_LOUD != 100
+#endif
+fixed gst_spectrum_Loudampl[100] = {
+	32767, 29203, 26027, 23197, 20674, 18426, 16422, 14636,
+	13044, 11626, 10361, 9234, 8230, 7335, 6537, 5826,
+	5193, 4628, 4125, 3676, 3276, 2920, 2602, 2319,
+	2067, 1842, 1642, 1463, 1304, 1162, 1036, 923,
+	823, 733, 653, 582, 519, 462, 412, 367,
+	327, 292, 260, 231, 206, 184, 164, 146,
+	130, 116, 103, 92, 82, 73, 65, 58,
+	51, 46, 41, 36, 32, 29, 26, 23,
+	20, 18, 16, 14, 13, 11, 10, 9,
+	8, 7, 6, 5, 5, 4, 4, 3,
+	3, 2, 2, 2, 2, 1, 1, 1,
+	1, 1, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0,
+};
diff --git a/gst/spectrum/gstspectrum.c b/gst/spectrum/gstspectrum.c
new file mode 100644
index 00000000..0821545c
--- /dev/null
+++ b/gst/spectrum/gstspectrum.c
@@ -0,0 +1,242 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+
+#include "gstspectrum.h"
+
+static GstElementDetails gst_spectrum_details = {
+  "Spectrum analyzer",
+  "Filter/Analysis",
+  "Run an FFT on the audio signal, output spectrum data",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+static GstTypeDefinition spectrumdefinition = {
+  "spectrum_spectrum_raw",
+  "spectrum/raw",
+  NULL,
+  NULL,
+};
+
+
+/* Spectrum signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_WIDTH,
+};
+
+
+static void	gst_spectrum_class_init	(GstSpectrumClass *klass);
+static void	gst_spectrum_init	(GstSpectrum *spectrum);
+
+static void	gst_spectrum_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+
+static void	gst_spectrum_chain	(GstPad *pad, GstBuffer *buf);
+
+#define fixed short
+int gst_spectrum_fix_fft(fixed fr[], fixed fi[], int m, int inverse);
+void gst_spectrum_fix_loud(fixed loud[], fixed fr[], fixed fi[], int n, int scale_shift);
+void gst_spectrum_window(fixed fr[], int n);
+
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_spectrum_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_spectrum_get_type (void)
+{
+  static GType spectrum_type = 0;
+
+  if (!spectrum_type) {
+    static const GTypeInfo spectrum_info = {
+      sizeof(GstSpectrumClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_spectrum_class_init,
+      NULL,
+      NULL,
+      sizeof(GstSpectrum),
+      0,
+      (GInstanceInitFunc)gst_spectrum_init,
+    };
+    spectrum_type = g_type_register_static(GST_TYPE_ELEMENT, "GstSpectrum", &spectrum_info, 0);
+  }
+  return spectrum_type;
+}
+
+static void
+gst_spectrum_class_init (GstSpectrumClass *klass)
+{
+  GObjectClass *gobject_class;
+
+  gobject_class = (GObjectClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_WIDTH,
+    g_param_spec_int("width","width","width",
+                     G_MININT,G_MAXINT,0,G_PARAM_WRITABLE)); // CHECKME
+
+  gobject_class->set_property = gst_spectrum_set_property;
+}
+
+static void
+gst_spectrum_init (GstSpectrum *spectrum)
+{
+  spectrum->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(spectrum),spectrum->sinkpad);
+  gst_pad_set_chain_function(spectrum->sinkpad,gst_spectrum_chain);
+  spectrum->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(spectrum),spectrum->srcpad);
+
+  spectrum->width = 75;
+}
+
+static void
+gst_spectrum_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstSpectrum *spectrum;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SPECTRUM(object));
+  spectrum = GST_SPECTRUM(object);
+
+  switch (prop_id) {
+    case ARG_WIDTH:
+      spectrum->width = g_value_get_int (value);
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+gst_spectrum_chain (GstPad *pad, GstBuffer *buf)
+{
+  GstSpectrum *spectrum;
+  gint spec_base, spec_len;
+  gint16 *re, *im, *loud;
+  gint16 *samples;
+  gint samplecount,step,pos,i;
+  guchar *spect;
+  GstBuffer *newbuf;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  spectrum = GST_SPECTRUM (GST_OBJECT_PARENT (pad));
+
+  /* first deal with audio metadata */
+//  FIXME
+//  if (buf->meta) {
+//    if (spectrum->meta != NULL) {
+//      /* FIXME: need to unref the old metadata so it goes away */
+//    }
+//    /* we just make a copy of the pointer */
+//    spectrum->meta = (MetaAudioRaw *)(buf->data);
+//    /* FIXME: now we have to ref the metadata so it does go away */
+//  }
+
+  //g_return_if_fail(spectrum->meta != NULL);
+
+  //samplecount = GST_BUFFER_SIZE(buf) /
+  //              (spectrum->meta->channels * sizeof(gint16));
+//  samples = (gint16 *)g_malloc(buf->datasize);
+//  g_return_if_fail(samples != NULL);
+//  memcpy(samples,(gint16
+//*)GST_BUFFER_DATA(buf),GST_BUFFER_DATASIZE(buf));
+//  gst_buffer_unref(buf);
+  samples = (gint16 *)GST_BUFFER_DATA(buf);
+
+//  return;
+//  spec_base = (gint) (log(samplecount) / log(2));
+//  if (spec_base > 10) spec_base = 10;
+//  spec_len = (gint) pow(2, spec_base);
+  spec_base = 8;
+  spec_len = 1024;
+
+  im = g_malloc(spec_len * sizeof(gint16));
+  g_return_if_fail(im != NULL);
+  loud = g_malloc(spec_len * sizeof(gint16));
+  g_return_if_fail(loud != NULL);
+
+  memset(im,0,spec_len * sizeof(gint16));
+  //if (spectrum->meta->channels == 2) {
+    re = g_malloc(spec_len * sizeof(gint16));
+    for (i=0;i<spec_len;i++)
+      re[i] = (samples[(i*2)] + samples[(i*2)+1]) >> 1;
+  //} else
+  //  re = samples;
+  gst_spectrum_window(re,spec_len);
+  gst_spectrum_fix_fft(re,im,spec_base,FALSE);
+  gst_spectrum_fix_loud(loud,re,im,spec_len,0);
+  if (re != samples) g_free(re);
+  g_free(im);
+  step = spec_len / (spectrum->width*2);
+  spect = (guchar *)g_malloc(spectrum->width);
+  for (i=0,pos=0;i<spectrum->width;i++,pos += step) {
+    if (loud[pos] > -60)
+      spect[i] = (loud[pos] + 60) / 2;
+    else
+      spect[i] = 0;
+//    if (spect[i] > 15);
+//      spect[i] = 15;
+  }
+  g_free(loud);
+  gst_buffer_unref(buf);
+//  g_free(samples);
+
+  newbuf = gst_buffer_new();
+  g_return_if_fail(newbuf != NULL);
+  GST_BUFFER_DATA(newbuf) = spect;
+  GST_BUFFER_SIZE(newbuf) = spectrum->width;
+
+  gst_pad_push(spectrum->srcpad,newbuf);
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* create an elementfactory for the spectrum element */
+  factory = gst_elementfactory_new ("spectrum",GST_TYPE_SPECTRUM,
+                                    &gst_spectrum_details);
+  g_return_val_if_fail (factory != NULL, FALSE);
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "spectrum",
+  plugin_init
+};
diff --git a/gst/spectrum/gstspectrum.h b/gst/spectrum/gstspectrum.h
new file mode 100644
index 00000000..f7a395ec
--- /dev/null
+++ b/gst/spectrum/gstspectrum.h
@@ -0,0 +1,67 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_SPECTRUM_H__
+#define __GST_SPECTRUM_H__
+
+
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SPECTRUM \
+  (gst_spectrum_get_type())
+#define GST_SPECTRUM(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SPECTRUM,GstSpectrum))
+#define GST_SPECTRUM_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SPECTRUM,GstSpectrum))
+#define GST_IS_SPECTRUM(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SPECTRUM))
+#define GST_IS_SPECTRUM_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SPECTRUM))
+
+typedef struct _GstSpectrum GstSpectrum;
+typedef struct _GstSpectrumClass GstSpectrumClass;
+
+struct _GstSpectrum {
+  GstElement element;
+
+  GstPad *sinkpad,*srcpad;
+
+  gint width;
+};
+
+struct _GstSpectrumClass {
+  GstElementClass parent_class;
+};
+
+GType gst_spectrum_get_type(void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SPECTRUM_H__ */
diff --git a/gst/speed/Makefile.am b/gst/speed/Makefile.am
new file mode 100644
index 00000000..35aed207
--- /dev/null
+++ b/gst/speed/Makefile.am
@@ -0,0 +1,8 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgstspeed.la
+
+libgstspeed_la_SOURCES = gstspeed.c
+libgstspeed_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstspeed.h filter.func
diff --git a/gst/speed/filter.func b/gst/speed/filter.func
new file mode 100644
index 00000000..89429528
--- /dev/null
+++ b/gst/speed/filter.func
@@ -0,0 +1,66 @@
+/* -*- Mode: c; c-basic-offset: 2 -*- */ 
+    _FORMAT *in_data, *out_data;
+
+    /* get a buffer here so that we can have something to interpolate
+     * against for the first few samples if speed < 0.5 */
+    in_data = (_FORMAT*) GST_BUFFER_DATA(in);
+    nin = GST_BUFFER_SIZE(in)/sizeof(_FORMAT);
+    lower = in_data[0];
+    i_float = 0.5 * (speed - 1.0);
+    i = i_float + 1.0; /* ciel(i_float) for ints */
+    
+    do {
+      speed = filter->speed; /* update this, it might have changed */
+      
+      if (filter->srcpool) {
+        out = gst_buffer_new_from_pool(filter->srcpool, 0, 0);
+        out_data = (_FORMAT*) GST_BUFFER_DATA(out);
+      } else {
+        out = gst_buffer_new();
+        GST_BUFFER_DATA(out) = (gchar*) g_new(_FORMAT,SPEED_BUFSIZE/sizeof(_FORMAT));
+        GST_BUFFER_SIZE(out) = SPEED_BUFSIZE;
+        out_data = (_FORMAT*) GST_BUFFER_DATA(out);
+      }
+      nout = GST_BUFFER_SIZE(out) / sizeof(_FORMAT);
+      
+      for (j=0; j<nout; j++) {
+        /* index of upper bounds of interpolation for
+         * new sample, got it by trial&error on the chalkboard */
+        i_float += speed;
+        i = i_float + 1.0; /* ciel(i_float) for ints */
+        
+        while (i >= nin) {
+          i = i % nin;
+          i_float = i_float - nin;
+          lower = in_data[nin-1];
+          gst_buffer_unref(in);
+          in = gst_pad_pull (filter->sinkpad);
+          
+          while (GST_IS_EVENT(in)) {
+            switch (GST_EVENT_TYPE(in)) {
+            case GST_EVENT_EOS:
+              gst_element_set_state((GstElement*)filter, GST_STATE_PAUSED);
+              gst_pad_push(filter->srcpad, in);
+              return;
+            default:
+              gst_pad_push(filter->srcpad, in);
+              in = gst_pad_pull (filter->sinkpad);
+            }
+          }
+          
+          in_data = (_FORMAT*) GST_BUFFER_DATA(in);
+          nin = GST_BUFFER_SIZE(in) / sizeof(_FORMAT);
+        } 
+        
+        if (i>0)
+          lower = in_data[i-1];
+        
+        interp = i_float - floor(i_float);
+        
+        out_data[j] = lower*(1-interp) + in_data[i]*interp;
+        
+        lower = in_data[i];
+      }
+      
+      gst_pad_push(filter->srcpad, out);
+    } while (!GST_ELEMENT_IS_COTHREAD_STOPPING (element));
diff --git a/gst/speed/gstspeed.c b/gst/speed/gstspeed.c
new file mode 100644
index 00000000..51811227
--- /dev/null
+++ b/gst/speed/gstspeed.c
@@ -0,0 +1,347 @@
+/* -*- c-basic-offset: 2 -*-
+ * GStreamer
+ * Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <gst/gst.h>
+#include <math.h>
+#include <libs/audio/gstaudio.h>
+#include "gstspeed.h"
+
+/* buffer size to make if no bufferpool is available, must be divisible by 
+ * sizeof(gfloat) */
+#define SPEED_BUFSIZE 4096
+/* number of buffers to allocate per chunk in sink buffer pool */
+#define SPEED_NUMBUF 6
+
+static GstElementDetails speed_details = {
+  "Speed",
+  "Filter/Effect",
+  "Set speed/pitch on audio/raw streams (resampler)",
+  VERSION,
+  "Andy Wingo <apwingo@eos.ncsu.edu>",
+  "(C) 2001"
+};
+
+
+/* Filter signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_SILENT,
+  ARG_SPEED
+};
+
+static GstPadTemplate*                    
+speed_sink_factory (void)            
+{                                         
+  static GstPadTemplate *template = NULL; 
+                                          
+  if (!template) {                        
+    template = gst_padtemplate_new 
+      ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
+      gst_caps_append(gst_caps_new ("sink_int",  "audio/raw",
+                                    GST_AUDIO_INT_MONO_PAD_TEMPLATE_PROPS),
+                      gst_caps_new ("sink_float", "audio/raw",
+                                    GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS)),
+      NULL);
+  }                                       
+  return template;                        
+}
+
+static GstPadTemplate*
+speed_src_factory (void)
+{
+  static GstPadTemplate *template = NULL;
+  
+  if (!template)
+    template = gst_padtemplate_new 
+      ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
+       gst_caps_append (gst_caps_new ("src_float", "audio/raw",
+                                      GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS),
+                        gst_caps_new ("src_int", "audio/raw",
+                                      GST_AUDIO_INT_MONO_PAD_TEMPLATE_PROPS)),
+       NULL);
+  
+  return template;
+}
+
+static GstBufferPool*
+speed_sink_get_bufferpool (GstPad *pad)
+{
+  GstSpeed *filter;
+  
+  filter = GST_SPEED (gst_pad_get_parent(pad));
+
+  return filter->sinkpool;
+}
+
+static void		speed_class_init		(GstSpeedClass *klass);
+static void		speed_init		(GstSpeed *filter);
+
+static void		speed_set_property	(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void		speed_get_property        (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static gint             speed_parse_caps          (GstSpeed *filter, GstCaps *caps);
+
+static void		speed_loop              (GstElement *element);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_filter_signals[LAST_SIGNAL] = { 0 };
+
+static GstPadNegotiateReturn
+speed_negotiate_src (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstSpeed* filter = GST_SPEED (gst_pad_get_parent (pad));
+  
+  if (*caps==NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  if (speed_parse_caps(filter, *caps))
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad,filter->sinkpad,caps);
+}
+
+static GstPadNegotiateReturn
+speed_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
+{
+  GstSpeed* filter = GST_SPEED (gst_pad_get_parent (pad));
+  
+  if (*caps==NULL) 
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  if (speed_parse_caps(filter, *caps))
+    return GST_PAD_NEGOTIATE_FAIL;
+  
+  return gst_pad_negotiate_proxy(pad,filter->srcpad,caps);
+}	
+
+static gint
+speed_parse_caps (GstSpeed *filter, GstCaps *caps)
+{
+  const gchar *format;
+  
+  g_return_val_if_fail(filter!=NULL,-1);
+  g_return_val_if_fail(caps!=NULL,-1);
+  
+  format = gst_caps_get_string(caps, "format");
+  
+  filter->rate       = gst_caps_get_int (caps, "rate");
+  filter->channels   = gst_caps_get_int (caps, "channels");
+  
+  if (strcmp(format, "int")==0) {
+    filter->format        = GST_SPEED_FORMAT_INT;
+    filter->width         = gst_caps_get_int (caps, "width");
+    filter->depth         = gst_caps_get_int (caps, "depth");
+    filter->law           = gst_caps_get_int (caps, "law");
+    filter->endianness    = gst_caps_get_int (caps, "endianness");
+    filter->is_signed     = gst_caps_get_int (caps, "signed");
+    if (!filter->silent) {
+      g_print ("Speed : channels %d, rate %d\n",  
+               filter->channels, filter->rate);
+      g_print ("Speed : format int, bit width %d, endianness %d, signed %s\n",
+               filter->width, filter->endianness, filter->is_signed ? "yes" : "no");
+    }
+  } else if (strcmp(format, "float")==0) {
+    filter->format     = GST_SPEED_FORMAT_FLOAT;
+    filter->layout     = gst_caps_get_string(caps, "layout");
+    filter->intercept  = gst_caps_get_float(caps, "intercept");
+    filter->slope      = gst_caps_get_float(caps, "slope");
+    if (!filter->silent) {
+      g_print ("Speed : channels %d, rate %d\n",  
+               filter->channels, filter->rate);
+      g_print ("Speed : format float, layout %s, intercept %f, slope %f\n",
+               filter->layout, filter->intercept, filter->slope);
+    }
+  } else  {
+    return -1;
+  }
+  return 0;
+}
+
+
+GType
+gst_speed_get_type(void) {
+  static GType speed_type = 0;
+
+  if (!speed_type) {
+    static const GTypeInfo speed_info = {
+      sizeof(GstSpeedClass),      NULL,
+      NULL,
+      (GClassInitFunc)speed_class_init,
+      NULL,
+      NULL,
+      sizeof(GstSpeed),
+      0,
+      (GInstanceInitFunc)speed_init,
+    };
+    speed_type = g_type_register_static(GST_TYPE_ELEMENT, "GstSpeed", &speed_info, 0);
+  }
+  return speed_type;
+}
+
+static void
+speed_class_init (GstSpeedClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SILENT,
+    g_param_spec_boolean("silent","silent","silent",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SPEED,
+    g_param_spec_float("speed","speed","speed",
+                       0.1,40.0,1.0,G_PARAM_READWRITE));
+
+  gobject_class->set_property = speed_set_property;
+  gobject_class->get_property = speed_get_property;
+}
+
+static void
+speed_init (GstSpeed *filter)
+{
+  filter->sinkpad = gst_pad_new_from_template(speed_sink_factory (),"sink");
+  gst_pad_set_negotiate_function(filter->sinkpad,speed_negotiate_sink);
+  gst_pad_set_bufferpool_function (filter->sinkpad, speed_sink_get_bufferpool);
+  filter->srcpad = gst_pad_new_from_template(speed_src_factory (),"src");
+  gst_pad_set_negotiate_function(filter->srcpad,speed_negotiate_src);
+  
+  gst_element_add_pad(GST_ELEMENT(filter),filter->sinkpad);
+  gst_element_add_pad(GST_ELEMENT(filter),filter->srcpad);
+  gst_element_set_loop_function(GST_ELEMENT(filter),speed_loop);
+  filter->silent = FALSE;
+  filter->speed = 1.0;
+  
+  filter->sinkpool = gst_buffer_pool_get_default(SPEED_BUFSIZE,
+                                                 SPEED_NUMBUF);
+}
+
+static void
+speed_loop (GstElement *element)
+{
+  GstSpeed *filter = GST_SPEED(element);
+  GstBuffer *in, *out;
+  guint i, j, nin, nout;
+  gfloat interp, speed, lower, i_float;
+  
+  g_return_if_fail(filter != NULL);
+  g_return_if_fail(GST_IS_SPEED(filter));
+
+  filter->srcpool = gst_pad_get_bufferpool(filter->srcpad);
+  
+  i = j = 0;
+  speed = filter->speed;
+  
+  in = gst_pad_pull(filter->sinkpad);
+  
+  /* this is a bit nasty, but hey, it's what you've got to do to keep the same
+   * algorithm and multiple data types in c. */
+  if (filter->format==GST_SPEED_FORMAT_FLOAT) {
+#define _FORMAT gfloat
+#include "filter.func"
+#undef _FORMAT
+  } else if (filter->format==GST_SPEED_FORMAT_INT && filter->width==16) {
+#define _FORMAT gint16
+#include "filter.func"
+#undef _FORMAT
+  } else if (filter->format==GST_SPEED_FORMAT_INT && filter->width==8) {
+#define _FORMAT gint8
+#include "filter.func"
+#undef _FORMAT
+  }
+}
+
+static void
+speed_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstSpeed *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SPEED(object));
+  filter = GST_SPEED(object);
+
+  switch (prop_id) 
+  {
+    case ARG_SILENT:
+      filter->silent = g_value_get_boolean (value);
+      break;
+    case ARG_SPEED:
+      filter->speed = g_value_get_float (value);
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+speed_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstSpeed *filter;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_SPEED(object));
+  filter = GST_SPEED(object);
+
+  switch (prop_id) {
+    case ARG_SILENT:
+      g_value_set_boolean (value, filter->silent);
+      break;
+    case ARG_SPEED:
+      g_value_set_float (value, filter->speed);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  factory = gst_elementfactory_new("speed",GST_TYPE_SPEED,
+                                   &speed_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+  
+  gst_elementfactory_add_padtemplate (factory, speed_src_factory ());
+  gst_elementfactory_add_padtemplate (factory, speed_sink_factory ());
+
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "speed",
+  plugin_init
+};
diff --git a/gst/speed/gstspeed.h b/gst/speed/gstspeed.h
new file mode 100644
index 00000000..530a9dc8
--- /dev/null
+++ b/gst/speed/gstspeed.h
@@ -0,0 +1,106 @@
+/* -*- c-basic-offset: 2 -*-
+ * GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_SPEED_H__
+#define __GST_SPEED_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+// #include <gst/meta/audioraw.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_SPEED \
+  (gst_speed_get_type())
+#define GST_SPEED(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SPEED,GstSpeed))
+#define GST_SPEED_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ULAW,GstSpeed))
+#define GST_IS_SPEED(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SPEED))
+#define GST_IS_SPEED_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SPEED))
+
+typedef struct _GstSpeed GstSpeed;
+typedef struct _GstSpeedClass GstSpeedClass;
+typedef enum _GstSpeedFormat GstSpeedFormat;
+
+enum _GstSpeedFormat {
+  GST_SPEED_FORMAT_INT,
+  GST_SPEED_FORMAT_FLOAT
+};
+
+struct _GstSpeed {
+  GstElement element;
+
+  GstPad *sinkpad, *srcpad;
+  GstBufferPool *sinkpool, *srcpool;
+  
+  gboolean silent;
+  
+  gfloat speed;
+  
+  /* the next three are valid for both int and float */
+  
+  GstSpeedFormat format;
+  
+  guint rate;
+  
+  guint channels;
+  
+  /* the next five are valid only for format==GST_SPEED_FORMAT_INT */
+  
+  guint width;
+  
+  guint depth;
+
+  guint endianness;
+  
+  guint law;
+  
+  gboolean is_signed;
+  
+  /* the next three are valid only for format==GST_SPEED_FORMAT_FLOAT */
+  
+  const gchar *layout;
+  
+  gfloat slope;
+  
+  gfloat intercept;
+};
+
+struct _GstSpeedClass {
+  GstElementClass parent_class;
+};
+
+GType gst_speed_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_SPEED_H__ */
diff --git a/gst/stereo/.gitignore b/gst/stereo/.gitignore
new file mode 100644
index 00000000..08f5ed37
--- /dev/null
+++ b/gst/stereo/.gitignore
@@ -0,0 +1,7 @@
+Makefile
+Makefile.in
+*.o
+*.lo
+*.la
+.deps
+.libs
diff --git a/gst/stereo/Makefile.am b/gst/stereo/Makefile.am
new file mode 100644
index 00000000..69e18c72
--- /dev/null
+++ b/gst/stereo/Makefile.am
@@ -0,0 +1,10 @@
+filterdir = $(libdir)/gst
+
+filter_LTLIBRARIES = libgststereo.la
+
+libgststereo_la_SOURCES = gststereo.c
+libgststereo_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gststereo.h
+
+EXTRA_DIST = README
diff --git a/gst/stereo/README b/gst/stereo/README
new file mode 100644
index 00000000..a61e66ae
--- /dev/null
+++ b/gst/stereo/README
@@ -0,0 +1,3 @@
+This effect is borrowed from xmms-0.6.1, though I mangled it so badly in
+the process of copying it over that the xmms people probably won't want
+any credit for it ;-)
diff --git a/gst/stereo/gststereo.c b/gst/stereo/gststereo.c
new file mode 100644
index 00000000..622dd5d4
--- /dev/null
+++ b/gst/stereo/gststereo.c
@@ -0,0 +1,226 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gststereo.h>
+
+
+static GstElementDetails stereo_details = {
+  "Stereo effect",
+  "Filter/Effect",
+  "Muck with the stereo signal, enhance it's 'stereo-ness'",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 1999",
+};
+
+
+/* Stereo signals and args */
+enum {
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_ACTIVE,
+  ARG_STEREO
+};
+
+
+static void	gst_stereo_class_init		(GstStereoClass *klass);
+static void	gst_stereo_init			(GstStereo *stereo);
+
+static void	gst_stereo_set_property		(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void	gst_stereo_get_property		(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static void	gst_stereo_chain		(GstPad *pad, GstBuffer *buf);
+
+static GstElementClass *parent_class = NULL;
+//static guint gst_stereo_signals[LAST_SIGNAL] = { 0 };
+
+GType
+gst_stereo_get_type(void) {
+  static GType stereo_type = 0;
+
+  if (!stereo_type) {
+    static const GTypeInfo stereo_info = {
+      sizeof(GstStereoClass),      NULL,
+      NULL,
+      (GClassInitFunc)gst_stereo_class_init,
+      NULL,
+      NULL,
+      sizeof(GstStereo),
+      0,
+      (GInstanceInitFunc)gst_stereo_init,
+    };
+    stereo_type = g_type_register_static(GST_TYPE_ELEMENT, "GstStereo", &stereo_info, 0);
+  }
+  return stereo_type;
+}
+
+static void
+gst_stereo_class_init (GstStereoClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_ACTIVE,
+    g_param_spec_int("active","active","active",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_STEREO,
+    g_param_spec_float("stereo","stereo","stereo",
+                       0.0,1.0,0.0,G_PARAM_READWRITE)); // CHECKME
+
+  gobject_class->set_property = gst_stereo_set_property;
+  gobject_class->get_property = gst_stereo_get_property;
+}
+
+static void
+gst_stereo_init (GstStereo *stereo)
+{
+  stereo->sinkpad = gst_pad_new("sink",GST_PAD_SINK);
+  gst_element_add_pad(GST_ELEMENT(stereo),stereo->sinkpad);
+  gst_pad_set_chain_function(stereo->sinkpad,gst_stereo_chain);
+  stereo->srcpad = gst_pad_new("src",GST_PAD_SRC);
+  gst_element_add_pad(GST_ELEMENT(stereo),stereo->srcpad);
+
+  stereo->active = FALSE;
+  stereo->stereo = 2.5;
+}
+
+static void
+gst_stereo_chain (GstPad *pad,GstBuffer *buf)
+{
+  GstStereo *stereo;
+  gint16 *data;
+  gint samples;
+  gint i;
+  gdouble avg,ldiff,rdiff,tmp,mul;
+
+  g_return_if_fail(pad != NULL);
+  g_return_if_fail(GST_IS_PAD(pad));
+  g_return_if_fail(buf != NULL);
+
+  stereo = GST_STEREO(GST_OBJECT_PARENT (pad));
+  g_return_if_fail(stereo != NULL);
+  g_return_if_fail(GST_IS_STEREO(stereo));
+
+//  FIXME
+//  if (buf->meta)
+//    memcpy(&stereo->meta,buf->meta,sizeof(stereo->meta));
+
+  if (stereo->active) {
+
+    //if (stereo->meta.channels == 2 && stereo->meta.format == AFMT_S16_LE) {
+      data = (gint16 *)GST_BUFFER_DATA(buf);
+      samples = GST_BUFFER_SIZE(buf) / 2;
+      mul = stereo->stereo;
+      for (i = 0; i < samples / 2; i += 2) {
+        avg = (data[i] + data[i + 1]) / 2;
+        ldiff = data[i] - avg;
+        rdiff = data[i + 1] - avg;
+
+        tmp = avg + ldiff * mul;
+        if (tmp < -32768)
+          tmp = -32768;
+        if (tmp > 32767)
+          tmp = 32767;
+        data[i] = tmp;
+
+        tmp = avg + rdiff * mul;
+        if (tmp < -32768)
+          tmp = -32768;
+        if (tmp > 32767)
+          tmp = 32767;
+        data[i + 1] = tmp;
+      }
+    //}
+  }
+
+  gst_pad_push(stereo->srcpad,buf);
+}
+
+static void
+gst_stereo_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  GstStereo *stereo;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_STEREO(object));
+  stereo = GST_STEREO(object);
+
+  switch (prop_id) {
+    case ARG_ACTIVE:
+      stereo->active = g_value_get_int (value);
+      break;
+    case ARG_STEREO:
+      stereo->stereo = g_value_get_float (value) * 10.0;
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+gst_stereo_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  GstStereo *stereo;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail(GST_IS_STEREO(object));
+  stereo = GST_STEREO(object);
+
+  switch (prop_id) {
+    case ARG_ACTIVE:
+      g_value_set_int (value, stereo->active);
+      break;
+    case ARG_STEREO:
+      g_value_set_float (value, stereo->stereo / 10.0);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  factory = gst_elementfactory_new("stereo",GST_TYPE_STEREO,
+                                   &stereo_details);
+  g_return_val_if_fail(factory != NULL, FALSE);
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "stereo",
+  plugin_init
+};
+
diff --git a/gst/stereo/gststereo.h b/gst/stereo/gststereo.h
new file mode 100644
index 00000000..f775f850
--- /dev/null
+++ b/gst/stereo/gststereo.h
@@ -0,0 +1,68 @@
+/* Gnome-Streamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * 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_STEREO_H__
+#define __GST_STEREO_H__
+
+
+#include <config.h>
+#include <gst/gst.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GST_TYPE_STEREO \
+  (gst_stereo_get_type())
+#define GST_STEREO(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_STEREO,GstStereo))
+#define GST_STEREO_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_STEREO,GstStereo))
+#define GST_IS_STEREO(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_STEREO))
+#define GST_IS_STEREO_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_STEREO))
+
+typedef struct _GstStereo GstStereo;
+typedef struct _GstStereoClass GstStereoClass;
+
+struct _GstStereo {
+  GstElement element;
+
+  GstPad *sinkpad,*srcpad;
+
+  gint8 active;
+  gfloat stereo;
+};
+
+struct _GstStereoClass {
+  GstElementClass parent_class;
+};
+
+GType gst_stereo_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_STEREO_H__ */