diff -Nur gst-plugins-ugly0.10-0.10.4/ext/dvdread/dvdreadsrc.c gst-plugins-ugly0.10-0.10.4.new/ext/dvdread/dvdreadsrc.c
--- gst-plugins-ugly0.10-0.10.4/ext/dvdread/dvdreadsrc.c	2006-08-14 03:16:14.000000000 -0600
+++ gst-plugins-ugly0.10-0.10.4.new/ext/dvdread/dvdreadsrc.c	2006-12-03 10:10:44.000000000 -0700
@@ -278,7 +278,7 @@
   src->chapter = 0;
   src->title = 0;
   src->need_newsegment = TRUE;
-  src->vts_tmapt = NULL;
+  src->tmap = NULL;
   if (src->title_lang_event_pending) {
     gst_event_unref (src->title_lang_event_pending);
     src->title_lang_event_pending = NULL;
@@ -339,7 +339,6 @@
 static gboolean
 gst_dvd_read_src_goto_chapter (GstDvdReadSrc * src, gint chapter)
 {
-  gint i;
 
   /* make sure the chapter number is valid for this title */
   if (chapter < 0 || chapter >= src->num_chapters) {
@@ -359,19 +358,9 @@
       src->start_cell, src->last_cell);
 
   /* retrieve position */
-  src->cur_pack = 0;
-  for (i = 0; i < chapter; i++) {
-    gint c1, c2;
-
-    cur_title_get_chapter_bounds (src, i, &c1, &c2);
-
-    while (c1 < c2) {
-      src->cur_pack +=
-          src->cur_pgc->cell_playback[c1].last_sector -
-          src->cur_pgc->cell_playback[c1].first_sector;
-      ++c1;
-    }
-  }
+  gint c1, c2;
+  cur_title_get_chapter_bounds (src, chapter, &c1, &c2);
+  src->cur_pack = src->cur_pgc->cell_playback[c1].first_sector;
 
   /* prepare reading for new cell */
   src->new_cell = TRUE;
@@ -532,31 +521,20 @@
   src->title_lang_event_pending =
       gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s);
 
-  /* dump seek tables */
-  src->vts_tmapt = src->vts_file->vts_tmapt;
-  if (src->vts_tmapt) {
-    gint i, j;
-
-    GST_LOG_OBJECT (src, "nr_of_tmaps = %d", src->vts_tmapt->nr_of_tmaps);
-    for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
-      GST_LOG_OBJECT (src, "======= Table %d ===================", i);
-      GST_LOG_OBJECT (src, "Offset relative to VTS_TMAPTI: %d",
-          src->vts_tmapt->tmap_offset[i]);
-      GST_LOG_OBJECT (src, "Time unit (seconds)          : %d",
-          src->vts_tmapt->tmap[i].tmu);
-      GST_LOG_OBJECT (src, "Number of entries            : %d",
-          src->vts_tmapt->tmap[i].nr_of_entries);
-      for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; j++) {
-        guint64 time;
-
-        time = src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
-        GST_LOG_OBJECT (src, "Time: %" GST_TIME_FORMAT " VOBU "
-            "Sector: 0x%08x %s", GST_TIME_ARGS (time),
-            src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff,
-            (src->vts_tmapt->tmap[i].map_ent[j] >> 31) ? "discontinuity" : "");
-      }
+  
+  /* If the current title_set has a vts_tmapt, it will have one tmap per
+  title, but we are only interested in the tmap for this title. */
+  if (src->vts_file->vts_tmapt != NULL)
+  {
+    gint i;
+    i = src->ttn - 1;       
+    if (i >= 0 && i < src->vts_file->vts_tmapt->nr_of_tmaps)
+    {
+      src->tmap = & src->vts_file->vts_tmapt->tmap[i];
     }
-  } else {
+  }
+  else 
+  {
     GST_WARNING_OBJECT (src, "no vts_tmapt - seeking will suck");
   }
 
@@ -640,55 +618,55 @@
 /* find time for sector from index, returns NONE if there is no exact match */
 static GstClockTime
 gst_dvd_read_src_get_time_for_sector (GstDvdReadSrc * src, guint sector)
-{
-  gint i, j;
+{  
+  gint i;
 
-  if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0)
+  if (src->tmap == NULL) 
     return GST_CLOCK_TIME_NONE;
-
-  for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
-    for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; ++j) {
-      if ((src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff) == sector)
-        return src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
+    
+  for (i = 0; i < src->tmap->nr_of_entries; i++)
+  {
+    if ((src->tmap->map_ent[i] & 0x7fffffff) == sector)
+    {
+      return src->tmap->tmu * (i + 1) * GST_SECOND;
     }
   }
-
-  if (sector == 0)
-    return (GstClockTime) 0;
-
   return GST_CLOCK_TIME_NONE;
 }
 
-/* returns the sector in the index at (or before) the given time, or -1 */
+
+/* Returns sector for time <= ts, or -1 if src->tmap == NULL */
 static gint
 gst_dvd_read_src_get_sector_from_time (GstDvdReadSrc * src, GstClockTime ts)
 {
-  gint sector, i, j;
+  gint i;
 
-  if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0)
+  if (src->tmap == NULL) 
+  {
+    GST_WARNING_OBJECT (src, 
+      "Trying to get sector from time, but src->tmap == NULL");
     return -1;
-
-  sector = 0;
-  for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
-    for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; ++j) {
-      GstClockTime entry_time;
-
-      entry_time = src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
-      if (entry_time <= ts) {
-        sector = src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff;
-      }
-      if (entry_time >= ts) {
-        return sector;
-      }
-    }
+  }
+    
+  i = ts / GST_SECOND / src->tmap->tmu - 1;
+  
+  if (i < 0)
+  {
+    /* FIXME: we should actually return the start sector for the title,
+    which is not in src->tmap->map_ent[] */
+    i = 0;
+  }
+  else if (i >= src->tmap->nr_of_entries)
+  {
+    GST_WARNING_OBJECT (src, 
+      "Probably trying to seek beyond end of title");
+    i = src->tmap->nr_of_entries - 1;
   }
 
-  if (ts == 0)
-    return 0;
-
-  return -1;
+  return src->tmap->map_ent[i] & 0x7fffffff; // Some high bits aren't used.
 }
 
+
 typedef enum
 {
   GST_DVD_READ_OK = 0,
@@ -984,6 +962,9 @@
   GST_OBJECT_UNLOCK (src);
 }
 
+
+/* Because there can be more than one title in the title_set, this doesn't
+   always return something meaningful. */
 static gboolean
 gst_dvd_read_src_get_size (GstDvdReadSrc * src, gint64 * size)
 {
@@ -1377,59 +1358,63 @@
   return res;
 }
 
+/* sector is absolute (i.e., relative to title_set, not title) */
 static gboolean
 gst_dvd_read_src_goto_sector (GstDvdReadSrc * src, int angle)
-{
+{ 
   gint seek_to = src->cur_pack;
-  gint chapter, sectors, next, cur, i;
+  gint chap, cell;
 
-  /* retrieve position */
-  src->cur_pack = 0;
-  for (i = 0; i < src->num_chapters; i++) {
+  /* find chapter and cell containing sector src->cur_pack */
+  for (chap = 0; chap < src->num_chapters; chap++)
+  {
     gint c1, c2;
+    cur_title_get_chapter_bounds (src, chap, &c1, &c2);
 
-    cur_title_get_chapter_bounds (src, i, &c1, &c2);
-
-    for (next = cur = c1; cur < c2;) {
-      if (next != cur) {
-        sectors =
-            src->cur_pgc->cell_playback[cur].last_sector -
-            src->cur_pgc->cell_playback[cur].first_sector;
-        if (src->cur_pack + sectors > seek_to) {
-          chapter = i;
+    for (cell = c1; cell < c2;) {
+      if (seek_to < src->cur_pgc->cell_playback[cell].first_sector)
+      {
+        /* HACK: Some initial seek to FORMAT_BYTES 0 is being called, maybe
+        from GstBaseSrc, which is breaking things for a title_set with more
+        than one title.  As an aside, querying and seeking by sector (or
+        bytes, which are converted to sectors) is totally broken because of
+        further title starts at sector 0 assumptions throughout the code */
+        seek_to = src->cur_pgc->cell_playback[cell].first_sector;
+        goto done;
+      }
+      if (src->cur_pgc->cell_playback[cell].first_sector <= src->cur_pack &&
+          src->cur_pgc->cell_playback[cell].last_sector >= src->cur_pack)
+      {
+          /* seek_to is in the sector interval for this chap and cell */
           goto done;
-        }
-        src->cur_pack += sectors;
       }
-      cur = next;
-      if (src->cur_pgc->cell_playback[cur].block_type == BLOCK_TYPE_ANGLE_BLOCK)
-        cur += angle;
-      next = gst_dvd_read_src_get_next_cell (src, src->cur_pgc, cur);
+      
+      if (src->cur_pgc->cell_playback[cell].block_type == BLOCK_TYPE_ANGLE_BLOCK)
+        cell += angle;
+        
+      cell = gst_dvd_read_src_get_next_cell (src, src->cur_pgc, cell);
     }
   }
 
-  GST_DEBUG_OBJECT (src, "Seek to sector %u failed", seek_to);
+  GST_WARNING_OBJECT (src, "Seek to sector %u failed", seek_to);
 
   return FALSE;
 
 done:
   {
-    /* so chapter $chapter and cell $cur contain our sector
-     * of interest. Let's go there! */
     GST_INFO_OBJECT (src, "Seek succeeded, going to chapter %u, cell %u",
-        chapter + 1, cur);
-
-    gst_dvd_read_src_goto_chapter (src, chapter);
-    src->cur_cell = cur;
-    src->next_cell = next;
+        chap + 1, cell);
+    gst_dvd_read_src_goto_chapter (src, chap);
+    src->cur_cell = cell;
+    src->next_cell = gst_dvd_read_src_get_next_cell (src, src->cur_pgc, cell);
     src->new_cell = FALSE;
     src->cur_pack = seek_to;
-
     return TRUE;
   }
 }
 
 
+
 /*** URI interface ***/
 
 static GstURIType
diff -Nur gst-plugins-ugly0.10-0.10.4/ext/dvdread/dvdreadsrc.c.orig gst-plugins-ugly0.10-0.10.4.new/ext/dvdread/dvdreadsrc.c.orig
--- gst-plugins-ugly0.10-0.10.4/ext/dvdread/dvdreadsrc.c.orig	1969-12-31 17:00:00.000000000 -0700
+++ gst-plugins-ugly0.10-0.10.4.new/ext/dvdread/dvdreadsrc.c.orig	2006-08-14 03:16:14.000000000 -0600
@@ -0,0 +1,1596 @@
+/* GStreamer DVD title source
+ * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>
+ * Copyright (C) 2001 Billy Biggs <vektor@dumbterm.net>.
+ * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
+ *
+ * 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 "_stdint.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include "dvdreadsrc.h"
+
+#include <gst/gst-i18n-plugin.h>
+
+GST_DEBUG_CATEGORY_STATIC (gstgst_dvd_read_src_debug);
+#define GST_CAT_DEFAULT (gstgst_dvd_read_src_debug)
+
+static void gst_dvd_read_src_do_init (GType dvdreadsrc_type);
+
+enum
+{
+  ARG_0,
+  ARG_DEVICE,
+  ARG_TITLE,
+  ARG_CHAPTER,
+  ARG_ANGLE
+};
+
+static GstElementDetails gst_dvd_read_src_details = {
+  "DVD Source",
+  "Source/File/DVD",
+  "Access a DVD title/chapter/angle using libdvdread",
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+};
+
+static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/mpeg, mpegversion=2, systemstream=(boolean)true"));
+
+static GstFormat title_format;
+static GstFormat angle_format;
+static GstFormat sector_format;
+static GstFormat chapter_format;
+
+static gboolean gst_dvd_read_src_start (GstBaseSrc * basesrc);
+static gboolean gst_dvd_read_src_stop (GstBaseSrc * basesrc);
+static GstFlowReturn gst_dvd_read_src_create (GstPushSrc * pushsrc,
+    GstBuffer ** buf);
+static gboolean gst_dvd_read_src_src_query (GstBaseSrc * basesrc,
+    GstQuery * query);
+static gboolean gst_dvd_read_src_src_event (GstBaseSrc * basesrc,
+    GstEvent * event);
+static gboolean gst_dvd_read_src_goto_title (GstDvdReadSrc * src, gint title,
+    gint angle);
+static gboolean gst_dvd_read_src_goto_chapter (GstDvdReadSrc * src,
+    gint chapter);
+static gboolean gst_dvd_read_src_goto_sector (GstDvdReadSrc * src, gint angle);
+static void gst_dvd_read_src_set_property (GObject * object, guint prop_id,
+    const GValue * value, GParamSpec * pspec);
+static void gst_dvd_read_src_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec);
+static GstEvent *gst_dvd_read_src_make_clut_change_event (GstDvdReadSrc * src,
+    const guint * clut);
+static gboolean gst_dvd_read_src_get_size (GstDvdReadSrc * src, gint64 * size);
+static gboolean gst_dvd_read_src_do_seek (GstBaseSrc * src, GstSegment * s);
+static gint64 gst_dvd_read_src_convert_timecode (dvd_time_t * time);
+static gint gst_dvd_read_src_get_next_cell (GstDvdReadSrc * src,
+    pgc_t * pgc, gint cell);
+static GstClockTime gst_dvd_read_src_get_time_for_sector (GstDvdReadSrc * src,
+    guint sector);
+static gint gst_dvd_read_src_get_sector_from_time (GstDvdReadSrc * src,
+    GstClockTime ts);
+
+GST_BOILERPLATE_FULL (GstDvdReadSrc, gst_dvd_read_src, GstPushSrc,
+    GST_TYPE_PUSH_SRC, gst_dvd_read_src_do_init);
+
+static void
+gst_dvd_read_src_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&srctemplate));
+
+  gst_element_class_set_details (element_class, &gst_dvd_read_src_details);
+}
+
+static void
+gst_dvd_read_src_finalize (GObject * object)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (object);
+
+  g_free (src->location);
+  g_free (src->last_uri);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gst_dvd_read_src_init (GstDvdReadSrc * src, GstDvdReadSrcClass * klass)
+{
+  src->dvd = NULL;
+  src->vts_file = NULL;
+  src->vmg_file = NULL;
+  src->dvd_title = NULL;
+
+  src->location = g_strdup ("/dev/dvd");
+  src->last_uri = NULL;
+  src->new_seek = TRUE;
+  src->new_cell = TRUE;
+  src->change_cell = FALSE;
+  src->uri_title = 1;
+  src->uri_chapter = 1;
+  src->uri_angle = 1;
+
+  src->title_lang_event_pending = NULL;
+  src->pending_clut_event = NULL;
+
+  gst_pad_use_fixed_caps (GST_BASE_SRC_PAD (src));
+  gst_pad_set_caps (GST_BASE_SRC_PAD (src),
+      gst_static_pad_template_get_caps (&srctemplate));
+}
+
+static gboolean
+gst_dvd_read_src_is_seekable (GstBaseSrc * src)
+{
+  return TRUE;
+}
+
+static void
+gst_dvd_read_src_class_init (GstDvdReadSrcClass * klass)
+{
+  GstPushSrcClass *gstpushsrc_class = GST_PUSH_SRC_CLASS (klass);
+  GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = gst_dvd_read_src_finalize;
+  gobject_class->set_property = gst_dvd_read_src_set_property;
+  gobject_class->get_property = gst_dvd_read_src_get_property;
+
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,
+      g_param_spec_string ("device", "Device",
+          "DVD device location", NULL, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TITLE,
+      g_param_spec_int ("title", "title", "title",
+          1, 999, 1, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CHAPTER,
+      g_param_spec_int ("chapter", "chapter", "chapter",
+          1, 999, 1, G_PARAM_READWRITE));
+  g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ANGLE,
+      g_param_spec_int ("angle", "angle", "angle",
+          1, 999, 1, G_PARAM_READWRITE));
+
+  gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_dvd_read_src_start);
+  gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_dvd_read_src_stop);
+  gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_dvd_read_src_src_query);
+  gstbasesrc_class->event = GST_DEBUG_FUNCPTR (gst_dvd_read_src_src_event);
+  gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_dvd_read_src_do_seek);
+  gstbasesrc_class->is_seekable =
+      GST_DEBUG_FUNCPTR (gst_dvd_read_src_is_seekable);
+
+  gstpushsrc_class->create = GST_DEBUG_FUNCPTR (gst_dvd_read_src_create);
+}
+
+static gboolean
+gst_dvd_read_src_start (GstBaseSrc * basesrc)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
+
+  g_return_val_if_fail (src->location != NULL, FALSE);
+
+  GST_DEBUG_OBJECT (src, "Opening DVD '%s'", src->location);
+
+  if ((src->dvd = DVDOpen (src->location)) == NULL)
+    goto open_failed;
+
+  /* Load the video manager to find out the information about the titles */
+  GST_DEBUG_OBJECT (src, "Loading VMG info");
+
+  if (!(src->vmg_file = ifoOpen (src->dvd, 0)))
+    goto ifo_open_failed;
+
+  src->tt_srpt = src->vmg_file->tt_srpt;
+
+  src->title = src->uri_title - 1;
+  src->chapter = src->uri_chapter - 1;
+  src->angle = src->uri_angle - 1;
+
+  if (!gst_dvd_read_src_goto_title (src, src->title, src->angle))
+    goto title_open_failed;
+
+  if (!gst_dvd_read_src_goto_chapter (src, src->chapter))
+    goto chapter_open_failed;
+
+  src->new_seek = FALSE;
+  src->change_cell = TRUE;
+
+  return TRUE;
+
+  /* ERRORS */
+open_failed:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Could not open DVD")),
+        ("DVDOpen(%s) failed: %s", src->location, g_strerror (errno)));
+    return FALSE;
+  }
+ifo_open_failed:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Could not open DVD")),
+        ("ifoOpen() failed: %s", g_strerror (errno)));
+    return FALSE;
+  }
+title_open_failed:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Could not open DVD title %d"), src->uri_title), (NULL));
+    return FALSE;
+  }
+chapter_open_failed:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Failed to go to chapter %d of DVD title %d"),
+            src->uri_chapter, src->uri_title), (NULL));
+    return FALSE;
+  }
+}
+
+static gboolean
+gst_dvd_read_src_stop (GstBaseSrc * basesrc)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
+
+  if (src->vts_file) {
+    ifoClose (src->vts_file);
+    src->vts_file = NULL;
+  }
+  if (src->vmg_file) {
+    ifoClose (src->vmg_file);
+    src->vmg_file = NULL;
+  }
+  if (src->dvd_title) {
+    DVDCloseFile (src->dvd_title);
+    src->dvd_title = NULL;
+  }
+  if (src->dvd) {
+    DVDClose (src->dvd);
+    src->dvd = NULL;
+  }
+  src->new_cell = TRUE;
+  src->new_seek = TRUE;
+  src->change_cell = FALSE;
+  src->chapter = 0;
+  src->title = 0;
+  src->need_newsegment = TRUE;
+  src->vts_tmapt = NULL;
+  if (src->title_lang_event_pending) {
+    gst_event_unref (src->title_lang_event_pending);
+    src->title_lang_event_pending = NULL;
+  }
+  if (src->pending_clut_event) {
+    gst_event_unref (src->pending_clut_event);
+    src->pending_clut_event = NULL;
+  }
+  if (src->chapter_starts) {
+    g_free (src->chapter_starts);
+    src->chapter_starts = NULL;
+  }
+
+  GST_LOG_OBJECT (src, "closed DVD");
+
+  return TRUE;
+}
+
+static void
+cur_title_get_chapter_pgc (GstDvdReadSrc * src, gint chapter, gint * p_pgn,
+    gint * p_pgc_id, pgc_t ** p_pgc)
+{
+  pgc_t *pgc;
+  gint pgn, pgc_id;
+
+  g_assert (chapter >= 0 && chapter < src->num_chapters);
+
+  pgc_id = src->vts_ptt_srpt->title[src->ttn - 1].ptt[chapter].pgcn;
+  pgn = src->vts_ptt_srpt->title[src->ttn - 1].ptt[chapter].pgn;
+  pgc = src->vts_file->vts_pgcit->pgci_srp[pgc_id - 1].pgc;
+
+  *p_pgn = pgn;
+  *p_pgc_id = pgc_id;
+  *p_pgc = pgc;
+}
+
+static void
+cur_title_get_chapter_bounds (GstDvdReadSrc * src, gint chapter,
+    gint * p_first_cell, gint * p_last_cell)
+{
+  pgc_t *pgc;
+  gint pgn, pgc_id, pgn_next_ch;
+
+  g_assert (chapter >= 0 && chapter < src->num_chapters);
+
+  cur_title_get_chapter_pgc (src, chapter, &pgn, &pgc_id, &pgc);
+
+  *p_first_cell = pgc->program_map[pgn - 1] - 1;
+
+  if (chapter == (src->num_chapters - 1)) {
+    *p_last_cell = pgc->nr_of_cells;
+  } else {
+    pgn_next_ch = src->vts_ptt_srpt->title[src->ttn - 1].ptt[chapter + 1].pgn;
+    *p_last_cell = pgc->program_map[pgn_next_ch - 1] - 1;
+  }
+}
+
+static gboolean
+gst_dvd_read_src_goto_chapter (GstDvdReadSrc * src, gint chapter)
+{
+  gint i;
+
+  /* make sure the chapter number is valid for this title */
+  if (chapter < 0 || chapter >= src->num_chapters) {
+    GST_WARNING_OBJECT (src, "invalid chapter %d (only %d available)",
+        chapter, src->num_chapters);
+    chapter = CLAMP (chapter, 0, src->num_chapters - 1);
+  }
+
+  /* determine which program chain we want to watch. This is
+   * based on the chapter number */
+  cur_title_get_chapter_pgc (src, chapter, &src->pgn, &src->pgc_id,
+      &src->cur_pgc);
+  cur_title_get_chapter_bounds (src, chapter, &src->start_cell,
+      &src->last_cell);
+
+  GST_LOG_OBJECT (src, "Opened chapter %d - cell %d-%d", chapter + 1,
+      src->start_cell, src->last_cell);
+
+  /* retrieve position */
+  src->cur_pack = 0;
+  for (i = 0; i < chapter; i++) {
+    gint c1, c2;
+
+    cur_title_get_chapter_bounds (src, i, &c1, &c2);
+
+    while (c1 < c2) {
+      src->cur_pack +=
+          src->cur_pgc->cell_playback[c1].last_sector -
+          src->cur_pgc->cell_playback[c1].first_sector;
+      ++c1;
+    }
+  }
+
+  /* prepare reading for new cell */
+  src->new_cell = TRUE;
+  src->next_cell = src->start_cell;
+
+  src->chapter = chapter;
+
+  if (src->pending_clut_event)
+    gst_event_unref (src->pending_clut_event);
+
+  src->pending_clut_event =
+      gst_dvd_read_src_make_clut_change_event (src, src->cur_pgc->palette);
+
+  return TRUE;
+}
+
+static void
+gst_dvd_read_src_get_chapter_starts (GstDvdReadSrc * src)
+{
+  GstClockTime uptohere;
+  guint c;
+
+  g_free (src->chapter_starts);
+  src->chapter_starts = g_new (GstClockTime, src->num_chapters);
+
+  uptohere = (GstClockTime) 0;
+  for (c = 0; c < src->num_chapters; ++c) {
+    GstClockTime chapter_duration = 0;
+    gint cell_start, cell_end, cell;
+    gint pgn, pgc_id;
+    pgc_t *pgc;
+
+    cur_title_get_chapter_pgc (src, c, &pgn, &pgc_id, &pgc);
+    cur_title_get_chapter_bounds (src, c, &cell_start, &cell_end);
+
+    cell = cell_start;
+    while (cell < cell_end) {
+      dvd_time_t *cell_duration;
+
+      cell_duration = &pgc->cell_playback[cell].playback_time;
+      chapter_duration += gst_dvd_read_src_convert_timecode (cell_duration);
+      cell = gst_dvd_read_src_get_next_cell (src, pgc, cell);
+    }
+
+    src->chapter_starts[c] = uptohere;
+
+    GST_INFO_OBJECT (src, "[%02u] Chapter %02u starts at %" GST_TIME_FORMAT
+        ", dur = %" GST_TIME_FORMAT ", cells %d-%d", src->title + 1, c + 1,
+        GST_TIME_ARGS (uptohere), GST_TIME_ARGS (chapter_duration),
+        cell_start, cell_end);
+
+    uptohere += chapter_duration;
+  }
+}
+
+static gboolean
+gst_dvd_read_src_goto_title (GstDvdReadSrc * src, gint title, gint angle)
+{
+  GstStructure *s;
+  gchar lang_code[3] = { '\0', '\0', '\0' }, *t;
+  gint title_set_nr;
+  gint num_titles;
+  gint i;
+
+  /* make sure our title number is valid */
+  num_titles = src->tt_srpt->nr_of_srpts;
+  GST_INFO_OBJECT (src, "There are %d titles on this DVD", num_titles);
+  if (title < 0 || title >= num_titles)
+    goto invalid_title;
+
+  src->num_chapters = src->tt_srpt->title[title].nr_of_ptts;
+  GST_INFO_OBJECT (src, "Title %d has %d chapters", title + 1,
+      src->num_chapters);
+
+  /* make sure the angle number is valid for this title */
+  src->num_angles = src->tt_srpt->title[title].nr_of_angles;
+  GST_LOG_OBJECT (src, "Title %d has %d angles", title + 1, src->num_angles);
+  if (angle < 0 || angle >= src->num_angles) {
+    GST_WARNING_OBJECT (src, "Invalid angle %d (only %d available)",
+        angle, src->num_angles);
+    angle = CLAMP (angle, 0, src->num_angles - 1);
+  }
+
+  /* load the VTS information for the title set our title is in */
+  title_set_nr = src->tt_srpt->title[title].title_set_nr;
+  src->vts_file = ifoOpen (src->dvd, title_set_nr);
+  if (src->vts_file == NULL)
+    goto ifo_open_failed;
+
+  src->ttn = src->tt_srpt->title[title].vts_ttn;
+  src->vts_ptt_srpt = src->vts_file->vts_ptt_srpt;
+
+  /* interactive title? */
+  if (src->num_chapters > 0 &&
+      src->vts_ptt_srpt->title[src->ttn - 1].ptt[0].pgn == 0) {
+    goto commands_only_pgc;
+  }
+
+  /* we've got enough info, time to open the title set data */
+  src->dvd_title = DVDOpenFile (src->dvd, title_set_nr, DVD_READ_TITLE_VOBS);
+  if (src->dvd_title == NULL)
+    goto title_open_failed;
+
+  GST_INFO_OBJECT (src, "Opened title %d, angle %d", title + 1, angle);
+  src->title = title;
+  src->angle = angle;
+
+  /* build event */
+
+  if (src->title_lang_event_pending) {
+    gst_event_unref (src->title_lang_event_pending);
+    src->title_lang_event_pending = NULL;
+  }
+
+  s = gst_structure_new ("application/x-gst-dvd",
+      "event", G_TYPE_STRING, "dvd-lang-codes", NULL);
+
+  /* audio */
+  for (i = 0; i < src->vts_file->vtsi_mat->nr_of_vts_audio_streams; i++) {
+    const audio_attr_t *a = &src->vts_file->vtsi_mat->vts_audio_attr[i];
+
+    t = g_strdup_printf ("audio-%d-format", i);
+    gst_structure_set (s, t, G_TYPE_INT, (int) a->audio_format, NULL);
+    g_free (t);
+
+    if (a->lang_type) {
+      t = g_strdup_printf ("audio-%d-language", i);
+      lang_code[0] = (a->lang_code >> 8) & 0xff;
+      lang_code[1] = a->lang_code & 0xff;
+      gst_structure_set (s, t, G_TYPE_STRING, lang_code, NULL);
+      g_free (t);
+    } else {
+      lang_code[0] = '\0';
+    }
+
+    GST_INFO_OBJECT (src, "[%02d] Audio    %02d: lang='%s', format=%d",
+        src->title + 1, i, lang_code, (gint) a->audio_format);
+  }
+
+  /* subtitle */
+  for (i = 0; i < src->vts_file->vtsi_mat->nr_of_vts_subp_streams; i++) {
+    const subp_attr_t *u = &src->vts_file->vtsi_mat->vts_subp_attr[i];
+
+    if (u->type) {
+      t = g_strdup_printf ("subtitle-%d-language", i);
+      lang_code[0] = (u->lang_code >> 8) & 0xff;
+      lang_code[1] = u->lang_code & 0xff;
+      gst_structure_set (s, t, G_TYPE_STRING, lang_code, NULL);
+      g_free (t);
+    } else {
+      lang_code[0] = '\0';
+    }
+
+    GST_INFO_OBJECT (src, "[%02d] Subtitle %02d: lang='%s', format=%d",
+        src->title + 1, i, lang_code);
+  }
+
+  src->title_lang_event_pending =
+      gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s);
+
+  /* dump seek tables */
+  src->vts_tmapt = src->vts_file->vts_tmapt;
+  if (src->vts_tmapt) {
+    gint i, j;
+
+    GST_LOG_OBJECT (src, "nr_of_tmaps = %d", src->vts_tmapt->nr_of_tmaps);
+    for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
+      GST_LOG_OBJECT (src, "======= Table %d ===================", i);
+      GST_LOG_OBJECT (src, "Offset relative to VTS_TMAPTI: %d",
+          src->vts_tmapt->tmap_offset[i]);
+      GST_LOG_OBJECT (src, "Time unit (seconds)          : %d",
+          src->vts_tmapt->tmap[i].tmu);
+      GST_LOG_OBJECT (src, "Number of entries            : %d",
+          src->vts_tmapt->tmap[i].nr_of_entries);
+      for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; j++) {
+        guint64 time;
+
+        time = src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
+        GST_LOG_OBJECT (src, "Time: %" GST_TIME_FORMAT " VOBU "
+            "Sector: 0x%08x %s", GST_TIME_ARGS (time),
+            src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff,
+            (src->vts_tmapt->tmap[i].map_ent[j] >> 31) ? "discontinuity" : "");
+      }
+    }
+  } else {
+    GST_WARNING_OBJECT (src, "no vts_tmapt - seeking will suck");
+  }
+
+  gst_dvd_read_src_get_chapter_starts (src);
+
+  return TRUE;
+
+  /* ERRORS */
+invalid_title:
+  {
+    GST_WARNING_OBJECT (src, "Invalid title %d (only %d available)",
+        title, num_titles);
+    return FALSE;
+  }
+ifo_open_failed:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Could not open DVD title %d"), title_set_nr),
+        ("ifoOpen(%d) failed: %s", title_set_nr, g_strerror (errno)));
+    return FALSE;
+  }
+title_open_failed:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Could not open DVD title %d"), title_set_nr),
+        ("Can't open title VOBS (VTS_%02d_1.VOB)", title_set_nr));
+    return FALSE;
+  }
+commands_only_pgc:
+  {
+    GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
+        (_("Could not open DVD title %d. Interactive titles are not supported "
+                "by this element"), title_set_nr),
+        ("Commands-only PGC, not supported, use dvdnavsrc"));
+    return FALSE;
+  }
+}
+
+/* FIXME: double-check this function, compare against original */
+static gint
+gst_dvd_read_src_get_next_cell (GstDvdReadSrc * src, pgc_t * pgc, gint cell)
+{
+  /* Check if we're entering an angle block. */
+  if (pgc->cell_playback[cell].block_type != BLOCK_TYPE_ANGLE_BLOCK)
+    return (cell + 1);
+
+  while (pgc->cell_playback[cell].block_mode == BLOCK_MODE_LAST_CELL)
+    ++cell;
+
+  return cell + 1;              /* really +1? (tpm) */
+}
+
+/* Returns true if the pack is a NAV pack */
+static gboolean
+gst_dvd_read_src_is_nav_pack (const guint8 * data)
+{
+  if (GST_READ_UINT32_BE (data + 0x26) != 0x000001BF)
+    return FALSE;
+
+  /* Check that this is substream 0 (PCI) */
+  if (data[0x2c] != 0)
+    return FALSE;
+
+  if (GST_READ_UINT32_BE (data + 0x400) != 0x000001BF)
+    return FALSE;
+
+  /* Check that this is substream 1 (DSI) */
+  if (data[0x406] != 1)
+    return FALSE;
+
+  /* Check sizes of PCI and DSI packets */
+  if (GST_READ_UINT16_BE (data + 0x2a) != 0x03d4)
+    return FALSE;
+
+  if (GST_READ_UINT16_BE (data + 0x404) != 0x03fa)
+    return FALSE;
+
+  return TRUE;
+}
+
+/* find time for sector from index, returns NONE if there is no exact match */
+static GstClockTime
+gst_dvd_read_src_get_time_for_sector (GstDvdReadSrc * src, guint sector)
+{
+  gint i, j;
+
+  if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0)
+    return GST_CLOCK_TIME_NONE;
+
+  for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
+    for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; ++j) {
+      if ((src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff) == sector)
+        return src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
+    }
+  }
+
+  if (sector == 0)
+    return (GstClockTime) 0;
+
+  return GST_CLOCK_TIME_NONE;
+}
+
+/* returns the sector in the index at (or before) the given time, or -1 */
+static gint
+gst_dvd_read_src_get_sector_from_time (GstDvdReadSrc * src, GstClockTime ts)
+{
+  gint sector, i, j;
+
+  if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0)
+    return -1;
+
+  sector = 0;
+  for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
+    for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; ++j) {
+      GstClockTime entry_time;
+
+      entry_time = src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
+      if (entry_time <= ts) {
+        sector = src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff;
+      }
+      if (entry_time >= ts) {
+        return sector;
+      }
+    }
+  }
+
+  if (ts == 0)
+    return 0;
+
+  return -1;
+}
+
+typedef enum
+{
+  GST_DVD_READ_OK = 0,
+  GST_DVD_READ_ERROR = -1,
+  GST_DVD_READ_EOS = -2,
+  GST_DVD_READ_AGAIN = -3
+} GstDvdReadReturn;
+
+static GstDvdReadReturn
+gst_dvd_read_src_read (GstDvdReadSrc * src, gint angle, gint new_seek,
+    GstBuffer ** p_buf)
+{
+  GstBuffer *buf;
+  guint8 oneblock[DVD_VIDEO_LB_LEN];
+  dsi_t dsi_pack;
+  guint next_vobu, next_ilvu_start, cur_output_size;
+  gint len;
+
+  /* playback by cell in this pgc, starting at the cell for our chapter */
+  if (new_seek)
+    src->cur_cell = src->start_cell;
+
+again:
+
+  if (src->cur_cell >= src->last_cell) {
+    /* advance to next chapter */
+    if (src->chapter == (src->num_chapters - 1))
+      goto eos;
+
+    GST_INFO_OBJECT (src, "end of chapter %d, switch to next",
+        src->chapter + 1);
+
+    ++src->chapter;
+    gst_dvd_read_src_goto_chapter (src, src->chapter);
+
+    return GST_DVD_READ_AGAIN;
+  }
+
+  if (src->new_cell || new_seek) {
+    if (!new_seek) {
+      src->cur_cell = src->next_cell;
+      if (src->cur_cell >= src->last_cell) {
+        GST_LOG_OBJECT (src, "last cell in chapter");
+        goto again;
+      }
+    }
+
+    /* take angle into account */
+    if (src->cur_pgc->cell_playback[src->cur_cell].block_type
+        == BLOCK_TYPE_ANGLE_BLOCK)
+      src->cur_cell += angle;
+
+    /* calculate next cell */
+    src->next_cell =
+        gst_dvd_read_src_get_next_cell (src, src->cur_pgc, src->cur_cell);
+
+    /* we loop until we're out of this cell */
+    src->cur_pack = src->cur_pgc->cell_playback[src->cur_cell].first_sector;
+    src->new_cell = FALSE;
+  }
+
+  if (src->cur_pack >= src->cur_pgc->cell_playback[src->cur_cell].last_sector) {
+    src->new_cell = TRUE;
+    GST_LOG_OBJECT (src, "Beyond last sector, go to next cell");
+    return GST_DVD_READ_AGAIN;
+  }
+
+  /* read NAV packet */
+nav_retry:
+
+  len = DVDReadBlocks (src->dvd_title, src->cur_pack, 1, oneblock);
+  if (len == 0)
+    goto read_error;
+
+  if (!gst_dvd_read_src_is_nav_pack (oneblock)) {
+    src->cur_pack++;
+    goto nav_retry;
+  }
+
+  /* parse the contained dsi packet */
+  navRead_DSI (&dsi_pack, &oneblock[DSI_START_BYTE]);
+  g_assert (src->cur_pack == dsi_pack.dsi_gi.nv_pck_lbn);
+
+  /* determine where we go next. These values are the ones we
+   * mostly care about */
+  next_ilvu_start = src->cur_pack + dsi_pack.sml_agli.data[angle].address;
+  cur_output_size = dsi_pack.dsi_gi.vobu_ea;
+
+  /* If we're not at the end of this cell, we can determine the next
+   * VOBU to display using the VOBU_SRI information section of the
+   * DSI.  Using this value correctly follows the current angle,
+   * avoiding the doubled scenes in The Matrix, and makes our life
+   * really happy.
+   *
+   * Otherwise, we set our next address past the end of this cell to
+   * force the code above to go to the next cell in the program. */
+  if (dsi_pack.vobu_sri.next_vobu != SRI_END_OF_CELL) {
+    next_vobu = src->cur_pack + (dsi_pack.vobu_sri.next_vobu & 0x7fffffff);
+  } else {
+    next_vobu = src->cur_pack + cur_output_size + 1;
+  }
+
+  g_assert (cur_output_size < 1024);
+  ++src->cur_pack;
+
+  /* create the buffer (TODO: use buffer pool?) */
+  buf = gst_buffer_new_and_alloc (cur_output_size * DVD_VIDEO_LB_LEN);
+
+  /* read in and output cursize packs */
+  len = DVDReadBlocks (src->dvd_title, src->cur_pack, cur_output_size,
+      GST_BUFFER_DATA (buf));
+
+  if (len != cur_output_size)
+    goto block_read_error;
+
+  GST_BUFFER_SIZE (buf) = cur_output_size * DVD_VIDEO_LB_LEN;
+  /* GST_BUFFER_OFFSET (buf) = priv->cur_pack * DVD_VIDEO_LB_LEN; */
+  GST_BUFFER_TIMESTAMP (buf) =
+      gst_dvd_read_src_get_time_for_sector (src, src->cur_pack);
+
+  gst_buffer_set_caps (buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (src)));
+
+  *p_buf = buf;
+
+  src->cur_pack = next_vobu;
+
+  GST_LOG_OBJECT (src, "Read %u sectors", cur_output_size);
+
+  return GST_DVD_READ_OK;
+
+  /* ERRORS */
+eos:
+  {
+    GST_INFO_OBJECT (src, "last chapter done - EOS");
+    return GST_DVD_READ_EOS;
+  }
+read_error:
+  {
+    GST_ERROR_OBJECT (src, "Read failed for block %d", src->cur_pack);
+    return GST_DVD_READ_ERROR;
+  }
+block_read_error:
+  {
+    GST_ERROR_OBJECT (src, "Read failed for %d blocks at %d",
+        cur_output_size, src->cur_pack);
+    gst_buffer_unref (buf);
+    return GST_DVD_READ_ERROR;
+  }
+}
+
+static GstFlowReturn
+gst_dvd_read_src_create (GstPushSrc * pushsrc, GstBuffer ** p_buf)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (pushsrc);
+  GstPad *srcpad;
+  gint res;
+
+  g_return_val_if_fail (src->dvd != NULL, GST_FLOW_ERROR);
+
+  srcpad = GST_BASE_SRC (src)->srcpad;
+
+  if (src->need_newsegment) {
+    gst_pad_push_event (srcpad,
+        gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
+            src->cur_pack * DVD_VIDEO_LB_LEN, -1, 0));
+    src->need_newsegment = FALSE;
+  }
+
+  if (src->new_seek) {
+    gst_dvd_read_src_goto_title (src, src->title, src->angle);
+    gst_dvd_read_src_goto_chapter (src, src->chapter);
+
+    src->new_seek = FALSE;
+    src->change_cell = TRUE;
+  }
+
+  if (src->title_lang_event_pending) {
+    gst_pad_push_event (srcpad, src->title_lang_event_pending);
+    src->title_lang_event_pending = NULL;
+  }
+
+  if (src->pending_clut_event) {
+    gst_pad_push_event (srcpad, src->pending_clut_event);
+    src->pending_clut_event = NULL;
+  }
+
+  /* read it in */
+  do {
+    res = gst_dvd_read_src_read (src, src->angle, src->change_cell, p_buf);
+  } while (res == GST_DVD_READ_AGAIN);
+
+  switch (res) {
+    case GST_DVD_READ_ERROR:{
+      GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), (NULL));
+      return GST_FLOW_ERROR;
+    }
+    case GST_DVD_READ_EOS:{
+      GST_INFO_OBJECT (src, "Reached EOS");
+      return GST_FLOW_UNEXPECTED;
+    }
+    case GST_DVD_READ_OK:{
+      src->change_cell = FALSE;
+      return GST_FLOW_OK;
+    }
+    default:
+      break;
+  }
+
+  g_return_val_if_reached (GST_FLOW_UNEXPECTED);
+}
+
+static void
+gst_dvd_read_src_set_property (GObject * object, guint prop_id,
+    const GValue * value, GParamSpec * pspec)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (object);
+  gboolean started;
+
+  GST_OBJECT_LOCK (src);
+  started = GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_STARTED);
+
+  switch (prop_id) {
+    case ARG_DEVICE:{
+      if (started) {
+        g_warning ("%s: property '%s' needs to be set before the device is "
+            "opened", GST_ELEMENT_NAME (src), pspec->name);
+        break;;
+      }
+
+      g_free (src->location);
+      /* clear the filename if we get a NULL (is that possible?) */
+      if (g_value_get_string (value) == NULL) {
+        src->location = g_strdup ("/dev/dvd");
+      } else {
+        src->location = g_strdup (g_value_get_string (value));
+      }
+      break;
+    }
+    case ARG_TITLE:
+      src->uri_title = g_value_get_int (value);
+      if (started) {
+        src->title = src->uri_title - 1;
+        src->new_seek = TRUE;
+      }
+      break;
+    case ARG_CHAPTER:
+      src->uri_chapter = g_value_get_int (value);
+      if (started) {
+        src->chapter = src->uri_chapter - 1;
+        src->new_seek = TRUE;
+      }
+      break;
+    case ARG_ANGLE:
+      src->uri_angle = g_value_get_int (value);
+      if (started) {
+        src->angle = src->uri_angle - 1;
+      }
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+
+  GST_OBJECT_UNLOCK (src);
+}
+
+static void
+gst_dvd_read_src_get_property (GObject * object, guint prop_id, GValue * value,
+    GParamSpec * pspec)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (object);
+
+  GST_OBJECT_LOCK (src);
+
+  switch (prop_id) {
+    case ARG_DEVICE:
+      g_value_set_string (value, src->location);
+      break;
+    case ARG_TITLE:
+      g_value_set_int (value, src->uri_title);
+      break;
+    case ARG_CHAPTER:
+      g_value_set_int (value, src->uri_chapter);
+      break;
+    case ARG_ANGLE:
+      g_value_set_int (value, src->uri_angle);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+
+  GST_OBJECT_UNLOCK (src);
+}
+
+static gboolean
+gst_dvd_read_src_get_size (GstDvdReadSrc * src, gint64 * size)
+{
+  gboolean ret = FALSE;
+
+  if (src->dvd_title) {
+    gsize blocks;
+
+    blocks = DVDFileSize (src->dvd_title);
+    if (blocks >= 0) {
+      *size = (gint64) blocks *DVD_VIDEO_LB_LEN;
+
+      ret = TRUE;
+    } else {
+      GST_WARNING_OBJECT (src, "DVDFileSize(%p) failed!", src->dvd_title);
+    }
+  }
+
+  return ret;
+}
+
+/*** Querying and seeking ***/
+
+static gboolean
+gst_dvd_read_src_handle_seek_event (GstDvdReadSrc * src, GstEvent * event)
+{
+  GstSeekFlags flags;
+  GstSeekType cur_type, end_type;
+  gint64 new_off, total;
+  GstFormat format;
+  GstPad *srcpad;
+  gboolean query_ok;
+  gdouble rate;
+
+  gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &new_off,
+      &end_type, NULL);
+
+  if (rate <= 0.0) {
+    GST_DEBUG_OBJECT (src, "cannot do backwards playback yet");
+    return FALSE;
+  }
+
+  if ((flags & GST_SEEK_FLAG_SEGMENT) != 0) {
+    GST_DEBUG_OBJECT (src, "segment seek not supported");
+    return FALSE;
+  }
+
+  if ((flags & GST_SEEK_FLAG_FLUSH) == 0) {
+    GST_DEBUG_OBJECT (src, "can only do flushing seeks at the moment");
+    return FALSE;
+  }
+
+  if (end_type != GST_SEEK_TYPE_NONE) {
+    GST_DEBUG_OBJECT (src, "end seek type not supported");
+    return FALSE;
+  }
+
+  if (cur_type != GST_SEEK_TYPE_SET) {
+    GST_DEBUG_OBJECT (src, "only SEEK_TYPE_SET is supported");
+    return FALSE;
+  }
+
+  if (format == angle_format) {
+    GST_OBJECT_LOCK (src);
+    if (new_off < 0 || new_off >= src->num_angles) {
+      GST_OBJECT_UNLOCK (src);
+      GST_DEBUG_OBJECT (src, "invalid angle %d, only %d available",
+          src->num_angles);
+      return FALSE;
+    }
+    src->angle = (gint) new_off;
+    GST_OBJECT_UNLOCK (src);
+    GST_DEBUG_OBJECT (src, "switched to angle %d", (gint) new_off + 1);
+    return TRUE;
+  }
+
+  if (format != chapter_format && format != title_format &&
+      format != GST_FORMAT_BYTES && format != GST_FORMAT_TIME) {
+    GST_DEBUG_OBJECT (src, "unsupported seek format %d (%s)", format,
+        gst_format_get_name (format));
+    return FALSE;
+  }
+
+  if (format == GST_FORMAT_BYTES) {
+    GST_DEBUG_OBJECT (src, "Requested seek to byte %" G_GUINT64_FORMAT,
+        new_off);
+  } else if (format == GST_FORMAT_TIME) {
+    GST_DEBUG_OBJECT (src, "Requested seek to time %" GST_TIME_FORMAT,
+        GST_TIME_ARGS (new_off));
+    if (gst_dvd_read_src_get_sector_from_time (src, new_off) < 0) {
+      GST_DEBUG_OBJECT (src, "Can't find sector for requested time");
+      return FALSE;
+    }
+  }
+
+  srcpad = GST_BASE_SRC_PAD (src);
+
+  /* check whether the seek looks reasonable (ie within possible range) */
+  if (format == GST_FORMAT_BYTES) {
+    GST_OBJECT_LOCK (src);
+    query_ok = gst_dvd_read_src_get_size (src, &total);
+    GST_OBJECT_UNLOCK (src);
+  } else {
+    query_ok = gst_pad_query_duration (srcpad, &format, &total);
+  }
+
+  if (!query_ok) {
+    GST_DEBUG_OBJECT (src, "Failed to query duration in format %s",
+        gst_format_get_name (format));
+    return FALSE;
+  }
+
+  GST_DEBUG_OBJECT (src, "Total      %s: %12" G_GINT64_FORMAT,
+      gst_format_get_name (format), total);
+  GST_DEBUG_OBJECT (src, "Seek to    %s: %12" G_GINT64_FORMAT,
+      gst_format_get_name (format), new_off);
+
+  if (new_off >= total) {
+    GST_DEBUG_OBJECT (src, "Seek position out of range");
+    return FALSE;
+  }
+
+  /* set segment to seek format; this allows us to use the do_seek
+   * virtual function and let the base source handle all the tricky
+   * stuff for us. We don't use the segment internally anyway */
+  /* FIXME: can't take the stream lock here - what to do? */
+  GST_OBJECT_LOCK (src);
+  GST_BASE_SRC (src)->segment.format = format;
+  GST_BASE_SRC (src)->segment.start = 0;
+  GST_BASE_SRC (src)->segment.stop = total;
+  GST_BASE_SRC (src)->segment.duration = total;
+  GST_OBJECT_UNLOCK (src);
+
+  return GST_BASE_SRC_CLASS (parent_class)->event (GST_BASE_SRC (src), event);
+}
+
+static gboolean
+gst_dvd_read_src_do_seek (GstBaseSrc * basesrc, GstSegment * s)
+{
+  GstDvdReadSrc *src;
+
+  src = GST_DVD_READ_SRC (basesrc);
+
+  GST_DEBUG_OBJECT (src, "Seeking to %s: %12" G_GINT64_FORMAT,
+      gst_format_get_name (s->format), s->last_stop);
+
+  if (s->format == sector_format || s->format == GST_FORMAT_BYTES
+      || s->format == GST_FORMAT_TIME) {
+    guint old;
+
+    old = src->cur_pack;
+
+    if (s->format == sector_format) {
+      src->cur_pack = s->last_stop;
+    } else if (s->format == GST_FORMAT_TIME) {
+      gint sector;
+
+      sector = gst_dvd_read_src_get_sector_from_time (src, s->last_stop);
+
+      GST_DEBUG_OBJECT (src, "Time %" GST_TIME_FORMAT " => sector %d",
+          GST_TIME_ARGS (s->last_stop), sector);
+
+      /* really shouldn't happen, we've checked this earlier ... */
+      g_return_val_if_fail (sector >= 0, FALSE);
+
+      src->cur_pack = sector;
+    } else {
+      /* byte format */
+      src->cur_pack = s->last_stop / DVD_VIDEO_LB_LEN;
+      if ((src->cur_pack * DVD_VIDEO_LB_LEN) != s->last_stop) {
+        GST_LOG_OBJECT (src, "rounded down offset %" G_GINT64_FORMAT " => %"
+            G_GINT64_FORMAT, s->last_stop,
+            (gint64) src->cur_pack * DVD_VIDEO_LB_LEN);
+      }
+    }
+
+    if (!gst_dvd_read_src_goto_sector (src, src->angle)) {
+      GST_DEBUG_OBJECT (src, "seek to sector 0x%08x failed", src->cur_pack);
+      src->cur_pack = old;
+      return FALSE;
+    }
+
+    GST_LOG_OBJECT (src, "seek to sector 0x%08x ok", src->cur_pack);
+  } else if (s->format == chapter_format) {
+    if (!gst_dvd_read_src_goto_chapter (src, (gint) s->last_stop)) {
+      GST_DEBUG_OBJECT (src, "seek to chapter %d failed",
+          (gint) s->last_stop + 1);
+      return FALSE;
+    }
+    GST_INFO_OBJECT (src, "seek to chapter %d ok", (gint) s->last_stop + 1);
+    src->chapter = s->last_stop;
+  } else if (s->format == title_format) {
+    if (!gst_dvd_read_src_goto_title (src, (gint) s->last_stop, src->angle) ||
+        !gst_dvd_read_src_goto_chapter (src, 0)) {
+      GST_DEBUG_OBJECT (src, "seek to title %d failed", (gint) s->last_stop);
+      return FALSE;
+    }
+    src->title = (gint) s->last_stop;
+    src->chapter = 0;
+    GST_INFO_OBJECT (src, "seek to title %d ok", src->title + 1);
+  } else {
+    g_return_val_if_reached (FALSE);
+  }
+
+  src->need_newsegment = TRUE;
+  return TRUE;
+}
+
+static gboolean
+gst_dvd_read_src_src_event (GstBaseSrc * basesrc, GstEvent * event)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
+  gboolean res;
+
+  GST_LOG_OBJECT (src, "handling %s event", GST_EVENT_TYPE_NAME (event));
+
+  switch (GST_EVENT_TYPE (event)) {
+    case GST_EVENT_SEEK:
+      res = gst_dvd_read_src_handle_seek_event (src, event);
+      break;
+    default:
+      res = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);
+      break;
+  }
+
+  return res;
+}
+
+static GstEvent *
+gst_dvd_read_src_make_clut_change_event (GstDvdReadSrc * src,
+    const guint * clut)
+{
+  GstStructure *structure;
+  gchar name[16];
+  gint i;
+
+  structure = gst_structure_new ("application/x-gst-dvd",
+      "event", G_TYPE_STRING, "dvd-spu-clut-change", NULL);
+
+  /* Create a separate field for each value in the table. */
+  for (i = 0; i < 16; i++) {
+    g_snprintf (name, sizeof (name), "clut%02d", i);
+    gst_structure_set (structure, name, G_TYPE_INT, (int) clut[i], NULL);
+  }
+
+  /* Create the DVD event and put the structure into it. */
+  return gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, structure);
+}
+
+static gint64
+gst_dvd_read_src_convert_timecode (dvd_time_t * time)
+{
+  gint64 ret_time;
+  const gint64 one_hour = 3600 * GST_SECOND;
+  const gint64 one_min = 60 * GST_SECOND;
+
+  g_return_val_if_fail ((time->hour >> 4) < 0xa
+      && (time->hour & 0xf) < 0xa, -1);
+  g_return_val_if_fail ((time->minute >> 4) < 0x7
+      && (time->minute & 0xf) < 0xa, -1);
+  g_return_val_if_fail ((time->second >> 4) < 0x7
+      && (time->second & 0xf) < 0xa, -1);
+
+  ret_time = ((time->hour >> 4) * 10 + (time->hour & 0xf)) * one_hour;
+  ret_time += ((time->minute >> 4) * 10 + (time->minute & 0xf)) * one_min;
+  ret_time += ((time->second >> 4) * 10 + (time->second & 0xf)) * GST_SECOND;
+
+  return ret_time;
+}
+
+static gboolean
+gst_dvd_read_src_do_duration_query (GstDvdReadSrc * src, GstQuery * query)
+{
+  GstFormat format;
+  gint64 val;
+
+  gst_query_parse_duration (query, &format, NULL);
+
+  switch (format) {
+    case GST_FORMAT_TIME:{
+      if (src->cur_pgc == NULL)
+        return FALSE;
+      val = gst_dvd_read_src_convert_timecode (&src->cur_pgc->playback_time);
+      if (val < 0)
+        return FALSE;
+      break;
+    }
+    case GST_FORMAT_BYTES:{
+      if (!gst_dvd_read_src_get_size (src, &val))
+        return FALSE;
+      break;
+    }
+    default:{
+      if (format == sector_format) {
+        val = DVDFileSize (src->dvd_title);
+      } else if (format == title_format) {
+        val = src->tt_srpt->nr_of_srpts;
+      } else if (format == chapter_format) {
+        val = src->num_chapters;
+      } else if (format == angle_format) {
+        val = src->tt_srpt->title[src->title].nr_of_angles;
+      } else {
+        GST_DEBUG_OBJECT (src, "Don't know how to handle format %d (%s)",
+            format, gst_format_get_name (format));
+        return FALSE;
+      }
+      break;
+    }
+  }
+
+  GST_LOG_OBJECT (src, "duration = %" G_GINT64_FORMAT " %s", val,
+      gst_format_get_name (format));
+
+  gst_query_set_duration (query, format, val);
+  return TRUE;
+}
+
+static gboolean
+gst_dvd_read_src_do_position_query (GstDvdReadSrc * src, GstQuery * query)
+{
+  GstFormat format;
+  gint64 val;
+
+  gst_query_parse_position (query, &format, NULL);
+
+  switch (format) {
+    case GST_FORMAT_BYTES:{
+      val = src->cur_pack * DVD_VIDEO_LB_LEN;
+      break;
+    }
+    default:{
+      if (format == sector_format) {
+        val = src->cur_pack;
+      } else if (format == title_format) {
+        val = src->title;
+      } else if (format == chapter_format) {
+        val = src->chapter;
+      } else if (format == angle_format) {
+        val = src->angle;
+      } else {
+        GST_DEBUG_OBJECT (src, "Don't know how to handle format %d (%s)",
+            format, gst_format_get_name (format));
+        return FALSE;
+      }
+      break;
+    }
+  }
+
+  GST_LOG_OBJECT (src, "position = %" G_GINT64_FORMAT " %s", val,
+      gst_format_get_name (format));
+
+  gst_query_set_position (query, format, val);
+  return TRUE;
+}
+
+static gboolean
+gst_dvd_read_src_src_query (GstBaseSrc * basesrc, GstQuery * query)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
+  gboolean started;
+  gboolean res = TRUE;
+
+  GST_LOG_OBJECT (src, "handling %s query",
+      gst_query_type_get_name (GST_QUERY_TYPE (query)));
+
+  GST_OBJECT_LOCK (src);
+  started = (GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_STARTED));
+  GST_OBJECT_UNLOCK (src);
+
+  if (!started) {
+    GST_DEBUG_OBJECT (src, "query failed: not started");
+    return FALSE;
+  }
+
+  switch (GST_QUERY_TYPE (query)) {
+    case GST_QUERY_DURATION:
+      GST_OBJECT_LOCK (src);
+      res = gst_dvd_read_src_do_duration_query (src, query);
+      GST_OBJECT_UNLOCK (src);
+      break;
+    case GST_QUERY_POSITION:
+      GST_OBJECT_LOCK (src);
+      res = gst_dvd_read_src_do_position_query (src, query);
+      GST_OBJECT_UNLOCK (src);
+      break;
+    default:
+      res = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query);
+      break;
+  }
+
+  return res;
+}
+
+static gboolean
+gst_dvd_read_src_goto_sector (GstDvdReadSrc * src, int angle)
+{
+  gint seek_to = src->cur_pack;
+  gint chapter, sectors, next, cur, i;
+
+  /* retrieve position */
+  src->cur_pack = 0;
+  for (i = 0; i < src->num_chapters; i++) {
+    gint c1, c2;
+
+    cur_title_get_chapter_bounds (src, i, &c1, &c2);
+
+    for (next = cur = c1; cur < c2;) {
+      if (next != cur) {
+        sectors =
+            src->cur_pgc->cell_playback[cur].last_sector -
+            src->cur_pgc->cell_playback[cur].first_sector;
+        if (src->cur_pack + sectors > seek_to) {
+          chapter = i;
+          goto done;
+        }
+        src->cur_pack += sectors;
+      }
+      cur = next;
+      if (src->cur_pgc->cell_playback[cur].block_type == BLOCK_TYPE_ANGLE_BLOCK)
+        cur += angle;
+      next = gst_dvd_read_src_get_next_cell (src, src->cur_pgc, cur);
+    }
+  }
+
+  GST_DEBUG_OBJECT (src, "Seek to sector %u failed", seek_to);
+
+  return FALSE;
+
+done:
+  {
+    /* so chapter $chapter and cell $cur contain our sector
+     * of interest. Let's go there! */
+    GST_INFO_OBJECT (src, "Seek succeeded, going to chapter %u, cell %u",
+        chapter + 1, cur);
+
+    gst_dvd_read_src_goto_chapter (src, chapter);
+    src->cur_cell = cur;
+    src->next_cell = next;
+    src->new_cell = FALSE;
+    src->cur_pack = seek_to;
+
+    return TRUE;
+  }
+}
+
+
+/*** URI interface ***/
+
+static GstURIType
+gst_dvd_read_src_uri_get_type (void)
+{
+  return GST_URI_SRC;
+}
+
+static gchar **
+gst_dvd_read_src_uri_get_protocols (void)
+{
+  static gchar *protocols[] = { "dvd", NULL };
+
+  return protocols;
+}
+
+static const gchar *
+gst_dvd_read_src_uri_get_uri (GstURIHandler * handler)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (handler);
+
+  GST_OBJECT_LOCK (src);
+
+  g_free (src->last_uri);
+  src->last_uri = g_strdup_printf ("dvd://%d,%d,%d", src->uri_title,
+      src->uri_chapter, src->uri_angle);
+
+  GST_OBJECT_UNLOCK (src);
+
+  return src->last_uri;
+}
+
+static gboolean
+gst_dvd_read_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
+{
+  GstDvdReadSrc *src = GST_DVD_READ_SRC (handler);
+  gboolean ret;
+  gchar *protocol;
+
+  protocol = gst_uri_get_protocol (uri);
+  ret = (protocol != NULL && g_str_equal (protocol, "dvd"));
+  g_free (protocol);
+  protocol = NULL;
+
+  if (!ret)
+    return ret;
+
+  /* parse out the new t/c/a and seek to them */
+  {
+    gchar *location = NULL;
+    gchar **strs;
+    gchar **strcur;
+    gint pos = 0;
+
+    location = gst_uri_get_location (uri);
+
+    if (!location)
+      return ret;
+
+    GST_OBJECT_LOCK (src);
+
+    src->uri_title = 1;
+    src->uri_chapter = 1;
+    src->uri_angle = 1;
+
+    strcur = strs = g_strsplit (location, ",", 0);
+    while (strcur && *strcur) {
+      gint val;
+
+      if (!sscanf (*strcur, "%d", &val))
+        break;
+
+      if (val <= 0) {
+        g_warning ("Invalid value %d in URI '%s'. Must be 1 or greater",
+            val, location);
+        break;
+      }
+
+      switch (pos) {
+        case 0:
+          src->uri_title = val;
+          break;
+        case 1:
+          src->uri_chapter = val;
+          break;
+        case 2:
+          src->uri_angle = val;
+          break;
+      }
+
+      strcur++;
+      pos++;
+    }
+
+    if (pos > 0 && GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_STARTED)) {
+      src->title = src->uri_title - 1;
+      src->chapter = src->uri_chapter - 1;
+      src->angle = src->uri_angle - 1;
+      src->new_seek = TRUE;
+    }
+
+    GST_OBJECT_UNLOCK (src);
+
+    g_strfreev (strs);
+    g_free (location);
+  }
+
+  return ret;
+}
+
+static void
+gst_dvd_read_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
+{
+  GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
+
+  iface->get_type = gst_dvd_read_src_uri_get_type;
+  iface->get_protocols = gst_dvd_read_src_uri_get_protocols;
+  iface->get_uri = gst_dvd_read_src_uri_get_uri;
+  iface->set_uri = gst_dvd_read_src_uri_set_uri;
+}
+
+static void
+gst_dvd_read_src_do_init (GType dvdreadsrc_type)
+{
+  static const GInterfaceInfo urihandler_info = {
+    gst_dvd_read_src_uri_handler_init,
+    NULL,
+    NULL
+  };
+
+  g_type_add_interface_static (dvdreadsrc_type, GST_TYPE_URI_HANDLER,
+      &urihandler_info);
+
+  title_format = gst_format_register ("title", "DVD title");
+  angle_format = gst_format_register ("angle", "DVD angle");
+  sector_format = gst_format_register ("sector", "DVD sector");
+  chapter_format = gst_format_register ("chapter", "DVD chapter");
+}
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  GST_DEBUG_CATEGORY_INIT (gstgst_dvd_read_src_debug, "dvdreadsrc", 0,
+      "DVD reader element based on dvdreadsrc");
+
+#ifdef ENABLE_NLS
+  GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
+      LOCALEDIR);
+  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+#endif /* ENABLE_NLS */
+
+  if (!gst_element_register (plugin, "dvdreadsrc", GST_RANK_SECONDARY,
+          GST_TYPE_DVD_READ_SRC)) {
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "dvdread",
+    "Access a DVD with dvdread",
+    plugin_init, VERSION, "GPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
diff -Nur gst-plugins-ugly0.10-0.10.4/ext/dvdread/dvdreadsrc.h gst-plugins-ugly0.10-0.10.4.new/ext/dvdread/dvdreadsrc.h
--- gst-plugins-ugly0.10-0.10.4/ext/dvdread/dvdreadsrc.h	2006-08-08 04:43:51.000000000 -0600
+++ gst-plugins-ugly0.10-0.10.4.new/ext/dvdread/dvdreadsrc.h	2006-12-03 10:10:44.000000000 -0700
@@ -73,7 +73,7 @@
   tt_srpt_t       *tt_srpt;
   ifo_handle_t    *vts_file;
   vts_ptt_srpt_t  *vts_ptt_srpt;
-  vts_tmapt_t     *vts_tmapt;
+  vts_tmap_t      *tmap;
   dvd_file_t      *dvd_title;
   gint             num_chapters;
   gint             num_angles;