Port mpeg1videoparse to 0.10 and give it rank SECONDARY-1, so that it's below existing decoders.

Original commit message from CVS:
* configure.ac:
* gst/mpeg1videoparse/Makefile.am:
* gst/mpeg1videoparse/gstmp1videoparse.c:
* gst/mpeg1videoparse/gstmp1videoparse.h:
* gst/mpeg1videoparse/mp1videoparse.vcproj:
* gst/mpegvideoparse/Makefile.am:
* gst/mpegvideoparse/mpegpacketiser.c: (mpeg_packetiser_init),
(mpeg_packetiser_free), (mpeg_packetiser_add_buf),
(mpeg_packetiser_flush), (mpeg_find_start_code),
(get_next_free_block), (complete_current_block),
(append_to_current_block), (start_new_block), (handle_packet),
(collect_packets), (mpeg_packetiser_handle_eos),
(mpeg_packetiser_get_block), (mpeg_packetiser_next_block):
* gst/mpegvideoparse/mpegpacketiser.h:
* gst/mpegvideoparse/mpegvideoparse.c: (mpegvideoparse_get_type),
(gst_mpegvideoparse_base_init), (gst_mpegvideoparse_class_init),
(mpv_parse_reset), (gst_mpegvideoparse_init),
(gst_mpegvideoparse_dispose), (set_par_from_dar),
(set_fps_from_code), (mpegvideoparse_parse_seq),
(gst_mpegvideoparse_time_code), (gst_mpegvideoparse_flush),
(mpegvideoparse_drain_avail), (gst_mpegvideoparse_chain),
(mpv_parse_sink_event), (gst_mpegvideoparse_change_state),
(plugin_init):
* gst/mpegvideoparse/mpegvideoparse.h:
* gst/mpegvideoparse/mpegvideoparse.vcproj:
Port mpeg1videoparse to 0.10 and give it rank SECONDARY-1, so
that it's below existing decoders.
Rename it to mpegvideoparse to reflect that it handles MPEG-1 and
MPEG-2 now.
Re-write the parsing code so that it collects packets differently
and timestamps Picture packets correctly.
Add a list of FIXME's at the top.

9 files changed, 1281 insertions, 680 deletions

diff --git a/gst/mpeg1videoparse/Makefile.am b/gst/mpeg1videoparse/Makefile.am
deleted file mode 100644
index b8d1739b..00000000
--- a/gst/mpeg1videoparse/Makefile.am
+++ /dev/null
@@ -1,9 +0,0 @@
-
-plugin_LTLIBRARIES = libgstmp1videoparse.la
-
-libgstmp1videoparse_la_SOURCES = gstmp1videoparse.c
-libgstmp1videoparse_la_CFLAGS = $(GST_CFLAGS)
-libgstmp1videoparse_la_LIBADD =
-libgstmp1videoparse_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
-
-noinst_HEADERS = gstmp1videoparse.h
diff --git a/gst/mpeg1videoparse/gstmp1videoparse.c b/gst/mpeg1videoparse/gstmp1videoparse.c
deleted file mode 100644
index 73eb0f13..00000000
--- a/gst/mpeg1videoparse/gstmp1videoparse.c
+++ /dev/null
@@ -1,585 +0,0 @@
-/* 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.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-/*#define GST_DEBUG_ENABLED */
-#include "gstmp1videoparse.h"
-
-/* Start codes. */
-#define SEQ_START_CODE 0x000001b3
-#define GOP_START_CODE 0x000001b8
-#define PICTURE_START_CODE 0x00000100
-#define SLICE_MIN_START_CODE 0x00000101
-#define SLICE_MAX_START_CODE 0x000001af
-#define EXT_START_CODE 0x000001b5
-#define USER_START_CODE 0x000001b2
-#define SEQUENCE_ERROR_CODE 0x000001b4
-#define SEQ_END_CODE 0x000001b7
-
-/* elementfactory information */
-static const GstElementDetails mpeg1videoparse_details =
-GST_ELEMENT_DETAILS ("MPEG-1 video parser",
-    "Codec/Parser/Video",
-    "Parses and frames MPEG 1 video streams, provides seek",
-    "Wim Taymans <wim.taymans@chello.be>");
-
-static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
-    GST_PAD_SRC,
-    GST_PAD_ALWAYS,
-    GST_STATIC_CAPS ("video/mpeg, "
-        "mpegversion = (int) 1, "
-        "systemstream = (boolean) false, "
-        "width = (int) [ 16, 4096 ], "
-        "height = (int) [ 16, 4096 ], "
-        "pixel_width = (int) [ 1, 255 ], "
-        "pixel_height = (int) [ 1, 255 ], " "framerate = (double) [ 0, MAX ]")
-    );
-
-static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
-    GST_PAD_SINK,
-    GST_PAD_ALWAYS,
-    GST_STATIC_CAPS ("video/mpeg, "
-        "mpegversion = (int) 1, " "systemstream = (boolean) false")
-    );
-
-/* Mp1VideoParse signals and args */
-enum
-{
-  /* FILL ME */
-  LAST_SIGNAL
-};
-
-enum
-{
-  ARG_0
-      /* FILL ME */
-};
-
-static void gst_mp1videoparse_class_init (Mp1VideoParseClass * klass);
-static void gst_mp1videoparse_base_init (Mp1VideoParseClass * klass);
-static void gst_mp1videoparse_init (Mp1VideoParse * mp1videoparse);
-
-static void gst_mp1videoparse_chain (GstPad * pad, GstData * _data);
-static void gst_mp1videoparse_real_chain (Mp1VideoParse * mp1videoparse,
-    GstBuffer * buf, GstPad * outpad);
-static void gst_mp1videoparse_flush (Mp1VideoParse * mp1videoparse);
-static GstStateChangeReturn
-gst_mp1videoparse_change_state (GstElement * element,
-    GstStateChange transition);
-
-static GstElementClass *parent_class = NULL;
-
-/*static guint gst_mp1videoparse_signals[LAST_SIGNAL] = { 0 }; */
-
-GType
-mp1videoparse_get_type (void)
-{
-  static GType mp1videoparse_type = 0;
-
-  if (!mp1videoparse_type) {
-    static const GTypeInfo mp1videoparse_info = {
-      sizeof (Mp1VideoParseClass),
-      (GBaseInitFunc) gst_mp1videoparse_base_init,
-      NULL,
-      (GClassInitFunc) gst_mp1videoparse_class_init,
-      NULL,
-      NULL,
-      sizeof (Mp1VideoParse),
-      0,
-      (GInstanceInitFunc) gst_mp1videoparse_init,
-    };
-
-    mp1videoparse_type =
-        g_type_register_static (GST_TYPE_ELEMENT, "Mp1VideoParse",
-        &mp1videoparse_info, 0);
-  }
-  return mp1videoparse_type;
-}
-
-static void
-gst_mp1videoparse_base_init (Mp1VideoParseClass * klass)
-{
-  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
-
-  gst_element_class_add_pad_template (element_class,
-      gst_static_pad_template_get (&src_factory));
-  gst_element_class_add_pad_template (element_class,
-      gst_static_pad_template_get (&sink_factory));
-  gst_element_class_set_details (element_class, &mpeg1videoparse_details);
-}
-
-static void
-gst_mp1videoparse_class_init (Mp1VideoParseClass * klass)
-{
-  GstElementClass *gstelement_class;
-
-  gstelement_class = (GstElementClass *) klass;
-
-  parent_class = g_type_class_peek_parent (klass);
-
-  gstelement_class->change_state = gst_mp1videoparse_change_state;
-}
-
-static void
-gst_mp1videoparse_init (Mp1VideoParse * mp1videoparse)
-{
-  mp1videoparse->sinkpad =
-      gst_pad_new_from_template (gst_static_pad_template_get (&sink_factory),
-      "sink");
-  gst_element_add_pad (GST_ELEMENT (mp1videoparse), mp1videoparse->sinkpad);
-  gst_pad_set_chain_function (mp1videoparse->sinkpad, gst_mp1videoparse_chain);
-
-  mp1videoparse->srcpad =
-      gst_pad_new_from_template (gst_static_pad_template_get (&src_factory),
-      "src");
-  gst_element_add_pad (GST_ELEMENT (mp1videoparse), mp1videoparse->srcpad);
-  gst_pad_use_explicit_caps (mp1videoparse->srcpad);
-
-  mp1videoparse->partialbuf = NULL;
-  mp1videoparse->need_resync = FALSE;
-  mp1videoparse->need_discont = TRUE;
-  mp1videoparse->last_pts = GST_CLOCK_TIME_NONE;
-  mp1videoparse->picture_in_buffer = 0;
-  mp1videoparse->width = mp1videoparse->height = -1;
-  mp1videoparse->fps = mp1videoparse->asr = 0.;
-}
-
-static void
-mp1videoparse_parse_seq (Mp1VideoParse * mp1videoparse, GstBuffer * buf)
-{
-  gint width, height, asr_idx, fps_idx;
-  gfloat asr_table[] = { 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
-  };
-  gfloat fps_table[] = { 0., 24. / 1.001, 24., 25.,
-    30. / 1.001, 30.,
-    50., 60. / 1.001, 60.
-  };
-  guint32 n = GST_READ_UINT32_BE (GST_BUFFER_DATA (buf));
-
-  width = (n & 0xfff00000) >> 20;
-  height = (n & 0x000fff00) >> 8;
-  asr_idx = (n & 0x000000f0) >> 4;
-  fps_idx = (n & 0x0000000f) >> 0;
-
-  if (fps_idx >= 9 || fps_idx <= 0)
-    fps_idx = 3;                /* well, we need a default */
-  if (asr_idx >= 15 || asr_idx <= 0)
-    asr_idx = 1;                /* no aspect ratio */
-
-  if (asr_table[asr_idx] != mp1videoparse->asr ||
-      fps_table[fps_idx] != mp1videoparse->fps ||
-      width != mp1videoparse->width || height != mp1videoparse->height) {
-    GstCaps *caps;
-    gint p_w, p_h;
-
-    mp1videoparse->asr = asr_table[asr_idx];
-    mp1videoparse->fps = fps_table[fps_idx];
-    mp1videoparse->width = width;
-    mp1videoparse->height = height;
-
-    p_w = (asr_table[asr_idx] < 1.0) ? (100 / asr_table[asr_idx]) : 1;
-    p_h = (asr_table[asr_idx] > 1.0) ? (100 * asr_table[asr_idx]) : 1;
-
-    caps = gst_caps_new_simple ("video/mpeg",
-        "systemstream", G_TYPE_BOOLEAN, FALSE,
-        "mpegversion", G_TYPE_INT, 1,
-        "width", G_TYPE_INT, width,
-        "height", G_TYPE_INT, height,
-        "framerate", G_TYPE_DOUBLE, fps_table[fps_idx],
-        "pixel_width", G_TYPE_INT, p_w, "pixel_height", G_TYPE_INT, p_h, NULL);
-
-    GST_DEBUG ("New mpeg1videoparse caps: " GST_PTR_FORMAT, caps);
-
-    gst_pad_set_explicit_caps (mp1videoparse->srcpad, caps);
-  }
-}
-
-static gboolean
-mp1videoparse_valid_sync (Mp1VideoParse * mp1videoparse, guint32 head,
-    GstBuffer * buf)
-{
-  switch (head) {
-    case SEQ_START_CODE:{
-      GstBuffer *subbuf = gst_buffer_create_sub (buf, 4,
-          GST_BUFFER_SIZE (buf) - 4);
-
-      mp1videoparse_parse_seq (mp1videoparse, subbuf);
-      gst_buffer_unref (subbuf);
-      return TRUE;
-    }
-    case GOP_START_CODE:
-    case PICTURE_START_CODE:
-    case USER_START_CODE:
-    case EXT_START_CODE:
-      return TRUE;
-    default:
-      if (head >= SLICE_MIN_START_CODE && head <= SLICE_MAX_START_CODE)
-        return TRUE;
-  }
-
-  return FALSE;
-}
-
-static gint
-mp1videoparse_find_next_gop (Mp1VideoParse * mp1videoparse, GstBuffer * buf)
-{
-  guchar *data = GST_BUFFER_DATA (buf);
-  gulong size = GST_BUFFER_SIZE (buf);
-  gulong offset = 0;
-  gint sync_zeros = 0;
-  gboolean have_sync = FALSE;
-
-  while (offset < size) {
-    guchar byte = *(data + offset);
-
-    offset++;
-    if (byte == 0) {
-      sync_zeros++;
-    } else if (byte == 1 && sync_zeros >= 2) {
-      sync_zeros = 0;
-      have_sync = TRUE;
-    } else if (have_sync) {
-      if (byte == (SEQ_START_CODE & 0xff) || byte == (GOP_START_CODE & 0xff)) {
-        return offset - 4;
-      } else {
-        sync_zeros = 0;
-        have_sync = FALSE;
-      }
-    } else {
-      sync_zeros = 0;
-    }
-  }
-
-  return -1;
-}
-
-static guint64
-gst_mp1videoparse_time_code (guchar * gop, gfloat fps)
-{
-  guint32 data = GST_READ_UINT32_BE (gop);
-
-  return ((((data & 0xfc000000) >> 26) * 3600 * GST_SECOND) +   /* hours */
-      (((data & 0x03f00000) >> 20) * 60 * GST_SECOND) + /* minutes */
-      (((data & 0x0007e000) >> 13) * GST_SECOND) +      /* seconds */
-      (((data & 0x00001f80) >> 7) * GST_SECOND / fps)); /* frames */
-}
-
-static void
-gst_mp1videoparse_flush (Mp1VideoParse * mp1videoparse)
-{
-  GST_DEBUG ("mp1videoparse: flushing");
-  if (mp1videoparse->partialbuf) {
-    gst_buffer_unref (mp1videoparse->partialbuf);
-    mp1videoparse->partialbuf = NULL;
-  }
-  mp1videoparse->need_resync = TRUE;
-  mp1videoparse->in_flush = TRUE;
-  mp1videoparse->picture_in_buffer = 0;
-}
-
-static void
-gst_mp1videoparse_chain (GstPad * pad, GstData * _data)
-{
-  GstBuffer *buf = GST_BUFFER (_data);
-  Mp1VideoParse *mp1videoparse;
-
-  g_return_if_fail (pad != NULL);
-  g_return_if_fail (GST_IS_PAD (pad));
-  g_return_if_fail (buf != NULL);
-
-  mp1videoparse = GST_MP1VIDEOPARSE (GST_OBJECT_PARENT (pad));
-
-  gst_mp1videoparse_real_chain (mp1videoparse, buf, mp1videoparse->srcpad);
-}
-
-static void
-gst_mp1videoparse_real_chain (Mp1VideoParse * mp1videoparse, GstBuffer * buf,
-    GstPad * outpad)
-{
-  guchar *data;
-  gulong size, offset = 0;
-  GstBuffer *outbuf;
-  gint sync_state;
-  gboolean have_sync;
-  guchar sync_byte;
-  guint32 head;
-  gint sync_pos;
-  guint64 time_stamp;
-  GstBuffer *temp;
-
-  time_stamp = GST_BUFFER_TIMESTAMP (buf);
-
-  if (GST_IS_EVENT (buf)) {
-    GstEvent *event = GST_EVENT (buf);
-
-    switch (GST_EVENT_TYPE (event)) {
-      case GST_EVENT_DISCONTINUOUS:
-        mp1videoparse->need_discont = TRUE;
-        /* fall-through */
-      case GST_EVENT_FLUSH:
-        gst_mp1videoparse_flush (mp1videoparse);
-        break;
-      case GST_EVENT_EOS:
-        gst_mp1videoparse_flush (mp1videoparse);
-        gst_event_ref (event);
-        gst_pad_push (outpad, GST_DATA (event));
-        gst_element_set_eos (GST_ELEMENT (mp1videoparse));
-        break;
-      default:
-        GST_DEBUG ("Unhandled event type %d", GST_EVENT_TYPE (event));
-        break;
-    }
-
-    gst_event_unref (event);
-    return;
-  }
-
-
-  if (mp1videoparse->partialbuf) {
-    GstBuffer *merge;
-
-    offset = GST_BUFFER_SIZE (mp1videoparse->partialbuf);
-    merge = gst_buffer_merge (mp1videoparse->partialbuf, buf);
-
-    gst_buffer_unref (mp1videoparse->partialbuf);
-    gst_buffer_unref (buf);
-
-    mp1videoparse->partialbuf = merge;
-  } else {
-    mp1videoparse->partialbuf = buf;
-    offset = 0;
-  }
-
-  data = GST_BUFFER_DATA (mp1videoparse->partialbuf);
-  size = GST_BUFFER_SIZE (mp1videoparse->partialbuf);
-
-  GST_DEBUG ("mp1videoparse: received buffer of %ld bytes %" G_GINT64_FORMAT,
-      size, GST_BUFFER_TIMESTAMP (buf));
-
-  do {
-    data = GST_BUFFER_DATA (mp1videoparse->partialbuf);
-    size = GST_BUFFER_SIZE (mp1videoparse->partialbuf);
-
-    head = GST_READ_UINT32_BE (data);
-
-    GST_DEBUG ("mp1videoparse: head is %08x", (unsigned int) head);
-
-    if (!mp1videoparse_valid_sync (mp1videoparse, head,
-            mp1videoparse->partialbuf) || mp1videoparse->need_resync) {
-      sync_pos =
-          mp1videoparse_find_next_gop (mp1videoparse,
-          mp1videoparse->partialbuf);
-      if (sync_pos >= 0) {
-        mp1videoparse->need_resync = FALSE;
-        GST_DEBUG ("mp1videoparse: found new gop at %d", sync_pos);
-
-        if (sync_pos != 0) {
-          temp =
-              gst_buffer_create_sub (mp1videoparse->partialbuf, sync_pos,
-              size - sync_pos);
-          g_assert (temp != NULL);
-          gst_buffer_unref (mp1videoparse->partialbuf);
-          mp1videoparse->partialbuf = temp;
-          data = GST_BUFFER_DATA (mp1videoparse->partialbuf);
-          size = GST_BUFFER_SIZE (mp1videoparse->partialbuf);
-          offset = 0;
-        }
-
-        head = GST_READ_UINT32_BE (data);
-        /* re-call this function so that if we hadn't already, we can
-         * now read the sequence header and parse video properties,
-         * set caps, stream data, be happy, bla, bla, bla... */
-        if (!mp1videoparse_valid_sync (mp1videoparse, head,
-                mp1videoparse->partialbuf))
-          g_error ("Found sync but no valid sync point at pos 0x0");
-      } else {
-        GST_DEBUG ("mp1videoparse: could not sync");
-        gst_buffer_unref (mp1videoparse->partialbuf);
-        mp1videoparse->partialbuf = NULL;
-        return;
-      }
-    }
-
-    if (mp1videoparse->picture_in_buffer == 1 &&
-        time_stamp != GST_CLOCK_TIME_NONE) {
-      mp1videoparse->last_pts = time_stamp;
-    }
-
-    sync_state = 0;
-    have_sync = FALSE;
-
-    GST_DEBUG ("mp1videoparse: searching sync");
-
-    while (offset < size - 1) {
-      sync_byte = *(data + offset);
-      if (sync_byte == 0) {
-        sync_state++;
-      } else if ((sync_byte == 1) && (sync_state >= 2)) {
-        GST_DEBUG ("mp1videoparse: code 0x000001%02x", data[offset + 1]);
-        if (data[offset + 1] == (PICTURE_START_CODE & 0xff)) {
-          mp1videoparse->picture_in_buffer++;
-          if (mp1videoparse->picture_in_buffer == 1) {
-            if (time_stamp != GST_CLOCK_TIME_NONE) {
-              mp1videoparse->last_pts = time_stamp;
-            }
-            sync_state = 0;
-          } else if (mp1videoparse->picture_in_buffer == 2) {
-            have_sync = TRUE;
-            break;
-          } else {
-            GST_DEBUG ("mp1videoparse: %d in buffer",
-                mp1videoparse->picture_in_buffer);
-            g_assert_not_reached ();
-          }
-        }
-        /* A new sequence (or GOP) is a valid sync too. Note that the
-         * sequence header should be put in the next buffer, not here. */
-        else if (data[offset + 1] == (SEQ_START_CODE & 0xFF) ||
-            data[offset + 1] == (GOP_START_CODE & 0xFF)) {
-          if (mp1videoparse->picture_in_buffer == 0 &&
-              data[offset + 1] == (GOP_START_CODE & 0xFF)) {
-            mp1videoparse->last_pts = gst_mp1videoparse_time_code (&data[2],
-                mp1videoparse->fps);
-          } else if (mp1videoparse->picture_in_buffer == 1) {
-            have_sync = TRUE;
-            break;
-          } else {
-            g_assert (mp1videoparse->picture_in_buffer == 0);
-          }
-        }
-        /* end-of-sequence is a valid sync point and should be included
-         * in the current picture, not the next. */
-        else if (data[offset + 1] == (SEQ_END_CODE & 0xFF)) {
-          if (mp1videoparse->picture_in_buffer == 1) {
-            offset += 4;
-            have_sync = TRUE;
-            break;
-          } else {
-            g_assert (mp1videoparse->picture_in_buffer == 0);
-          }
-        } else
-          sync_state = 0;
-      }
-      /* something else... */
-      else
-        sync_state = 0;
-
-      /* go down the buffer */
-      offset++;
-    }
-
-    if (have_sync) {
-      offset -= 2;
-      GST_DEBUG ("mp1videoparse: synced");
-
-      outbuf = gst_buffer_create_sub (mp1videoparse->partialbuf, 0, offset);
-      g_assert (outbuf != NULL);
-      GST_BUFFER_TIMESTAMP (outbuf) = mp1videoparse->last_pts;
-      GST_BUFFER_DURATION (outbuf) = GST_SECOND / mp1videoparse->fps;
-      mp1videoparse->last_pts += GST_BUFFER_DURATION (outbuf);
-
-      if (mp1videoparse->in_flush) {
-        /* FIXME, send a flush event here */
-        mp1videoparse->in_flush = FALSE;
-      }
-
-      if (GST_PAD_CAPS (outpad) != NULL) {
-        if (mp1videoparse->need_discont &&
-            GST_BUFFER_TIMESTAMP_IS_VALID (outbuf)) {
-          GstEvent *event = gst_event_new_discontinuous (FALSE,
-              GST_FORMAT_TIME, GST_BUFFER_TIMESTAMP (outbuf),
-              GST_FORMAT_UNDEFINED);
-
-          GST_DEBUG ("prepending discont event");
-          gst_pad_push (outpad, GST_DATA (event));
-          mp1videoparse->need_discont = FALSE;
-        }
-        GST_DEBUG ("mp1videoparse: pushing  %d bytes %" G_GUINT64_FORMAT,
-            GST_BUFFER_SIZE (outbuf), GST_BUFFER_TIMESTAMP (outbuf));
-        gst_pad_push (outpad, GST_DATA (outbuf));
-        GST_DEBUG ("mp1videoparse: pushing  done");
-      } else {
-        GST_DEBUG ("No capsnego yet, delaying buffer push");
-        gst_buffer_unref (outbuf);
-      }
-      mp1videoparse->picture_in_buffer = 0;
-
-      if (size != offset) {
-        temp =
-            gst_buffer_create_sub (mp1videoparse->partialbuf, offset,
-            size - offset);
-      } else {
-        temp = NULL;
-      }
-      gst_buffer_unref (mp1videoparse->partialbuf);
-      mp1videoparse->partialbuf = temp;
-      offset = 0;
-    } else {
-      if (time_stamp != GST_CLOCK_TIME_NONE)
-        mp1videoparse->last_pts = time_stamp;
-      return;
-    }
-  } while (mp1videoparse->partialbuf != NULL);
-}
-
-static GstStateChangeReturn
-gst_mp1videoparse_change_state (GstElement * element, GstStateChange transition)
-{
-  Mp1VideoParse *mp1videoparse;
-
-  g_return_val_if_fail (GST_IS_MP1VIDEOPARSE (element),
-      GST_STATE_CHANGE_FAILURE);
-
-  mp1videoparse = GST_MP1VIDEOPARSE (element);
-
-  switch (transition) {
-    case GST_STATE_CHANGE_PAUSED_TO_READY:
-      gst_mp1videoparse_flush (mp1videoparse);
-      mp1videoparse->need_discont = TRUE;
-      mp1videoparse->width = mp1videoparse->height = -1;
-      mp1videoparse->fps = mp1videoparse->asr = 0.;
-      break;
-    default:
-      break;
-  }
-
-  if (GST_ELEMENT_CLASS (parent_class)->change_state)
-    return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
-
-  return GST_STATE_CHANGE_SUCCESS;
-}
-
-static gboolean
-plugin_init (GstPlugin * plugin)
-{
-  return gst_element_register (plugin, "mpeg1videoparse",
-      GST_RANK_NONE, GST_TYPE_MP1VIDEOPARSE);
-}
-
-GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
-    GST_VERSION_MINOR,
-    "mpeg1videoparse",
-    "MPEG-1 video parser",
-    plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
diff --git a/gst/mpeg1videoparse/gstmp1videoparse.h b/gst/mpeg1videoparse/gstmp1videoparse.h
deleted file mode 100644
index 3581f02d..00000000
--- a/gst/mpeg1videoparse/gstmp1videoparse.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/* 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 __MP1VIDEOPARSE_H__
-#define __MP1VIDEOPARSE_H__
-
-
-#include <gst/gst.h>
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-
-#define GST_TYPE_MP1VIDEOPARSE \
-  (mp1videoparse_get_type())
-#define GST_MP1VIDEOPARSE(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MP1VIDEOPARSE,Mp1VideoParse))
-#define GST_MP1VIDEOPARSE_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MP1VIDEOPARSE,Mp1VideoParseClass))
-#define GST_IS_MP1VIDEOPARSE(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MP1VIDEOPARSE))
-#define GST_IS_MP1VIDEOPARSE_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MP1VIDEOPARSE))
-
-typedef struct _Mp1VideoParse Mp1VideoParse;
-typedef struct _Mp1VideoParseClass Mp1VideoParseClass;
-
-struct _Mp1VideoParse {
-  GstElement element;
-
-  GstPad *sinkpad,*srcpad;
-
-  GstBuffer *partialbuf;        /* previous buffer (if carryover) */
-  gulong next_buffer_offset;
-  gboolean need_resync;
-  gboolean in_flush;
-  gboolean need_discont;
-  guint64 last_pts;
-  gint picture_in_buffer;
-
-  gint width, height;
-  gfloat fps, asr;
-};
-
-struct _Mp1VideoParseClass {
-  GstElementClass parent_class;
-};
-
-GType gst_mp1videoparse_get_type(void);
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-
-#endif /* __MP1VIDEOPARSE_H__ */
diff --git a/gst/mpegvideoparse/Makefile.am b/gst/mpegvideoparse/Makefile.am
new file mode 100644
index 00000000..4f935788
--- /dev/null
+++ b/gst/mpegvideoparse/Makefile.am
@@ -0,0 +1,9 @@
+
+plugin_LTLIBRARIES = libgstmpegvideoparse.la
+
+libgstmpegvideoparse_la_SOURCES = mpegvideoparse.c mpegpacketiser.c
+libgstmpegvideoparse_la_CFLAGS = $(GST_CFLAGS)
+libgstmpegvideoparse_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS)
+libgstmpegvideoparse_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+
+noinst_HEADERS = mpegvideoparse.h mpegpacketiser.h
diff --git a/gst/mpegvideoparse/mpegpacketiser.c b/gst/mpegvideoparse/mpegpacketiser.c
new file mode 100644
index 00000000..5c054ed8
--- /dev/null
+++ b/gst/mpegvideoparse/mpegpacketiser.c
@@ -0,0 +1,438 @@
+/* GStreamer
+ * Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+/* The purpose of the packetiser is to parse the incoming buffers into 'blocks'
+ * that consist of the stream split at certain packet boundaries. It splits into
+ * a new block at the start of a GOP, Picture or Sequence packet.
+ * A GOP or sequence header always starts a new block. A Picture
+ * header starts a new block only if the previous packet was not a GOP - 
+ * otherwise it is accumulated with the GOP */
+#include "mpegpacketiser.h"
+
+static void collect_packets (MPEGPacketiser * p, GstBuffer * buf);
+
+void
+mpeg_packetiser_init (MPEGPacketiser * p)
+{
+  p->adapter = gst_adapter_new ();
+  p->n_blocks = 0;
+  p->blocks = NULL;
+  mpeg_packetiser_flush (p);
+}
+
+void
+mpeg_packetiser_free (MPEGPacketiser * p)
+{
+  gst_object_unref (p->adapter);
+  g_free (p->blocks);
+}
+
+void
+mpeg_packetiser_add_buf (MPEGPacketiser * p, GstBuffer * buf)
+{
+  /* Add the buffer to our pool */
+  gst_adapter_push (p->adapter, buf);
+
+  /* Store the timestamp to apply to the next picture that gets collected */
+  if (p->cur_buf_ts != GST_CLOCK_TIME_NONE) {
+    p->prev_buf_ts = p->cur_buf_ts;
+  }
+  p->cur_buf_ts = GST_BUFFER_TIMESTAMP (buf);
+
+  /* read what new packets we have in this buffer */
+  collect_packets (p, buf);
+
+  p->tracked_offset += GST_BUFFER_SIZE (buf);
+}
+
+void
+mpeg_packetiser_flush (MPEGPacketiser * p)
+{
+  gst_adapter_clear (p->adapter);
+  p->adapter_offset = 0;
+
+  p->sync_word = 0xffffffff;
+  p->tracked_offset = 0;
+  p->prev_sync_packet = MPEG_PACKET_NONE;
+
+  /* Reset our block info */
+  p->cur_block_idx = -1;
+  p->first_block_idx = -1;
+
+  /* Clear any pending timestamps */
+  p->prev_buf_ts = GST_CLOCK_TIME_NONE;
+  p->cur_buf_ts = GST_CLOCK_TIME_NONE;
+}
+
+guint8 *
+mpeg_find_start_code (guint32 * sync_word, guint8 * cur, guint8 * end)
+{
+  guint32 code = *sync_word;
+
+  if (G_UNLIKELY (cur == NULL))
+    return NULL;
+
+  while (cur < end) {
+    code <<= 8;
+
+    if (code == 0x00000100) {
+      /* Reset the sync word accumulator */
+      *sync_word = 0xffffffff;
+      return cur;
+    }
+
+    /* Add the next available byte to the collected sync word */
+    code |= *cur++;
+  }
+
+  *sync_word = code;
+  return NULL;
+}
+
+/* When we need to reallocate the blocks array, grow it by this much */
+#define BLOCKS_INCREMENT 5
+
+/* Get the index of the next unfilled block in the buffer. May need to grow
+ * the array first */
+gint
+get_next_free_block (MPEGPacketiser * p)
+{
+  gint next;
+  gboolean grow_array = FALSE;
+
+  /* Get a free block from the blocks array. May need to grow
+   * the array first */
+  if (p->n_blocks == 0) {
+    grow_array = TRUE;
+    next = 0;
+  } else {
+    if (G_UNLIKELY (p->cur_block_idx == -1)) {
+      next = 0;
+    } else {
+      next = p->cur_block_idx;
+      if (((next + 1) % p->n_blocks) == p->first_block_idx)
+        grow_array = TRUE;
+    }
+  }
+
+  if (grow_array) {
+    gint old_n_blocks = p->n_blocks;
+
+    p->n_blocks += BLOCKS_INCREMENT;
+
+    p->blocks = g_realloc (p->blocks, sizeof (MPEGBlockInfo) * p->n_blocks);
+
+    /* Now we may need to move some data up to the end of the array, if the 
+     * cur_block_idx is before the first_block_idx in the array. */
+    if (p->cur_block_idx < p->first_block_idx) {
+#if 0
+      g_print ("Moving %d blocks from idx %d to idx %d of %d\n",
+          old_n_blocks - p->first_block_idx,
+          p->first_block_idx, p->first_block_idx + BLOCKS_INCREMENT,
+          p->n_blocks);
+#endif
+
+      memmove (p->blocks + p->first_block_idx + BLOCKS_INCREMENT,
+          p->blocks + p->first_block_idx,
+          sizeof (MPEGBlockInfo) * (old_n_blocks - p->first_block_idx));
+      p->first_block_idx += BLOCKS_INCREMENT;
+    }
+  }
+
+  return next;
+}
+
+/* Mark the current block as complete */
+static void
+complete_current_block (MPEGPacketiser * p, guint64 offset)
+{
+  MPEGBlockInfo *block;
+
+  if (G_UNLIKELY (p->cur_block_idx == -1))
+    return;                     /* No block is in progress */
+
+  /* If we're pointing at the first_block_idx, then we're about to re-complete
+   * a previously completed buffer. Not allowed, because the array should have
+   * been previously expanded to cope via a get_next_free_block call. */
+  g_assert (p->cur_block_idx != p->first_block_idx);
+
+  /* Get the appropriate entry from the blocks array */
+  g_assert (p->blocks != NULL && p->cur_block_idx < p->n_blocks);
+  block = p->blocks + p->cur_block_idx;
+
+  /* Extend the block length to the current offset */
+  g_assert (block->offset < offset);
+  block->length = offset - block->offset;
+
+#if 0
+  g_print ("Completed block of type 0x%02x @ offset %" G_GUINT64_FORMAT
+      " with size %u\n", block->first_pack_type, block->offset, block->length);
+#endif
+
+  /* If this is the first complete block, set first_block_idx to be this block */
+  if (p->first_block_idx == -1)
+    p->first_block_idx = p->cur_block_idx;
+
+  /* Update the statistics regarding the packet we're handling */
+  if (block->flags & MPEG_BLOCK_FLAG_PICTURE)
+    p->n_pictures++;
+
+  /* And advance the cur_block_idx ptr to the next slot */
+  p->cur_block_idx = (p->cur_block_idx + 1) % p->n_blocks;
+}
+
+/* Accumulate the packet up to 'offset' into the current block 
+ * (discard if no block is in progress). Update the block info
+ * to indicate what is in it. */
+static void
+append_to_current_block (MPEGPacketiser * p, guint64 offset, guint8 pack_type)
+{
+  MPEGBlockInfo *block;
+
+  if (G_UNLIKELY (p->cur_block_idx == -1))
+    return;                     /* No block in progress, drop this packet */
+
+  /* Get the appropriate entry from the blocks array */
+  g_assert (p->blocks != NULL && p->cur_block_idx < p->n_blocks);
+  block = p->blocks + p->cur_block_idx;
+
+  /* Extend the block length to the current offset */
+  g_assert (block->offset < offset);
+  block->length = offset - block->offset;
+
+  /* Update flags */
+  switch (pack_type) {
+    case MPEG_PACKET_SEQUENCE:
+      g_assert (!(block->flags &
+              (MPEG_BLOCK_FLAG_GOP | MPEG_BLOCK_FLAG_PICTURE)));
+      block->flags |= MPEG_BLOCK_FLAG_SEQUENCE;
+      break;
+    case MPEG_PACKET_GOP:
+      block->flags |= MPEG_BLOCK_FLAG_GOP;
+      break;
+    case MPEG_PACKET_PICTURE:
+      block->flags |= MPEG_BLOCK_FLAG_PICTURE;
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+start_new_block (MPEGPacketiser * p, guint64 offset, guint8 pack_type)
+{
+  gint block_idx;
+  MPEGBlockInfo *block;
+
+  /* First, append data up to the start of this block to the current one, but
+   * not including this packet info */
+  complete_current_block (p, offset);
+
+  block_idx = get_next_free_block (p);
+  /* FIXME: Retrieve the appropriate entry from the blocks array */
+  /* Get the appropriate entry from the blocks array */
+  g_assert (p->blocks != NULL && block_idx < p->n_blocks);
+  block = p->blocks + block_idx;
+
+  /* Init the block */
+  block->first_pack_type = pack_type;
+  block->offset = offset;
+  block->ts = GST_CLOCK_TIME_NONE;
+
+  /* Initially, the length is 0. It grows as we encounter new sync headers */
+  block->length = 0;
+  switch (pack_type) {
+    case MPEG_PACKET_SEQUENCE:
+      block->flags = MPEG_BLOCK_FLAG_SEQUENCE;
+      break;
+    case MPEG_PACKET_GOP:
+      block->flags = MPEG_BLOCK_FLAG_GOP;
+      break;
+    case MPEG_PACKET_PICTURE:
+      block->flags = MPEG_BLOCK_FLAG_PICTURE;
+      break;
+    default:
+      /* We don't start blocks with other packet types */
+      g_assert_not_reached ();
+  }
+
+  /* Make this our current block */
+  p->cur_block_idx = block_idx;
+
+#if 0
+  g_print ("Started new block in slot %d with first pack 0x%02x @ offset %"
+      G_GUINT64_FORMAT "\n", block_idx, block->first_pack_type, block->offset);
+#endif
+
+}
+
+static void
+handle_packet (MPEGPacketiser * p, guint64 offset, guint8 pack_type)
+{
+  switch (pack_type) {
+    case MPEG_PACKET_SEQUENCE:
+    case MPEG_PACKET_GOP:
+      /* Start a new block */
+      start_new_block (p, offset, pack_type);
+      p->prev_sync_packet = pack_type;
+      break;
+    case MPEG_PACKET_PICTURE:{
+      MPEGBlockInfo *block;
+      GstClockTime ts;
+
+      /* Start a new block unless the previous sync packet was a GOP */
+      if (p->prev_sync_packet != MPEG_PACKET_GOP) {
+        start_new_block (p, offset, pack_type);
+      } else {
+        append_to_current_block (p, offset, pack_type);
+      }
+      p->prev_sync_packet = pack_type;
+
+      /* We have a picture packet, apply any pending timestamp. The logic here
+       * is that the timestamp on any incoming buffer needs to apply to the next
+       * picture packet where the _first_byte_ of the sync word starts after the
+       * packet boundary. We track the ts from the current buffer and a
+       * previous buffer in order to handle this correctly. It would still be
+       * possible to get it wrong if there was a PES packet smaller than 3 bytes
+       * but anyone that does that can suck it.  */
+      if (offset >= p->tracked_offset) {
+        /* sync word started within this buffer - take the cur ts */
+        ts = p->cur_buf_ts;
+        p->cur_buf_ts = GST_CLOCK_TIME_NONE;
+        p->prev_buf_ts = GST_CLOCK_TIME_NONE;
+      } else {
+        /* sync word started in a previous buffer - take the old ts */
+        ts = p->prev_buf_ts;
+        p->prev_buf_ts = GST_CLOCK_TIME_NONE;
+      }
+
+      /* If we didn't drop the packet, set the timestamp on it */
+      if (G_LIKELY (p->cur_block_idx != -1)) {
+        block = p->blocks + p->cur_block_idx;
+        block->ts = ts;
+#if 0
+        g_print ("Picture @ offset %" G_GINT64_FORMAT " has ts %"
+            GST_TIME_FORMAT "\n", block->offset, GST_TIME_ARGS (block->ts));
+#endif
+      }
+      break;
+    }
+    default:
+      append_to_current_block (p, offset, pack_type);
+      break;
+  }
+}
+
+static void
+collect_packets (MPEGPacketiser * p, GstBuffer * buf)
+{
+  guint8 *cur;
+  guint8 *end = GST_BUFFER_DATA (buf) + GST_BUFFER_SIZE (buf);
+
+  cur = mpeg_find_start_code (&(p->sync_word), GST_BUFFER_DATA (buf), end);
+  while (cur != NULL) {
+    /* Calculate the offset as tracked since the last flush. Note that cur
+     * points to the last byte of the sync word, so we adjust by -3 to get the
+     * first byte */
+    guint64 offset = p->tracked_offset + (cur - GST_BUFFER_DATA (buf) - 3);
+
+    handle_packet (p, offset, *cur);
+    cur = mpeg_find_start_code (&(p->sync_word), cur, end);
+  }
+}
+
+void
+mpeg_packetiser_handle_eos (MPEGPacketiser * p)
+{
+  /* Append any remaining data to the current block */
+  if (p->tracked_offset > 0) {
+    complete_current_block (p, p->tracked_offset);
+  }
+}
+
+/* Returns a pointer to the block info for the completed block at the
+ * head of the queue, and extracts the bytes from the adapter if requested.
+ * Caller should move to the next block by calling mpeg_packetiser_next_block
+ * afterward.
+ */
+MPEGBlockInfo *
+mpeg_packetiser_get_block (MPEGPacketiser * p, GstBuffer ** buf)
+{
+  MPEGBlockInfo *block;
+
+  if (buf)
+    *buf = NULL;
+
+  if (G_UNLIKELY (p->first_block_idx == -1)) {
+    return NULL;                /* No complete blocks to discard */
+  }
+
+  /* p->first_block_idx can't get set != -1 unless some block storage got
+   * allocated */
+  g_assert (p->blocks != NULL && p->n_blocks != 0);
+  block = p->blocks + p->first_block_idx;
+
+  /* Can only get the buffer out once, so we'll return NULL on later attempts */
+  if (buf != NULL && block->length > 0 && p->adapter_offset <= block->offset) {
+    /* Kick excess data out of the adapter */
+    if (p->adapter_offset < block->offset) {
+      guint64 to_flush = block->offset - p->adapter_offset;
+
+      g_assert (gst_adapter_available (p->adapter) >= to_flush);
+      gst_adapter_flush (p->adapter, to_flush);
+      p->adapter_offset += to_flush;
+    }
+
+    g_assert (gst_adapter_available (p->adapter) >= block->length);
+    *buf = gst_adapter_take_buffer (p->adapter, block->length);
+    p->adapter_offset += block->length;
+
+    GST_BUFFER_TIMESTAMP (*buf) = block->ts;
+  }
+  return block;
+}
+
+/* Advance the first_block pointer to discard a completed block
+ * from the queue */
+void
+mpeg_packetiser_next_block (MPEGPacketiser * p)
+{
+  gint next;
+  MPEGBlockInfo *block;
+
+  block = mpeg_packetiser_get_block (p, NULL);
+  if (G_UNLIKELY (block == NULL))
+    return;                     /* No complete blocks to discard */
+
+  /* Update the statistics regarding the block we're discarding */
+  if (block->flags & MPEG_BLOCK_FLAG_PICTURE)
+    p->n_pictures--;
+
+  next = (p->first_block_idx + 1) % p->n_blocks;
+  if (next == p->cur_block_idx)
+    p->first_block_idx = -1;    /* Discarding the last block */
+  else
+    p->first_block_idx = next;
+}
diff --git a/gst/mpegvideoparse/mpegpacketiser.h b/gst/mpegvideoparse/mpegpacketiser.h
new file mode 100644
index 00000000..202c6d9c
--- /dev/null
+++ b/gst/mpegvideoparse/mpegpacketiser.h
@@ -0,0 +1,116 @@
+/* GStreamer
+ * Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __MPEGPACKETISER_H__
+#define __MPEGPACKETISER_H__
+
+#include <gst/gst.h>
+#include <gst/base/gstadapter.h>
+
+typedef struct MPEGPacketiser MPEGPacketiser;
+typedef struct MPEGBlockInfo MPEGBlockInfo;
+
+/* Packet ID codes for different packet types we
+ * care about */
+#define MPEG_PACKET_PICTURE      0x00
+#define MPEG_PACKET_SLICE_MIN    0x01
+#define MPEG_PACKET_SLICE_MAX    0xaf
+#define MPEG_PACKET_SEQUENCE     0xb3
+#define MPEG_PACKET_EXTENSION    0xb5
+#define MPEG_PACKET_SEQUENCE_END 0xb7
+#define MPEG_PACKET_GOP          0xb8
+#define MPEG_PACKET_NONE         0xff
+
+/* Extension codes we care about */
+#define MPEG_PACKET_EXT_SEQUENCE         0x01
+#define MPEG_PACKET_EXT_SEQUENCE_DISPLAY 0x02
+#define MPEG_PACKET_EXT_QUANT_MATRIX     0x03
+
+/* Flags indicating what type of packets are in this block, some are mutually
+ * exclusive though - ie, sequence packs are accumulated separately. GOP & 
+ * Picture may occur together or separately */
+#define MPEG_BLOCK_FLAG_SEQUENCE  0x01
+#define MPEG_BLOCK_FLAG_PICTURE   0x02
+#define MPEG_BLOCK_FLAG_GOP       0x04
+
+struct MPEGBlockInfo {
+  guint8 first_pack_type;
+  guint8 flags;
+
+  guint64 offset;
+  guint32 length;
+
+  GstClockTime ts;
+};
+
+struct MPEGPacketiser {
+  GstAdapter *adapter;
+  /* position in the adapter */
+  guint64 adapter_offset;
+
+  /* Sync word accumulator */
+  guint32 sync_word;
+
+  /* Offset since the last flush (unrelated to incoming buffer offsets) */
+  guint64 tracked_offset;
+
+  /* Number of picture packets currently collected */
+  guint n_pictures;
+
+  /* 2 sets of timestamps + offsets used to mark picture blocks
+   * The first is used when a sync word overlaps packet boundaries
+   * and comes from some buffer in the past. The next one comes from current
+   * buffer. These are only ever valid when handling streams from a demuxer,
+   * of course. */ 
+  GstClockTime prev_buf_ts;
+  GstClockTime cur_buf_ts;
+
+  /* MPEG id of the previous SEQUENCE, PICTURE or GOP packet. 
+     MPEG_PACKET_NONE after a flush */
+  guint8  prev_sync_packet;
+
+  /* Indices into the blocks array. cur_block_idx is where we're writing and
+     indicates the end of the populated block entries.
+     first_block_idx is the read ptr. It may be -1 to indicate there are no
+     complete blocks available */
+  gint cur_block_idx;
+  gint first_block_idx;
+
+  /* An array of MPEGBlockInfo entries, used as a growable circular buffer
+   * indexed by cur_block_idx and bounded by last_block_idx */
+  gint n_blocks;
+  MPEGBlockInfo *blocks;
+};
+
+guint8 *mpeg_find_start_code (guint32 *sync_word, guint8 *cur, guint8 *end);
+
+void mpeg_packetiser_init (MPEGPacketiser *p);
+void mpeg_packetiser_free (MPEGPacketiser *p);
+
+void mpeg_packetiser_add_buf (MPEGPacketiser *p, GstBuffer *buf);
+void mpeg_packetiser_handle_eos (MPEGPacketiser *p);
+
+void mpeg_packetiser_flush (MPEGPacketiser *p);
+
+/* Get the blockinfo and buffer for the block at the head of the queue */
+MPEGBlockInfo *mpeg_packetiser_get_block (MPEGPacketiser *p, GstBuffer **buf);
+
+/* Advance to the next data block */
+void mpeg_packetiser_next_block (MPEGPacketiser *p);
+
+#endif
diff --git a/gst/mpegvideoparse/mpegvideoparse.c b/gst/mpegvideoparse/mpegvideoparse.c
new file mode 100644
index 00000000..18464507
--- /dev/null
+++ b/gst/mpegvideoparse/mpegvideoparse.c
@@ -0,0 +1,629 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+#include "mpegvideoparse.h"
+
+/* FIXME: there are still some things to do in this element.
+ * + Handle Sequence Display Extension to output the display size
+ *   rather than the encoded size.
+ * + Collect a list of regions and the sequence headers that apply
+ *   to each region so that we properly handle SEQUENCE_END followed
+ *   by a new sequence.
+ * + At least detect when the sequence changes and error out instead.
+ * + Do all the other stuff (documentation, tests) to get it into
+ *   ugly or good.
+ * + low priority:
+ *   - handle seeking in raw elementary streams
+ *   - calculate timestamps for all un-timestamped frames, taking into
+ *     account frame re-ordering. Doing this probably requires introducing
+ *     an extra end-to-end delay, however so might not be really desirable.
+ */
+GST_DEBUG_CATEGORY_STATIC (mpv_parse_debug);
+#define GST_CAT_DEFAULT mpv_parse_debug
+
+/* elementfactory information */
+static GstElementDetails mpegvideoparse_details =
+GST_ELEMENT_DETAILS ("MPEG video elementary stream parser",
+    "Codec/Parser/Video",
+    "Parses and frames MPEG-1 and MPEG-2 elementary video streams",
+    "Wim Taymans <wim.taymans@chello.be>\n"
+    "Jan Schmidt <thaytan@mad.scientist.com>");
+
+static GstStaticPadTemplate src_template =
+GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/mpeg, "
+        "mpegversion = (int) [ 1, 2 ], "
+        "parsed = (boolean) true, "
+        "systemstream = (boolean) false, "
+        "width = (int) [ 16, 4096 ], "
+        "height = (int) [ 16, 4096 ], "
+        "pixel-aspect-ratio = (fraction) [ 0/1, MAX ], "
+        "framerate = (fraction) [ 0/1, MAX ]")
+    );
+
+static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/mpeg, "
+        "mpegversion = (int) [ 1, 2 ], "
+        "parsed = (boolean) false, " "systemstream = (boolean) false")
+    );
+
+/* MpegVideoParse signals and args */
+enum
+{
+  /* FILL ME */
+  LAST_SIGNAL
+};
+
+enum
+{
+  ARG_0
+      /* FILL ME */
+};
+
+static void gst_mpegvideoparse_class_init (MpegVideoParseClass * klass);
+static void gst_mpegvideoparse_base_init (MpegVideoParseClass * klass);
+static void gst_mpegvideoparse_init (MpegVideoParse * mpegvideoparse);
+static void gst_mpegvideoparse_dispose (MpegVideoParse * mpegvideoparse);
+
+static GstFlowReturn gst_mpegvideoparse_chain (GstPad * pad, GstBuffer * buf);
+static gboolean mpv_parse_sink_event (GstPad * pad, GstEvent * event);
+static void gst_mpegvideoparse_flush (MpegVideoParse * mpegvideoparse);
+static GstStateChangeReturn
+gst_mpegvideoparse_change_state (GstElement * element,
+    GstStateChange transition);
+
+static GstElementClass *parent_class = NULL;
+
+/*static guint gst_mpegvideoparse_signals[LAST_SIGNAL] = { 0 }; */
+
+GType
+mpegvideoparse_get_type (void)
+{
+  static GType mpegvideoparse_type = 0;
+
+  if (!mpegvideoparse_type) {
+    static const GTypeInfo mpegvideoparse_info = {
+      sizeof (MpegVideoParseClass),
+      (GBaseInitFunc) gst_mpegvideoparse_base_init,
+      NULL,
+      (GClassInitFunc) gst_mpegvideoparse_class_init,
+      NULL,
+      NULL,
+      sizeof (MpegVideoParse),
+      0,
+      (GInstanceInitFunc) gst_mpegvideoparse_init,
+    };
+
+    mpegvideoparse_type =
+        g_type_register_static (GST_TYPE_ELEMENT, "MpegVideoParse",
+        &mpegvideoparse_info, 0);
+  }
+  return mpegvideoparse_type;
+}
+
+static void
+gst_mpegvideoparse_base_init (MpegVideoParseClass * klass)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&src_template));
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&sink_template));
+
+  gst_element_class_set_details (element_class, &mpegvideoparse_details);
+}
+
+static void
+gst_mpegvideoparse_class_init (MpegVideoParseClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gstelement_class = (GstElementClass *) klass;
+  gobject_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->dispose = (GObjectFinalizeFunc) (gst_mpegvideoparse_dispose);
+  gstelement_class->change_state = gst_mpegvideoparse_change_state;
+}
+
+static void
+mpv_parse_reset (MpegVideoParse * mpegvideoparse)
+{
+  mpegvideoparse->seq_hdr.mpeg_version = 0;
+  mpegvideoparse->seq_hdr.width = mpegvideoparse->seq_hdr.height = -1;
+  mpegvideoparse->seq_hdr.fps_n = mpegvideoparse->seq_hdr.par_w = 0;
+  mpegvideoparse->seq_hdr.fps_d = mpegvideoparse->seq_hdr.par_h = 1;
+}
+
+static void
+gst_mpegvideoparse_init (MpegVideoParse * mpegvideoparse)
+{
+  mpegvideoparse->sinkpad =
+      gst_pad_new_from_static_template (&sink_template, "sink");
+  gst_pad_set_chain_function (mpegvideoparse->sinkpad,
+      gst_mpegvideoparse_chain);
+  gst_pad_set_event_function (mpegvideoparse->sinkpad, mpv_parse_sink_event);
+  gst_element_add_pad (GST_ELEMENT (mpegvideoparse), mpegvideoparse->sinkpad);
+
+  mpegvideoparse->srcpad =
+      gst_pad_new_from_static_template (&src_template, "src");
+  gst_pad_use_fixed_caps (mpegvideoparse->srcpad);
+  gst_element_add_pad (GST_ELEMENT (mpegvideoparse), mpegvideoparse->srcpad);
+
+  mpeg_packetiser_init (&mpegvideoparse->packer);
+
+  mpv_parse_reset (mpegvideoparse);
+}
+
+void
+gst_mpegvideoparse_dispose (MpegVideoParse * mpegvideoparse)
+{
+  mpeg_packetiser_free (&mpegvideoparse->packer);
+  gst_buffer_replace (&mpegvideoparse->seq_hdr_buf, NULL);
+}
+
+/* Set the Pixel Aspect Ratio in our hdr from a DAR code in the data */
+static void
+set_par_from_dar (MPEGSeqHdr * hdr, guint8 asr_code)
+{
+  /* Pixel_width = DAR_width * display_vertical_size */
+  /* Pixel_height = DAR_height * display_horizontal_size */
+  switch (asr_code) {
+    case 0x02:                 /* 3:4 DAR = 4:3 pixels */
+      hdr->par_w = 4 * hdr->height;
+      hdr->par_h = 3 * hdr->width;
+      break;
+    case 0x03:                 /* 9:16 DAR */
+      hdr->par_w = 16 * hdr->height;
+      hdr->par_h = 9 * hdr->width;
+      break;
+    case 0x04:                 /* 1:2.21 DAR */
+      hdr->par_w = 221 * hdr->height;
+      hdr->par_h = 100 * hdr->width;
+      break;
+    case 0x01:                 /* Square pixels */
+    default:
+      hdr->par_w = hdr->par_h = 1;
+      break;
+  }
+}
+
+static void
+set_fps_from_code (MPEGSeqHdr * hdr, guint8 fps_code)
+{
+  const gint framerates[][2] = {
+    {30, 1}, {24000, 1001}, {24, 1}, {25, 1},
+    {30000, 1001}, {30, 1}, {50, 1}, {60000, 1001},
+    {60, 1}, {30, 1}
+  };
+
+  if (fps_code < 10) {
+    hdr->fps_n = framerates[fps_code][0];
+    hdr->fps_d = framerates[fps_code][1];
+  } else {
+    /* Force a valid framerate */
+    hdr->fps_n = 30;
+    hdr->fps_d = 1;
+  }
+}
+
+static void
+mpegvideoparse_parse_seq (MpegVideoParse * mpegvideoparse, GstBuffer * buf)
+{
+  MPEGSeqHdr new_hdr;
+  guint32 code;
+  guint8 dar_idx, fps_idx;
+  gint seq_data_length;
+  guint32 sync_word = 0xffffffff;
+  guint8 *cur, *end;
+  gboolean constrained_flag;
+  gboolean load_intra_flag;
+  gboolean load_non_intra_flag;
+
+  cur = GST_BUFFER_DATA (buf);
+  end = GST_BUFFER_DATA (buf) + GST_BUFFER_SIZE (buf);
+
+  if (GST_BUFFER_SIZE (buf) < 12)
+    return;                     /* Too small to be a sequence header */
+
+  seq_data_length = 12;         /* minimum length. */
+
+  /* Skip the sync word */
+  cur += 4;
+
+  /* Parse the MPEG 1 bits */
+  new_hdr.mpeg_version = 1;
+
+  code = GST_READ_UINT32_BE (cur);
+  new_hdr.width = (code >> 20) & 0xfff;
+  new_hdr.height = (code >> 8) & 0xfff;
+
+  dar_idx = (code >> 4) & 0xf;
+  set_par_from_dar (&new_hdr, dar_idx);
+  fps_idx = code & 0xf;
+  set_fps_from_code (&new_hdr, fps_idx);
+
+  constrained_flag = (cur[7] >> 2) & 0x01;
+  load_intra_flag = (cur[7] >> 1) & 0x01;
+  if (load_intra_flag) {
+    seq_data_length += 64;      /* 8 rows of 8 bytes of intra matrix */
+    if (GST_BUFFER_SIZE (buf) < seq_data_length)
+      return;
+    cur += 64;
+  }
+
+  load_non_intra_flag = cur[7] & 0x01;
+  if (load_non_intra_flag) {
+    seq_data_length += 64;      /* 8 rows of 8 bytes of non-intra matrix */
+    if (GST_BUFFER_SIZE (buf) < seq_data_length)
+      return;
+    cur += 64;
+  }
+
+  /* Skip the rest of the MPEG-1 header */
+  cur += 8;
+
+  /* Read MPEG-2 sequence extensions */
+  cur = mpeg_find_start_code (&sync_word, cur, end);
+  while (cur != NULL) {
+    /* Cur points at the last byte of the start code */
+    if (cur[0] == MPEG_PACKET_EXTENSION) {
+      guint8 ext_code;
+
+      if ((end - cur - 1) < 1)
+        return;                 /* short extension packet extension */
+
+      ext_code = cur[1] >> 4;
+      if (ext_code == MPEG_PACKET_EXT_SEQUENCE) {
+        /* Parse a Sequence Extension */
+        guint8 horiz_size_ext, vert_size_ext;
+        guint8 fps_n_ext, fps_d_ext;
+
+        if ((end - cur - 1) < 7)
+          /* need at least 10 bytes, minus 3 for the start code 000001 */
+          return;
+
+        horiz_size_ext = ((cur[2] << 1) & 0x02) | ((cur[3] >> 7) & 0x01);
+        vert_size_ext = (cur[3] >> 5) & 0x03;
+        fps_n_ext = (cur[6] >> 5) & 0x03;
+        fps_d_ext = cur[6] & 0x1f;
+
+        new_hdr.fps_n *= (fps_n_ext + 1);
+        new_hdr.fps_d *= (fps_d_ext + 1);
+        new_hdr.width += (horiz_size_ext << 12);
+        new_hdr.height += (vert_size_ext << 12);
+      }
+
+      new_hdr.mpeg_version = 2;
+    }
+    cur = mpeg_find_start_code (&sync_word, cur, end);
+  }
+
+  if (new_hdr.par_w != mpegvideoparse->seq_hdr.par_w ||
+      new_hdr.par_h != mpegvideoparse->seq_hdr.par_h ||
+      new_hdr.fps_n != mpegvideoparse->seq_hdr.fps_n ||
+      new_hdr.fps_d != mpegvideoparse->seq_hdr.fps_d ||
+      new_hdr.width != mpegvideoparse->seq_hdr.width ||
+      new_hdr.height != mpegvideoparse->seq_hdr.height ||
+      new_hdr.mpeg_version != mpegvideoparse->seq_hdr.mpeg_version) {
+    GstCaps *caps;
+    GstBuffer *seq_buf;
+
+    /* Store the entire sequence header + sequence header extension
+       for output as codec_data */
+    seq_buf = gst_buffer_copy (buf);
+    gst_buffer_replace (&mpegvideoparse->seq_hdr_buf, seq_buf);
+    gst_buffer_unref (seq_buf);
+
+    /* And update the new_hdr into our stored version */
+    memcpy (&mpegvideoparse->seq_hdr, &new_hdr, sizeof (MPEGSeqHdr));
+
+    caps = gst_caps_new_simple ("video/mpeg",
+        "systemstream", G_TYPE_BOOLEAN, FALSE,
+        "parsed", G_TYPE_BOOLEAN, TRUE,
+        "mpegversion", G_TYPE_INT, new_hdr.mpeg_version,
+        "width", G_TYPE_INT, new_hdr.width,
+        "height", G_TYPE_INT, new_hdr.height,
+        "framerate", GST_TYPE_FRACTION, new_hdr.fps_n, new_hdr.fps_d,
+        "pixel-aspect-ratio", GST_TYPE_FRACTION, new_hdr.par_w, new_hdr.par_h,
+        "codec_data", GST_TYPE_BUFFER, seq_buf, NULL);
+
+    GST_DEBUG ("New mpegvideoparse caps: %" GST_PTR_FORMAT, caps);
+    gst_pad_set_caps (mpegvideoparse->srcpad, caps);
+  }
+}
+
+#if 0
+static guint64
+gst_mpegvideoparse_time_code (guchar * gop, MPEGSeqHdr * seq_hdr)
+{
+  guint32 data = GST_READ_UINT32_BE (gop);
+  guint64 seconds;
+  guint8 frames;
+
+  seconds = ((data & 0xfc000000) >> 26) * 3600; /* hours */
+  seconds += ((data & 0x03f00000) >> 20) * 60;  /* minutes */
+  seconds += (data & 0x0007e000) >> 13; /* seconds */
+
+  frames = (data & 0x00001f80) >> 7;
+
+  return seconds * GST_SECOND + gst_util_uint64_scale_int (frames * GST_SECOND,
+      seq_hdr->fps_d, seq_hdr->fps_n);
+}
+#endif
+
+static void
+gst_mpegvideoparse_flush (MpegVideoParse * mpegvideoparse)
+{
+  GST_DEBUG_OBJECT (mpegvideoparse, "mpegvideoparse: flushing");
+
+  mpegvideoparse->next_offset = GST_BUFFER_OFFSET_NONE;
+}
+
+static GstFlowReturn
+mpegvideoparse_drain_avail (MpegVideoParse * mpegvideoparse)
+{
+  MPEGBlockInfo *cur;
+  GstBuffer *buf;
+  GstFlowReturn res = GST_FLOW_OK;
+
+  cur = mpeg_packetiser_get_block (&mpegvideoparse->packer, &buf);
+  while (cur != NULL) {
+    /* Handle the block */
+    GST_LOG_OBJECT (mpegvideoparse,
+        "Have block of size %u with pack_type 0x%02x and flags 0x%02x\n",
+        cur->length, cur->first_pack_type, cur->flags);
+
+    /* Don't start pushing out buffers until we've seen a sequence header */
+    if (mpegvideoparse->seq_hdr.mpeg_version == 0) {
+      if ((cur->flags & MPEG_BLOCK_FLAG_SEQUENCE) == 0) {
+        if (buf) {
+          GST_DEBUG_OBJECT (mpegvideoparse,
+              "No sequence header yet. Dropping buffer of %u bytes",
+              GST_BUFFER_SIZE (buf));
+          gst_buffer_unref (buf);
+          buf = NULL;
+        }
+      } else {
+        /* Found a sequence header */
+        mpegvideoparse_parse_seq (mpegvideoparse, buf);
+      }
+    }
+
+    if (buf != NULL) {
+      GST_DEBUG_OBJECT (mpegvideoparse,
+          "mpegvideoparse: pushing buffer of %u bytes with ts %"
+          GST_TIME_FORMAT, GST_BUFFER_SIZE (buf),
+          GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
+      gst_buffer_set_caps (buf, GST_PAD_CAPS (mpegvideoparse->srcpad));
+      if (mpegvideoparse->need_discont) {
+        GST_DEBUG_OBJECT (mpegvideoparse,
+            "setting discont flag on outgoing buffer");
+        GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
+        mpegvideoparse->need_discont = FALSE;
+      }
+      res = gst_pad_push (mpegvideoparse->srcpad, buf);
+      if (res != GST_FLOW_OK)
+        break;
+    }
+
+    /* Advance to the next data block */
+    mpeg_packetiser_next_block (&mpegvideoparse->packer);
+    cur = mpeg_packetiser_get_block (&mpegvideoparse->packer, &buf);
+  };
+
+  return res;
+}
+
+static GstFlowReturn
+gst_mpegvideoparse_chain (GstPad * pad, GstBuffer * buf)
+{
+  MpegVideoParse *mpegvideoparse;
+  GstFlowReturn res;
+  gboolean have_discont;
+  gint64 next_offset = GST_BUFFER_OFFSET_NONE;
+
+  g_return_val_if_fail (pad != NULL, GST_FLOW_ERROR);
+  g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
+
+  mpegvideoparse =
+      GST_MPEGVIDEOPARSE (gst_object_get_parent (GST_OBJECT (pad)));
+
+  GST_DEBUG_OBJECT (mpegvideoparse,
+      "mpegvideoparse: received buffer of %u bytes with ts %"
+      GST_TIME_FORMAT, GST_BUFFER_SIZE (buf),
+      GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
+
+  /* If we have an offset, and the incoming offset doesn't match, 
+     or we have a discont, handle it first by flushing out data
+     we have collected. */
+  have_discont = GST_BUFFER_IS_DISCONT (buf);
+
+  if (mpegvideoparse->next_offset != GST_BUFFER_OFFSET_NONE) {
+    if (GST_BUFFER_OFFSET_IS_VALID (buf)) {
+      if (mpegvideoparse->next_offset != GST_BUFFER_OFFSET (buf))
+        have_discont = TRUE;
+      next_offset = GST_BUFFER_OFFSET (buf) + GST_BUFFER_SIZE (buf);
+    } else {
+      next_offset = mpegvideoparse->next_offset + GST_BUFFER_SIZE (buf);
+    }
+  }
+
+  if (have_discont) {
+    GST_DEBUG_OBJECT (mpegvideoparse, "Have discont packet, draining data");
+    mpegvideoparse->need_discont = TRUE;
+
+    mpeg_packetiser_handle_eos (&mpegvideoparse->packer);
+    res = mpegvideoparse_drain_avail (mpegvideoparse);
+    mpeg_packetiser_flush (&mpegvideoparse->packer);
+    if (res != GST_FLOW_OK) {
+      mpegvideoparse->next_offset = next_offset;
+      gst_buffer_unref (buf);
+      return res;
+    }
+  }
+
+  /* Takes ownership of the data */
+  mpeg_packetiser_add_buf (&mpegvideoparse->packer, buf);
+
+  /* And push out what we can */
+  res = mpegvideoparse_drain_avail (mpegvideoparse);
+
+  /* Update our offset */
+  mpegvideoparse->next_offset = next_offset;
+
+  gst_object_unref (mpegvideoparse);
+  return res;
+}
+
+static gboolean
+mpv_parse_sink_event (GstPad * pad, GstEvent * event)
+{
+  gboolean res = TRUE;
+  MpegVideoParse *mpegvideoparse =
+      GST_MPEGVIDEOPARSE (gst_pad_get_parent (pad));
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_NEWSEGMENT:
+    {
+      gdouble rate, applied_rate;
+      GstFormat format;
+      gint64 start, stop, pos;
+      gboolean update;
+
+      gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
+          &format, &start, &stop, &pos);
+
+      if (format == GST_FORMAT_BYTES) {
+        /* FIXME: Later, we might use a seek table to seek on elementary stream
+           files, and that would allow byte-to-time conversions. It's not a high
+           priority - most mpeg video is muxed and then the demuxer handles 
+           seeking. In the meantime, here's some commented out logic copied
+           from mp3parse */
+#if 0
+        GstClockTime seg_start, seg_stop, seg_pos;
+
+        /* stop time is allowed to be open-ended, but not start & pos */
+        if (!mp3parse_bytepos_to_time (mp3parse, stop, &seg_stop))
+          seg_stop = GST_CLOCK_TIME_NONE;
+        if (mp3parse_bytepos_to_time (mp3parse, start, &seg_start) &&
+            mp3parse_bytepos_to_time (mp3parse, pos, &seg_pos)) {
+          gst_event_unref (event);
+          event = gst_event_new_new_segment_full (update, rate, applied_rate,
+              GST_FORMAT_TIME, seg_start, seg_stop, seg_pos);
+          format = GST_FORMAT_TIME;
+          GST_DEBUG_OBJECT (mp3parse, "Converted incoming segment to TIME. "
+              "start = %" G_GINT64_FORMAT ", stop = %" G_GINT64_FORMAT
+              "pos = %" G_GINT64_FORMAT, seg_start, seg_stop, seg_pos);
+        }
+#endif
+      }
+
+      if (format != GST_FORMAT_TIME) {
+        /* Unknown incoming segment format. Output a default open-ended 
+         * TIME segment */
+        gst_event_unref (event);
+        event = gst_event_new_new_segment_full (update, rate, applied_rate,
+            GST_FORMAT_TIME, 0, GST_CLOCK_TIME_NONE, 0);
+      }
+
+      gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,
+          &format, &start, &stop, &pos);
+      GST_DEBUG_OBJECT (mpegvideoparse,
+          "Pushing newseg rate %g, applied rate %g, "
+          "format %d, start %lld, stop %lld, pos %lld\n",
+          rate, applied_rate, format, start, stop, pos);
+
+      res = gst_pad_event_default (pad, event);
+      break;
+    }
+    case GST_EVENT_FLUSH_STOP:
+      gst_mpegvideoparse_flush (mpegvideoparse);
+      res = gst_pad_event_default (pad, event);
+      break;
+    case GST_EVENT_EOS:
+
+      /* Push any remaining buffers out, then flush. */
+      mpeg_packetiser_handle_eos (&mpegvideoparse->packer);
+      mpegvideoparse_drain_avail (mpegvideoparse);
+      gst_mpegvideoparse_flush (mpegvideoparse);
+
+      res = gst_pad_event_default (pad, event);
+      break;
+    default:
+      res = gst_pad_event_default (pad, event);
+      break;
+  }
+
+  gst_object_unref (mpegvideoparse);
+  return res;
+}
+
+static GstStateChangeReturn
+gst_mpegvideoparse_change_state (GstElement * element,
+    GstStateChange transition)
+{
+  MpegVideoParse *mpegvideoparse;
+  GstStateChangeReturn ret;
+
+  g_return_val_if_fail (GST_IS_MPEGVIDEOPARSE (element),
+      GST_STATE_CHANGE_FAILURE);
+
+  mpegvideoparse = GST_MPEGVIDEOPARSE (element);
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      mpv_parse_reset (mpegvideoparse);
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  GST_DEBUG_CATEGORY_INIT (mpv_parse_debug, "mpegvideoparse", 0,
+      "MPEG Video Parser");
+
+  return gst_element_register (plugin, "mpegvideoparse",
+      GST_RANK_SECONDARY - 1, GST_TYPE_MPEGVIDEOPARSE);
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "mpegvideoparse",
+    "MPEG-1 and MPEG-2 video parser",
+    plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)
diff --git a/gst/mpegvideoparse/mpegvideoparse.h b/gst/mpegvideoparse/mpegvideoparse.h
new file mode 100644
index 00000000..99c6722c
--- /dev/null
+++ b/gst/mpegvideoparse/mpegvideoparse.h
@@ -0,0 +1,79 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) <2007> Jan Schmidt <thaytan@mad.scientist.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __MPEGVIDEOPARSE_H__
+#define __MPEGVIDEOPARSE_H__
+
+#include <gst/gst.h>
+#include "mpegpacketiser.h"
+
+G_BEGIN_DECLS
+
+#define GST_TYPE_MPEGVIDEOPARSE \
+  (mpegvideoparse_get_type())
+#define GST_MPEGVIDEOPARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MPEGVIDEOPARSE,MpegVideoParse))
+#define GST_MPEGVIDEOPARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MPEGVIDEOPARSE,MpegVideoParseClass))
+#define GST_IS_MPEGVIDEOPARSE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MPEGVIDEOPARSE))
+#define GST_IS_MPEGVIDEOPARSE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MPEGVIDEOPARSE))
+
+typedef struct _MpegVideoParse MpegVideoParse;
+typedef struct _MpegVideoParseClass MpegVideoParseClass;
+
+typedef struct MPEGSeqHdr
+{
+  /* 0 for unknown, else 1 or 2 */
+  guint8 mpeg_version;
+
+  /* Pixel-Aspect Ratio from DAR code via set_par_from_dar */
+  gint par_w, par_h;
+  /* Width and Height of the video */
+  gint width, height;
+  /* Framerate */
+  gint fps_n, fps_d;
+} MPEGSeqHdr;
+
+struct _MpegVideoParse {
+  GstElement element;
+
+  GstPad *sinkpad, *srcpad;
+
+  gint64 next_offset;
+  gboolean need_discont;
+
+  /* Info from the Sequence Header */
+  MPEGSeqHdr seq_hdr;
+  GstBuffer *seq_hdr_buf;
+
+  /* Packetise helper */
+  MPEGPacketiser packer;
+};
+
+struct _MpegVideoParseClass {
+  GstElementClass parent_class;
+};
+
+GType gst_mpegvideoparse_get_type(void);
+
+G_END_DECLS
+
+#endif /* __MPEGVIDEOPARSE_H__ */
diff --git a/gst/mpeg1videoparse/mp1videoparse.vcproj b/gst/mpegvideoparse/mpegvideoparse.vcproj
index 62f5d34c..7aed71ac 100644
--- a/gst/mpeg1videoparse/mp1videoparse.vcproj
+++ b/gst/mpegvideoparse/mpegvideoparse.vcproj
@@ -2,7 +2,7 @@
 <VisualStudioProject
 	ProjectType="Visual C++"
 	Version="7.10"
-	Name="mp1videoparse"
+	Name="mpegvideoparse"
 	ProjectGUID="{979C216F-0ACF-4956-AE00-055A42D678E6}"
 	Keyword="Win32Proj">
 	<Platforms>
@@ -20,7 +20,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="0"
 				AdditionalIncludeDirectories="../../../gstreamer/win32;../../../gstreamer;../../../gstreamer/libs;../../../glib;../../../glib/glib;../../../glib/gmodule;&quot;../../gst-libs&quot;;../../../popt/include;../../../libxml2/include/libxml2"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;mp1videoparse_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;mpegvideoparse_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
 				MinimalRebuild="TRUE"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
@@ -33,15 +33,15 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalDependencies="glib-2.0.lib gmodule-2.0.lib gthread-2.0.lib gobject-2.0.lib libgstreamer.lib gstbytestream.lib iconv.lib intl.lib"
-				OutputFile="$(OutDir)/gstmp1videoparse.dll"
+				OutputFile="$(OutDir)/mpegvideoparse.dll"
 				LinkIncremental="2"
 				AdditionalLibraryDirectories="../../../gstreamer/win32/Debug;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
 				ModuleDefinitionFile=""
 				GenerateDebugInformation="TRUE"
-				ProgramDatabaseFile="$(OutDir)/mp1videoparse.pdb"
+				ProgramDatabaseFile="$(OutDir)/mpegvideoparse.pdb"
 				SubSystem="2"
 				OptimizeReferences="2"
-				ImportLibrary="$(OutDir)/gstmp1videoparse.lib"
+				ImportLibrary="$(OutDir)/mpegvideoparse.lib"
 				TargetMachine="1"/>
 			<Tool
 				Name="VCMIDLTool"/>
@@ -74,7 +74,7 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				AdditionalIncludeDirectories="../../../gstreamer/win32;../../../gstreamer;../../../gstreamer/libs;../../../glib;../../../glib/glib;../../../glib/gmodule;&quot;../../gst-libs&quot;;../../../popt/include;../../../libxml2/include/libxml2"
-				PreprocessorDefinitions="WIN32;NDEBUG;GST_DISABLE_GST_DEBUG;_WINDOWS;_USRDLL;mp1videoparse_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
+				PreprocessorDefinitions="WIN32;NDEBUG;GST_DISABLE_GST_DEBUG;_WINDOWS;_USRDLL;mpegvideoparse_EXPORTS;HAVE_CONFIG_H;_USE_MATH_DEFINES"
 				RuntimeLibrary="2"
 				UsePrecompiledHeader="0"
 				WarningLevel="3"
@@ -85,7 +85,7 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalDependencies="glib-2.0.lib gmodule-2.0.lib gthread-2.0.lib gobject-2.0.lib libgstreamer.lib gstbytestream.lib iconv.lib intl.lib"
-				OutputFile="$(OutDir)/gstmp1videoparse.dll"
+				OutputFile="$(OutDir)/mpegvideoparse.dll"
 				LinkIncremental="1"
 				AdditionalLibraryDirectories="../../../gstreamer/win32/Release;../../../glib/glib;../../../glib/gmodule;../../../glib/gthread;../../../glib/gobject;../../../gettext/lib;../../../libiconv/lib"
 				ModuleDefinitionFile=""
@@ -93,7 +93,7 @@
 				SubSystem="2"
 				OptimizeReferences="2"
 				EnableCOMDATFolding="2"
-				ImportLibrary="$(OutDir)/gstmp1videoparse.lib"
+				ImportLibrary="$(OutDir)/mpegvideoparse.lib"
 				TargetMachine="1"/>
 			<Tool
 				Name="VCMIDLTool"/>
@@ -126,7 +126,7 @@
 			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
 			<File
-				RelativePath=".\gstmp1videoparse.c">
+				RelativePath=".\mpegvideoparse.c">
 			</File>
 		</Filter>
 		<Filter
@@ -134,7 +134,7 @@
 			Filter="h;hpp;hxx;hm;inl;inc;xsd"
 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
 			<File
-				RelativePath=".\gstmp1videoparse.h">
+				RelativePath=".\mpegvideoparse.h">
 			</File>
 		</Filter>
 		<Filter