Initial revision

Original commit message from CVS:
Initial revision

8 files changed, 1755 insertions, 0 deletions

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);
+    }
+
+}