dvdreadsrc: fix sector search for packed titles
[glsdk/gst-plugins-ugly0-10.git] / ext / dvdread / dvdreadsrc.c
1 /* GStreamer DVD title source
2  * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>
3  * Copyright (C) 2001 Billy Biggs <vektor@dumbterm.net>.
4  * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
26 #include "_stdint.h"
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <unistd.h>
31 #include <string.h>
32 #include <errno.h>
34 #include "dvdreadsrc.h"
36 #include <gst/gst-i18n-plugin.h>
38 GST_DEBUG_CATEGORY_STATIC (gstgst_dvd_read_src_debug);
39 #define GST_CAT_DEFAULT (gstgst_dvd_read_src_debug)
41 static void gst_dvd_read_src_do_init (GType dvdreadsrc_type);
43 enum
44 {
45   ARG_0,
46   ARG_DEVICE,
47   ARG_TITLE,
48   ARG_CHAPTER,
49   ARG_ANGLE
50 };
52 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
53     GST_PAD_SRC,
54     GST_PAD_ALWAYS,
55     GST_STATIC_CAPS ("video/mpeg, mpegversion=2, systemstream=(boolean)true"));
57 static GstFormat title_format;
58 static GstFormat angle_format;
59 static GstFormat sector_format;
60 static GstFormat chapter_format;
62 static gboolean gst_dvd_read_src_start (GstBaseSrc * basesrc);
63 static gboolean gst_dvd_read_src_stop (GstBaseSrc * basesrc);
64 static GstFlowReturn gst_dvd_read_src_create (GstPushSrc * pushsrc,
65     GstBuffer ** buf);
66 static gboolean gst_dvd_read_src_src_query (GstBaseSrc * basesrc,
67     GstQuery * query);
68 static gboolean gst_dvd_read_src_src_event (GstBaseSrc * basesrc,
69     GstEvent * event);
70 static gboolean gst_dvd_read_src_goto_title (GstDvdReadSrc * src, gint title,
71     gint angle);
72 static gboolean gst_dvd_read_src_goto_chapter (GstDvdReadSrc * src,
73     gint chapter);
74 static gboolean gst_dvd_read_src_goto_sector (GstDvdReadSrc * src, gint angle);
75 static void gst_dvd_read_src_set_property (GObject * object, guint prop_id,
76     const GValue * value, GParamSpec * pspec);
77 static void gst_dvd_read_src_get_property (GObject * object, guint prop_id,
78     GValue * value, GParamSpec * pspec);
79 static GstEvent *gst_dvd_read_src_make_clut_change_event (GstDvdReadSrc * src,
80     const guint * clut);
81 static gboolean gst_dvd_read_src_get_size (GstDvdReadSrc * src, gint64 * size);
82 static gboolean gst_dvd_read_src_do_seek (GstBaseSrc * src, GstSegment * s);
83 static gint64 gst_dvd_read_src_convert_timecode (dvd_time_t * time);
84 static gint gst_dvd_read_src_get_next_cell (GstDvdReadSrc * src,
85     pgc_t * pgc, gint cell);
86 static GstClockTime gst_dvd_read_src_get_time_for_sector (GstDvdReadSrc * src,
87     guint sector);
88 static gint gst_dvd_read_src_get_sector_from_time (GstDvdReadSrc * src,
89     GstClockTime ts);
91 GST_BOILERPLATE_FULL (GstDvdReadSrc, gst_dvd_read_src, GstPushSrc,
92     GST_TYPE_PUSH_SRC, gst_dvd_read_src_do_init);
94 static void
95 gst_dvd_read_src_base_init (gpointer g_class)
96 {
97   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
99   gst_element_class_add_pad_template (element_class,
100       gst_static_pad_template_get (&srctemplate));
102   gst_element_class_set_details_simple (element_class, "DVD Source",
103       "Source/File/DVD",
104       "Access a DVD title/chapter/angle using libdvdread",
105       "Erik Walthinsen <omega@cse.ogi.edu>");
108 static void
109 gst_dvd_read_src_finalize (GObject * object)
111   GstDvdReadSrc *src = GST_DVD_READ_SRC (object);
113   g_free (src->location);
114   g_free (src->last_uri);
116   G_OBJECT_CLASS (parent_class)->finalize (object);
119 static void
120 gst_dvd_read_src_init (GstDvdReadSrc * src, GstDvdReadSrcClass * klass)
122   src->dvd = NULL;
123   src->vts_file = NULL;
124   src->vmg_file = NULL;
125   src->dvd_title = NULL;
127   src->location = g_strdup ("/dev/dvd");
128   src->last_uri = NULL;
129   src->new_seek = TRUE;
130   src->new_cell = TRUE;
131   src->change_cell = FALSE;
132   src->uri_title = 1;
133   src->uri_chapter = 1;
134   src->uri_angle = 1;
136   src->title_lang_event_pending = NULL;
137   src->pending_clut_event = NULL;
139   gst_pad_use_fixed_caps (GST_BASE_SRC_PAD (src));
140   gst_pad_set_caps (GST_BASE_SRC_PAD (src),
141       gst_static_pad_template_get_caps (&srctemplate));
144 static gboolean
145 gst_dvd_read_src_is_seekable (GstBaseSrc * src)
147   return TRUE;
150 static void
151 gst_dvd_read_src_class_init (GstDvdReadSrcClass * klass)
153   GstPushSrcClass *gstpushsrc_class = GST_PUSH_SRC_CLASS (klass);
154   GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
155   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
157   gobject_class->finalize = gst_dvd_read_src_finalize;
158   gobject_class->set_property = gst_dvd_read_src_set_property;
159   gobject_class->get_property = gst_dvd_read_src_get_property;
161   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,
162       g_param_spec_string ("device", "Device",
163           "DVD device location", NULL,
164           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
165   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TITLE,
166       g_param_spec_int ("title", "title", "title",
167           1, 999, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
168   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CHAPTER,
169       g_param_spec_int ("chapter", "chapter", "chapter",
170           1, 999, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
171   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ANGLE,
172       g_param_spec_int ("angle", "angle", "angle",
173           1, 999, 1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
175   gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_dvd_read_src_start);
176   gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_dvd_read_src_stop);
177   gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_dvd_read_src_src_query);
178   gstbasesrc_class->event = GST_DEBUG_FUNCPTR (gst_dvd_read_src_src_event);
179   gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_dvd_read_src_do_seek);
180   gstbasesrc_class->is_seekable =
181       GST_DEBUG_FUNCPTR (gst_dvd_read_src_is_seekable);
183   gstpushsrc_class->create = GST_DEBUG_FUNCPTR (gst_dvd_read_src_create);
186 static gboolean
187 gst_dvd_read_src_start (GstBaseSrc * basesrc)
189   GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
191   g_return_val_if_fail (src->location != NULL, FALSE);
193   GST_DEBUG_OBJECT (src, "Opening DVD '%s'", src->location);
195   if ((src->dvd = DVDOpen (src->location)) == NULL)
196     goto open_failed;
198   /* Load the video manager to find out the information about the titles */
199   GST_DEBUG_OBJECT (src, "Loading VMG info");
201   if (!(src->vmg_file = ifoOpen (src->dvd, 0)))
202     goto ifo_open_failed;
204   src->tt_srpt = src->vmg_file->tt_srpt;
206   src->title = src->uri_title - 1;
207   src->chapter = src->uri_chapter - 1;
208   src->angle = src->uri_angle - 1;
210   if (!gst_dvd_read_src_goto_title (src, src->title, src->angle))
211     goto title_open_failed;
213   if (!gst_dvd_read_src_goto_chapter (src, src->chapter))
214     goto chapter_open_failed;
216   src->new_seek = FALSE;
217   src->change_cell = TRUE;
219   return TRUE;
221   /* ERRORS */
222 open_failed:
223   {
224     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
225         (_("Could not open DVD")),
226         ("DVDOpen(%s) failed: %s", src->location, g_strerror (errno)));
227     return FALSE;
228   }
229 ifo_open_failed:
230   {
231     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
232         (_("Could not open DVD")),
233         ("ifoOpen() failed: %s", g_strerror (errno)));
234     return FALSE;
235   }
236 title_open_failed:
237   {
238     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
239         (_("Could not open DVD title %d"), src->uri_title), (NULL));
240     return FALSE;
241   }
242 chapter_open_failed:
243   {
244     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
245         (_("Failed to go to chapter %d of DVD title %d"),
246             src->uri_chapter, src->uri_title), (NULL));
247     return FALSE;
248   }
251 static gboolean
252 gst_dvd_read_src_stop (GstBaseSrc * basesrc)
254   GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
256   if (src->vts_file) {
257     ifoClose (src->vts_file);
258     src->vts_file = NULL;
259   }
260   if (src->vmg_file) {
261     ifoClose (src->vmg_file);
262     src->vmg_file = NULL;
263   }
264   if (src->dvd_title) {
265     DVDCloseFile (src->dvd_title);
266     src->dvd_title = NULL;
267   }
268   if (src->dvd) {
269     DVDClose (src->dvd);
270     src->dvd = NULL;
271   }
272   src->new_cell = TRUE;
273   src->new_seek = TRUE;
274   src->change_cell = FALSE;
275   src->chapter = 0;
276   src->title = 0;
277   src->need_newsegment = TRUE;
278   src->vts_tmapt = NULL;
279   if (src->title_lang_event_pending) {
280     gst_event_unref (src->title_lang_event_pending);
281     src->title_lang_event_pending = NULL;
282   }
283   if (src->pending_clut_event) {
284     gst_event_unref (src->pending_clut_event);
285     src->pending_clut_event = NULL;
286   }
287   if (src->chapter_starts) {
288     g_free (src->chapter_starts);
289     src->chapter_starts = NULL;
290   }
292   GST_LOG_OBJECT (src, "closed DVD");
294   return TRUE;
297 static void
298 cur_title_get_chapter_pgc (GstDvdReadSrc * src, gint chapter, gint * p_pgn,
299     gint * p_pgc_id, pgc_t ** p_pgc)
301   pgc_t *pgc;
302   gint pgn, pgc_id;
304   g_assert (chapter >= 0 && chapter < src->num_chapters);
306   pgc_id = src->vts_ptt_srpt->title[src->ttn - 1].ptt[chapter].pgcn;
307   pgn = src->vts_ptt_srpt->title[src->ttn - 1].ptt[chapter].pgn;
308   pgc = src->vts_file->vts_pgcit->pgci_srp[pgc_id - 1].pgc;
310   *p_pgn = pgn;
311   *p_pgc_id = pgc_id;
312   *p_pgc = pgc;
315 static void
316 cur_title_get_chapter_bounds (GstDvdReadSrc * src, gint chapter,
317     gint * p_first_cell, gint * p_last_cell)
319   pgc_t *pgc;
320   gint pgn, pgc_id, pgn_next_ch;
322   g_assert (chapter >= 0 && chapter < src->num_chapters);
324   cur_title_get_chapter_pgc (src, chapter, &pgn, &pgc_id, &pgc);
326   *p_first_cell = pgc->program_map[pgn - 1] - 1;
328   if (chapter == (src->num_chapters - 1)) {
329     *p_last_cell = pgc->nr_of_cells;
330   } else {
331     pgn_next_ch = src->vts_ptt_srpt->title[src->ttn - 1].ptt[chapter + 1].pgn;
332     *p_last_cell = pgc->program_map[pgn_next_ch - 1] - 1;
333   }
336 static gboolean
337 gst_dvd_read_src_goto_chapter (GstDvdReadSrc * src, gint chapter)
339   gint i;
341   /* make sure the chapter number is valid for this title */
342   if (chapter < 0 || chapter >= src->num_chapters) {
343     GST_WARNING_OBJECT (src, "invalid chapter %d (only %d available)",
344         chapter, src->num_chapters);
345     chapter = CLAMP (chapter, 0, src->num_chapters - 1);
346   }
348   /* determine which program chain we want to watch. This is
349    * based on the chapter number */
350   cur_title_get_chapter_pgc (src, chapter, &src->pgn, &src->pgc_id,
351       &src->cur_pgc);
352   cur_title_get_chapter_bounds (src, chapter, &src->start_cell,
353       &src->last_cell);
355   GST_LOG_OBJECT (src, "Opened chapter %d - cell %d-%d", chapter + 1,
356       src->start_cell, src->last_cell);
358   /* retrieve position */
359   src->cur_pack = 0;
360   for (i = 0; i < chapter; i++) {
361     gint c1, c2;
363     cur_title_get_chapter_bounds (src, i, &c1, &c2);
365     while (c1 < c2) {
366       src->cur_pack +=
367           src->cur_pgc->cell_playback[c1].last_sector -
368           src->cur_pgc->cell_playback[c1].first_sector;
369       ++c1;
370     }
371   }
373   /* prepare reading for new cell */
374   src->new_cell = TRUE;
375   src->next_cell = src->start_cell;
377   src->chapter = chapter;
379   if (src->pending_clut_event)
380     gst_event_unref (src->pending_clut_event);
382   src->pending_clut_event =
383       gst_dvd_read_src_make_clut_change_event (src, src->cur_pgc->palette);
385   return TRUE;
388 static void
389 gst_dvd_read_src_get_chapter_starts (GstDvdReadSrc * src)
391   GstClockTime uptohere;
392   guint c;
394   g_free (src->chapter_starts);
395   src->chapter_starts = g_new (GstClockTime, src->num_chapters);
397   uptohere = (GstClockTime) 0;
398   for (c = 0; c < src->num_chapters; ++c) {
399     GstClockTime chapter_duration = 0;
400     gint cell_start, cell_end, cell;
401     gint pgn, pgc_id;
402     pgc_t *pgc;
404     cur_title_get_chapter_pgc (src, c, &pgn, &pgc_id, &pgc);
405     cur_title_get_chapter_bounds (src, c, &cell_start, &cell_end);
407     cell = cell_start;
408     while (cell < cell_end) {
409       dvd_time_t *cell_duration;
411       cell_duration = &pgc->cell_playback[cell].playback_time;
412       chapter_duration += gst_dvd_read_src_convert_timecode (cell_duration);
413       cell = gst_dvd_read_src_get_next_cell (src, pgc, cell);
414     }
416     src->chapter_starts[c] = uptohere;
418     GST_INFO_OBJECT (src, "[%02u] Chapter %02u starts at %" GST_TIME_FORMAT
419         ", dur = %" GST_TIME_FORMAT ", cells %d-%d", src->title + 1, c + 1,
420         GST_TIME_ARGS (uptohere), GST_TIME_ARGS (chapter_duration),
421         cell_start, cell_end);
423     uptohere += chapter_duration;
424   }
427 static gboolean
428 gst_dvd_read_src_goto_title (GstDvdReadSrc * src, gint title, gint angle)
430   GstStructure *s;
431   gchar lang_code[3] = { '\0', '\0', '\0' }, *t;
432   pgc_t *pgc0;
433   gint title_set_nr;
434   gint num_titles;
435   gint pgn0, pgc0_id;
436   gint i;
438   /* make sure our title number is valid */
439   num_titles = src->tt_srpt->nr_of_srpts;
440   GST_INFO_OBJECT (src, "There are %d titles on this DVD", num_titles);
441   if (title < 0 || title >= num_titles)
442     goto invalid_title;
444   src->num_chapters = src->tt_srpt->title[title].nr_of_ptts;
445   GST_INFO_OBJECT (src, "Title %d has %d chapters", title + 1,
446       src->num_chapters);
448   /* make sure the angle number is valid for this title */
449   src->num_angles = src->tt_srpt->title[title].nr_of_angles;
450   GST_LOG_OBJECT (src, "Title %d has %d angles", title + 1, src->num_angles);
451   if (angle < 0 || angle >= src->num_angles) {
452     GST_WARNING_OBJECT (src, "Invalid angle %d (only %d available)",
453         angle, src->num_angles);
454     angle = CLAMP (angle, 0, src->num_angles - 1);
455   }
457   /* load the VTS information for the title set our title is in */
458   title_set_nr = src->tt_srpt->title[title].title_set_nr;
459   src->vts_file = ifoOpen (src->dvd, title_set_nr);
460   if (src->vts_file == NULL)
461     goto ifo_open_failed;
463   src->ttn = src->tt_srpt->title[title].vts_ttn;
464   src->vts_ptt_srpt = src->vts_file->vts_ptt_srpt;
466   /* interactive title? */
467   if (src->num_chapters > 0 &&
468       src->vts_ptt_srpt->title[src->ttn - 1].ptt[0].pgn == 0) {
469     goto commands_only_pgc;
470   }
472   /* we've got enough info, time to open the title set data */
473   src->dvd_title = DVDOpenFile (src->dvd, title_set_nr, DVD_READ_TITLE_VOBS);
474   if (src->dvd_title == NULL)
475     goto title_open_failed;
477   GST_INFO_OBJECT (src, "Opened title %d, angle %d", title + 1, angle);
478   src->title = title;
479   src->angle = angle;
481   /* build event */
483   if (src->title_lang_event_pending) {
484     gst_event_unref (src->title_lang_event_pending);
485     src->title_lang_event_pending = NULL;
486   }
488   s = gst_structure_new ("application/x-gst-dvd",
489       "event", G_TYPE_STRING, "dvd-lang-codes", NULL);
491   /* so we can filter out invalid/unused streams (same for all chapters) */
492   cur_title_get_chapter_pgc (src, 0, &pgn0, &pgc0_id, &pgc0);
494   /* audio */
495   for (i = 0; i < src->vts_file->vtsi_mat->nr_of_vts_audio_streams; i++) {
496     const audio_attr_t *a;
498     /* audio stream present? */
499     if (pgc0 != NULL && (pgc0->audio_control[i] & 0x8000) == 0)
500       continue;
502     a = &src->vts_file->vtsi_mat->vts_audio_attr[i];
504     t = g_strdup_printf ("audio-%d-format", i);
505     gst_structure_set (s, t, G_TYPE_INT, (int) a->audio_format, NULL);
506     g_free (t);
508     if (a->lang_type) {
509       t = g_strdup_printf ("audio-%d-language", i);
510       lang_code[0] = (a->lang_code >> 8) & 0xff;
511       lang_code[1] = a->lang_code & 0xff;
512       gst_structure_set (s, t, G_TYPE_STRING, lang_code, NULL);
513       g_free (t);
514     } else {
515       lang_code[0] = '\0';
516     }
518     GST_INFO_OBJECT (src, "[%02d] Audio    %02d: lang='%s', format=%d",
519         src->title + 1, i, lang_code, (gint) a->audio_format);
520   }
522   /* subtitle */
523   for (i = 0; i < src->vts_file->vtsi_mat->nr_of_vts_subp_streams; i++) {
524     const subp_attr_t *u;
526     /* subpicture stream present? */
527     if (pgc0 != NULL && (pgc0->subp_control[i] & 0x80000000) == 0)
528       continue;
530     u = &src->vts_file->vtsi_mat->vts_subp_attr[i];
532     if (u->type) {
533       t = g_strdup_printf ("subtitle-%d-language", i);
534       lang_code[0] = (u->lang_code >> 8) & 0xff;
535       lang_code[1] = u->lang_code & 0xff;
536       gst_structure_set (s, t, G_TYPE_STRING, lang_code, NULL);
537       g_free (t);
538     } else {
539       lang_code[0] = '\0';
540     }
542     GST_INFO_OBJECT (src, "[%02d] Subtitle %02d: lang='%s', type=%d",
543         src->title + 1, i, lang_code, u->type);
544   }
546   src->title_lang_event_pending =
547       gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s);
549   /* dump seek tables */
550   src->vts_tmapt = src->vts_file->vts_tmapt;
551   if (src->vts_tmapt) {
552     gint i, j;
554     GST_LOG_OBJECT (src, "nr_of_tmaps = %d", src->vts_tmapt->nr_of_tmaps);
555     for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
556       GST_LOG_OBJECT (src, "======= Table %d ===================", i);
557       GST_LOG_OBJECT (src, "Offset relative to VTS_TMAPTI: %d",
558           src->vts_tmapt->tmap_offset[i]);
559       GST_LOG_OBJECT (src, "Time unit (seconds)          : %d",
560           src->vts_tmapt->tmap[i].tmu);
561       GST_LOG_OBJECT (src, "Number of entries            : %d",
562           src->vts_tmapt->tmap[i].nr_of_entries);
563       for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; j++) {
564         guint64 time;
566         time = src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
567         GST_LOG_OBJECT (src, "Time: %" GST_TIME_FORMAT " VOBU "
568             "Sector: 0x%08x %s", GST_TIME_ARGS (time),
569             src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff,
570             (src->vts_tmapt->tmap[i].map_ent[j] >> 31) ? "discontinuity" : "");
571       }
572     }
573   } else {
574     GST_WARNING_OBJECT (src, "no vts_tmapt - seeking will suck");
575   }
577   gst_dvd_read_src_get_chapter_starts (src);
579   return TRUE;
581   /* ERRORS */
582 invalid_title:
583   {
584     GST_WARNING_OBJECT (src, "Invalid title %d (only %d available)",
585         title, num_titles);
586     return FALSE;
587   }
588 ifo_open_failed:
589   {
590     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
591         (_("Could not open DVD title %d"), title_set_nr),
592         ("ifoOpen(%d) failed: %s", title_set_nr, g_strerror (errno)));
593     return FALSE;
594   }
595 title_open_failed:
596   {
597     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
598         (_("Could not open DVD title %d"), title_set_nr),
599         ("Can't open title VOBS (VTS_%02d_1.VOB)", title_set_nr));
600     return FALSE;
601   }
602 commands_only_pgc:
603   {
604     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
605         (_("Could not open DVD title %d. Interactive titles are not supported "
606                 "by this element"), title_set_nr),
607         ("Commands-only PGC, not supported, use rsndvdbin"));
608     return FALSE;
609   }
612 /* FIXME: double-check this function, compare against original */
613 static gint
614 gst_dvd_read_src_get_next_cell (GstDvdReadSrc * src, pgc_t * pgc, gint cell)
616   /* Check if we're entering an angle block. */
617   if (pgc->cell_playback[cell].block_type != BLOCK_TYPE_ANGLE_BLOCK)
618     return (cell + 1);
620   while (pgc->cell_playback[cell].block_mode != BLOCK_MODE_LAST_CELL)
621     ++cell;
623   return cell + 1;
626 /* Returns true if the pack is a NAV pack */
627 static gboolean
628 gst_dvd_read_src_is_nav_pack (const guint8 * data, gint lbn, dsi_t * dsi_pack)
630   if (GST_READ_UINT32_BE (data + 0x26) != 0x000001BF)
631     return FALSE;
633   /* Check that this is substream 0 (PCI) */
634   if (data[0x2c] != 0)
635     return FALSE;
637   if (GST_READ_UINT32_BE (data + 0x400) != 0x000001BF)
638     return FALSE;
640   /* Check that this is substream 1 (DSI) */
641   if (data[0x406] != 1)
642     return FALSE;
644   /* Check sizes of PCI and DSI packets */
645   if (GST_READ_UINT16_BE (data + 0x2a) != 0x03d4)
646     return FALSE;
648   if (GST_READ_UINT16_BE (data + 0x404) != 0x03fa)
649     return FALSE;
651   /* Read the DSI packet into the provided struct and check it */
652   navRead_DSI (dsi_pack, (unsigned char *) data + DSI_START_BYTE);
653   if (lbn != dsi_pack->dsi_gi.nv_pck_lbn)
654     return FALSE;
656   return TRUE;
659 /* find time for sector from index, returns NONE if there is no exact match */
660 static GstClockTime
661 gst_dvd_read_src_get_time_for_sector (GstDvdReadSrc * src, guint sector)
663   gint i, j;
665   if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0)
666     return GST_CLOCK_TIME_NONE;
668   for (i = 0; i < src->vts_tmapt->nr_of_tmaps; ++i) {
669     for (j = 0; j < src->vts_tmapt->tmap[i].nr_of_entries; ++j) {
670       if ((src->vts_tmapt->tmap[i].map_ent[j] & 0x7fffffff) == sector)
671         return src->vts_tmapt->tmap[i].tmu * (j + 1) * GST_SECOND;
672     }
673   }
675   if (sector == 0)
676     return (GstClockTime) 0;
678   return GST_CLOCK_TIME_NONE;
681 /* returns the sector in the index at (or before) the given time, or -1 */
682 static gint
683 gst_dvd_read_src_get_sector_from_time (GstDvdReadSrc * src, GstClockTime ts)
685   gint sector, j;
687   if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps < src->ttn)
688     return -1;
690   sector = 0;
691   for (j = 0; j < src->vts_tmapt->tmap[src->ttn - 1].nr_of_entries; ++j) {
692     GstClockTime entry_time;
694     entry_time = src->vts_tmapt->tmap[src->ttn - 1].tmu * (j + 1) * GST_SECOND;
695     if (entry_time <= ts) {
696       sector = src->vts_tmapt->tmap[src->ttn - 1].map_ent[j] & 0x7fffffff;
697     }
698     if (entry_time >= ts) {
699       return sector;
700     }
701   }
703   if (ts == 0)
704     return 0;
706   return -1;
709 typedef enum
711   GST_DVD_READ_OK = 0,
712   GST_DVD_READ_ERROR = -1,
713   GST_DVD_READ_EOS = -2,
714   GST_DVD_READ_AGAIN = -3
715 } GstDvdReadReturn;
717 static GstDvdReadReturn
718 gst_dvd_read_src_read (GstDvdReadSrc * src, gint angle, gint new_seek,
719     GstBuffer ** p_buf)
721   GstBuffer *buf;
722   GstSegment *seg;
723   guint8 oneblock[DVD_VIDEO_LB_LEN];
724   dsi_t dsi_pack;
725   guint next_vobu, cur_output_size;
726   gint len;
727   gint retries;
728   gint64 next_time;
730   seg = &(GST_BASE_SRC (src)->segment);
732   /* playback by cell in this pgc, starting at the cell for our chapter */
733   if (new_seek)
734     src->cur_cell = src->start_cell;
736 again:
738   if (src->cur_cell >= src->last_cell) {
739     /* advance to next chapter */
740     if (src->chapter == (src->num_chapters - 1) ||
741         (seg->format == chapter_format && seg->stop != -1 &&
742             src->chapter == (seg->stop - 1))) {
743       GST_DEBUG_OBJECT (src, "end of chapter segment");
744       goto eos;
745     }
747     GST_INFO_OBJECT (src, "end of chapter %d, switch to next",
748         src->chapter + 1);
750     ++src->chapter;
751     gst_dvd_read_src_goto_chapter (src, src->chapter);
753     return GST_DVD_READ_AGAIN;
754   }
756   if (src->new_cell || new_seek) {
757     if (!new_seek) {
758       src->cur_cell = src->next_cell;
759       if (src->cur_cell >= src->last_cell) {
760         GST_LOG_OBJECT (src, "last cell in chapter");
761         goto again;
762       }
763     }
765     /* take angle into account */
766     if (src->cur_pgc->cell_playback[src->cur_cell].block_type
767         == BLOCK_TYPE_ANGLE_BLOCK)
768       src->cur_cell += angle;
770     /* calculate next cell */
771     src->next_cell =
772         gst_dvd_read_src_get_next_cell (src, src->cur_pgc, src->cur_cell);
774     /* we loop until we're out of this cell */
775     src->cur_pack = src->cur_pgc->cell_playback[src->cur_cell].first_sector;
776     src->new_cell = FALSE;
777     GST_DEBUG_OBJECT (src, "Starting new cell %d @ pack %d", src->cur_cell,
778         src->cur_pack);
779   }
781   if (src->cur_pack >= src->cur_pgc->cell_playback[src->cur_cell].last_sector) {
782     src->new_cell = TRUE;
783     GST_LOG_OBJECT (src, "Beyond last sector for cell %d, going to next cell",
784         src->cur_cell);
785     return GST_DVD_READ_AGAIN;
786   }
788   /* read NAV packet */
789   retries = 0;
790 nav_retry:
791   retries++;
793   len = DVDReadBlocks (src->dvd_title, src->cur_pack, 1, oneblock);
794   if (len != 1)
795     goto read_error;
797   if (!gst_dvd_read_src_is_nav_pack (oneblock, src->cur_pack, &dsi_pack)) {
798     GST_LOG_OBJECT (src, "Skipping nav packet @ pack %d", src->cur_pack);
799     src->cur_pack++;
801     if (retries < 2000) {
802       goto nav_retry;
803     } else {
804       GST_LOG_OBJECT (src, "No nav packet @ pack %d after 2000 blocks",
805           src->cur_pack);
806       goto read_error;
807     }
808   }
810   /* determine where we go next. These values are the ones we
811    * mostly care about */
812   cur_output_size = dsi_pack.dsi_gi.vobu_ea + 1;
814   /* If we're not at the end of this cell, we can determine the next
815    * VOBU to display using the VOBU_SRI information section of the
816    * DSI.  Using this value correctly follows the current angle,
817    * avoiding the doubled scenes in The Matrix, and makes our life
818    * really happy.
819    *
820    * Otherwise, we set our next address past the end of this cell to
821    * force the code above to go to the next cell in the program. */
822   if (dsi_pack.vobu_sri.next_vobu != SRI_END_OF_CELL) {
823     next_vobu = src->cur_pack + (dsi_pack.vobu_sri.next_vobu & 0x7fffffff);
824   } else {
825     next_vobu = src->cur_pgc->cell_playback[src->cur_cell].last_sector + 1;
826   }
828   g_assert (cur_output_size < 1024);
830   /* create the buffer (TODO: use buffer pool?) */
831   buf = gst_buffer_new_and_alloc (cur_output_size * DVD_VIDEO_LB_LEN);
833   GST_LOG_OBJECT (src, "Going to read %u sectors @ pack %d", cur_output_size,
834       src->cur_pack);
836   /* read in and output cursize packs */
837   len = DVDReadBlocks (src->dvd_title, src->cur_pack, cur_output_size,
838       GST_BUFFER_DATA (buf));
840   if (len != cur_output_size)
841     goto block_read_error;
843   GST_BUFFER_SIZE (buf) = cur_output_size * DVD_VIDEO_LB_LEN;
844   /* GST_BUFFER_OFFSET (buf) = priv->cur_pack * DVD_VIDEO_LB_LEN; */
845   GST_BUFFER_TIMESTAMP (buf) =
846       gst_dvd_read_src_get_time_for_sector (src, src->cur_pack);
848   gst_buffer_set_caps (buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (src)));
850   *p_buf = buf;
852   GST_LOG_OBJECT (src, "Read %u sectors", cur_output_size);
854   src->cur_pack = next_vobu;
856   next_time = GST_BUFFER_TIMESTAMP (buf);
857   if (GST_CLOCK_TIME_IS_VALID (next_time) && seg->format == GST_FORMAT_TIME &&
858       GST_CLOCK_TIME_IS_VALID (seg->stop) &&
859       next_time > seg->stop + 5 * GST_SECOND) {
860     GST_DEBUG_OBJECT (src, "end of TIME segment");
861     goto eos;
862   }
864   return GST_DVD_READ_OK;
866   /* ERRORS */
867 eos:
868   {
869     GST_INFO_OBJECT (src, "Reached end-of-segment/stream - EOS");
870     return GST_DVD_READ_EOS;
871   }
872 read_error:
873   {
874     GST_ERROR_OBJECT (src, "Read failed for block %d", src->cur_pack);
875     return GST_DVD_READ_ERROR;
876   }
877 block_read_error:
878   {
879     GST_ERROR_OBJECT (src, "Read failed for %d blocks at %d",
880         cur_output_size, src->cur_pack);
881     gst_buffer_unref (buf);
882     return GST_DVD_READ_ERROR;
883   }
886 /* we don't cache the result on purpose */
887 static gboolean
888 gst_dvd_read_descrambler_available (void)
890   GModule *module;
891   gpointer sym;
892   gsize res;
894   module = g_module_open ("libdvdcss", 0);
895   if (module != NULL) {
896     res = g_module_symbol (module, "dvdcss_open", &sym);
897     g_module_close (module);
898   } else {
899     res = FALSE;
900   }
902   return res;
905 static GstFlowReturn
906 gst_dvd_read_src_create (GstPushSrc * pushsrc, GstBuffer ** p_buf)
908   GstDvdReadSrc *src = GST_DVD_READ_SRC (pushsrc);
909   GstPad *srcpad;
910   gint res;
912   g_return_val_if_fail (src->dvd != NULL, GST_FLOW_ERROR);
914   srcpad = GST_BASE_SRC (src)->srcpad;
916   if (src->need_newsegment) {
917     gst_pad_push_event (srcpad,
918         gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,
919             (gint64) src->cur_pack * DVD_VIDEO_LB_LEN, -1, 0));
920     src->need_newsegment = FALSE;
921   }
923   if (src->new_seek) {
924     gst_dvd_read_src_goto_title (src, src->title, src->angle);
925     gst_dvd_read_src_goto_chapter (src, src->chapter);
927     src->new_seek = FALSE;
928     src->change_cell = TRUE;
929   }
931   if (src->title_lang_event_pending) {
932     gst_pad_push_event (srcpad, src->title_lang_event_pending);
933     src->title_lang_event_pending = NULL;
934   }
936   if (src->pending_clut_event) {
937     gst_pad_push_event (srcpad, src->pending_clut_event);
938     src->pending_clut_event = NULL;
939   }
941   /* read it in */
942   do {
943     res = gst_dvd_read_src_read (src, src->angle, src->change_cell, p_buf);
944   } while (res == GST_DVD_READ_AGAIN);
946   switch (res) {
947     case GST_DVD_READ_ERROR:{
948       /* FIXME: figure out a way to detect if scrambling is the problem */
949       if (!gst_dvd_read_descrambler_available ()) {
950         GST_ELEMENT_ERROR (src, RESOURCE, READ,
951             (_("Could not read DVD. This may be because the DVD is encrypted "
952                     "and a DVD decryption library is not installed.")), (NULL));
953       } else {
954         GST_ELEMENT_ERROR (src, RESOURCE, READ, (_("Could not read DVD.")),
955             (NULL));
956       }
957       return GST_FLOW_ERROR;
958     }
959     case GST_DVD_READ_EOS:{
960       return GST_FLOW_UNEXPECTED;
961     }
962     case GST_DVD_READ_OK:{
963       src->change_cell = FALSE;
964       return GST_FLOW_OK;
965     }
966     default:
967       break;
968   }
970   g_return_val_if_reached (GST_FLOW_UNEXPECTED);
973 static void
974 gst_dvd_read_src_set_property (GObject * object, guint prop_id,
975     const GValue * value, GParamSpec * pspec)
977   GstDvdReadSrc *src = GST_DVD_READ_SRC (object);
978   gboolean started;
980   GST_OBJECT_LOCK (src);
981   started = GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_STARTED);
983   switch (prop_id) {
984     case ARG_DEVICE:{
985       if (started) {
986         g_warning ("%s: property '%s' needs to be set before the device is "
987             "opened", GST_ELEMENT_NAME (src), pspec->name);
988         break;;
989       }
991       g_free (src->location);
992       /* clear the filename if we get a NULL (is that possible?) */
993       if (g_value_get_string (value) == NULL) {
994         src->location = g_strdup ("/dev/dvd");
995       } else {
996         src->location = g_strdup (g_value_get_string (value));
997       }
998       break;
999     }
1000     case ARG_TITLE:
1001       src->uri_title = g_value_get_int (value);
1002       if (started) {
1003         src->title = src->uri_title - 1;
1004         src->new_seek = TRUE;
1005       }
1006       break;
1007     case ARG_CHAPTER:
1008       src->uri_chapter = g_value_get_int (value);
1009       if (started) {
1010         src->chapter = src->uri_chapter - 1;
1011         src->new_seek = TRUE;
1012       }
1013       break;
1014     case ARG_ANGLE:
1015       src->uri_angle = g_value_get_int (value);
1016       if (started) {
1017         src->angle = src->uri_angle - 1;
1018       }
1019       break;
1020     default:
1021       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1022       break;
1023   }
1025   GST_OBJECT_UNLOCK (src);
1028 static void
1029 gst_dvd_read_src_get_property (GObject * object, guint prop_id, GValue * value,
1030     GParamSpec * pspec)
1032   GstDvdReadSrc *src = GST_DVD_READ_SRC (object);
1034   GST_OBJECT_LOCK (src);
1036   switch (prop_id) {
1037     case ARG_DEVICE:
1038       g_value_set_string (value, src->location);
1039       break;
1040     case ARG_TITLE:
1041       g_value_set_int (value, src->uri_title);
1042       break;
1043     case ARG_CHAPTER:
1044       g_value_set_int (value, src->uri_chapter);
1045       break;
1046     case ARG_ANGLE:
1047       g_value_set_int (value, src->uri_angle);
1048       break;
1049     default:
1050       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1051       break;
1052   }
1054   GST_OBJECT_UNLOCK (src);
1057 static gboolean
1058 gst_dvd_read_src_get_size (GstDvdReadSrc * src, gint64 * size)
1060   gboolean ret = FALSE;
1062   if (src->dvd_title) {
1063     gsize blocks;
1065     blocks = DVDFileSize (src->dvd_title);
1066     if (blocks >= 0) {
1067       *size = (gint64) blocks *DVD_VIDEO_LB_LEN;
1069       ret = TRUE;
1070     } else {
1071       GST_WARNING_OBJECT (src, "DVDFileSize(%p) failed!", src->dvd_title);
1072     }
1073   }
1075   return ret;
1078 /*** Querying and seeking ***/
1080 static gboolean
1081 gst_dvd_read_src_handle_seek_event (GstDvdReadSrc * src, GstEvent * event)
1083   GstSeekFlags flags;
1084   GstSeekType cur_type, end_type;
1085   gint64 new_off, total;
1086   GstFormat format;
1087   GstPad *srcpad;
1088   gboolean query_ok;
1089   gdouble rate;
1091   gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &new_off,
1092       &end_type, NULL);
1094   if (rate <= 0.0) {
1095     GST_DEBUG_OBJECT (src, "cannot do backwards playback yet");
1096     return FALSE;
1097   }
1099   if (end_type != GST_SEEK_TYPE_NONE) {
1100     if ((format != chapter_format && format != GST_FORMAT_TIME) ||
1101         end_type != GST_SEEK_TYPE_SET) {
1102       GST_DEBUG_OBJECT (src, "end seek type not supported");
1103       return FALSE;
1104     }
1105   }
1107   if (cur_type != GST_SEEK_TYPE_SET) {
1108     GST_DEBUG_OBJECT (src, "only SEEK_TYPE_SET is supported");
1109     return FALSE;
1110   }
1112   if (format == angle_format) {
1113     GST_OBJECT_LOCK (src);
1114     if (new_off < 0 || new_off >= src->num_angles) {
1115       GST_OBJECT_UNLOCK (src);
1116       GST_DEBUG_OBJECT (src, "invalid angle %d, only %d available",
1117           src->num_angles, src->num_angles);
1118       return FALSE;
1119     }
1120     src->angle = (gint) new_off;
1121     GST_OBJECT_UNLOCK (src);
1122     GST_DEBUG_OBJECT (src, "switched to angle %d", (gint) new_off + 1);
1123     return TRUE;
1124   }
1126   if (format != chapter_format && format != title_format &&
1127       format != GST_FORMAT_BYTES && format != GST_FORMAT_TIME) {
1128     GST_DEBUG_OBJECT (src, "unsupported seek format %d (%s)", format,
1129         gst_format_get_name (format));
1130     return FALSE;
1131   }
1133   if (format == GST_FORMAT_BYTES) {
1134     GST_DEBUG_OBJECT (src, "Requested seek to byte %" G_GUINT64_FORMAT,
1135         new_off);
1136   } else if (format == GST_FORMAT_TIME) {
1137     GST_DEBUG_OBJECT (src, "Requested seek to time %" GST_TIME_FORMAT,
1138         GST_TIME_ARGS (new_off));
1139     if (gst_dvd_read_src_get_sector_from_time (src, new_off) < 0) {
1140       GST_DEBUG_OBJECT (src, "Can't find sector for requested time");
1141       return FALSE;
1142     }
1143   }
1145   srcpad = GST_BASE_SRC_PAD (src);
1147   /* check whether the seek looks reasonable (ie within possible range) */
1148   if (format == GST_FORMAT_BYTES) {
1149     GST_OBJECT_LOCK (src);
1150     query_ok = gst_dvd_read_src_get_size (src, &total);
1151     GST_OBJECT_UNLOCK (src);
1152   } else {
1153     query_ok = gst_pad_query_duration (srcpad, &format, &total);
1154   }
1156   if (!query_ok) {
1157     GST_DEBUG_OBJECT (src, "Failed to query duration in format %s",
1158         gst_format_get_name (format));
1159     return FALSE;
1160   }
1162   GST_DEBUG_OBJECT (src, "Total      %s: %12" G_GINT64_FORMAT,
1163       gst_format_get_name (format), total);
1164   GST_DEBUG_OBJECT (src, "Seek to    %s: %12" G_GINT64_FORMAT,
1165       gst_format_get_name (format), new_off);
1167   if (new_off >= total) {
1168     GST_DEBUG_OBJECT (src, "Seek position out of range");
1169     return FALSE;
1170   }
1172   /* set segment to seek format; this allows us to use the do_seek
1173    * virtual function and let the base source handle all the tricky
1174    * stuff for us. We don't use the segment internally anyway */
1175   /* FIXME: can't take the stream lock here - what to do? */
1176   GST_OBJECT_LOCK (src);
1177   GST_BASE_SRC (src)->segment.format = format;
1178   GST_BASE_SRC (src)->segment.start = 0;
1179   GST_BASE_SRC (src)->segment.stop = total;
1180   GST_BASE_SRC (src)->segment.duration = total;
1181   GST_OBJECT_UNLOCK (src);
1183   return GST_BASE_SRC_CLASS (parent_class)->event (GST_BASE_SRC (src), event);
1186 static gboolean
1187 gst_dvd_read_src_do_seek (GstBaseSrc * basesrc, GstSegment * s)
1189   GstDvdReadSrc *src;
1191   src = GST_DVD_READ_SRC (basesrc);
1193   GST_DEBUG_OBJECT (src, "Seeking to %s: %12" G_GINT64_FORMAT,
1194       gst_format_get_name (s->format), s->last_stop);
1196   if (s->format == sector_format || s->format == GST_FORMAT_BYTES
1197       || s->format == GST_FORMAT_TIME) {
1198     guint old;
1200     old = src->cur_pack;
1202     if (s->format == sector_format) {
1203       src->cur_pack = s->last_stop;
1204     } else if (s->format == GST_FORMAT_TIME) {
1205       gint sector;
1207       sector = gst_dvd_read_src_get_sector_from_time (src, s->last_stop);
1209       GST_DEBUG_OBJECT (src, "Time %" GST_TIME_FORMAT " => sector %d",
1210           GST_TIME_ARGS (s->last_stop), sector);
1212       /* really shouldn't happen, we've checked this earlier ... */
1213       g_return_val_if_fail (sector >= 0, FALSE);
1215       src->cur_pack = sector;
1216     } else {
1217       /* byte format */
1218       src->cur_pack = s->last_stop / DVD_VIDEO_LB_LEN;
1219       if (((gint64) src->cur_pack * DVD_VIDEO_LB_LEN) != s->last_stop) {
1220         GST_LOG_OBJECT (src, "rounded down offset %" G_GINT64_FORMAT " => %"
1221             G_GINT64_FORMAT, s->last_stop,
1222             (gint64) src->cur_pack * DVD_VIDEO_LB_LEN);
1223       }
1224     }
1226     if (!gst_dvd_read_src_goto_sector (src, src->angle)) {
1227       GST_DEBUG_OBJECT (src, "seek to sector 0x%08x failed", src->cur_pack);
1228       src->cur_pack = old;
1229       return FALSE;
1230     }
1232     GST_LOG_OBJECT (src, "seek to sector 0x%08x ok", src->cur_pack);
1233   } else if (s->format == chapter_format) {
1234     if (!gst_dvd_read_src_goto_chapter (src, (gint) s->last_stop)) {
1235       GST_DEBUG_OBJECT (src, "seek to chapter %d failed",
1236           (gint) s->last_stop + 1);
1237       return FALSE;
1238     }
1239     GST_INFO_OBJECT (src, "seek to chapter %d ok", (gint) s->last_stop + 1);
1240     src->chapter = s->last_stop;
1241   } else if (s->format == title_format) {
1242     if (!gst_dvd_read_src_goto_title (src, (gint) s->last_stop, src->angle) ||
1243         !gst_dvd_read_src_goto_chapter (src, 0)) {
1244       GST_DEBUG_OBJECT (src, "seek to title %d failed", (gint) s->last_stop);
1245       return FALSE;
1246     }
1247     src->title = (gint) s->last_stop;
1248     src->chapter = 0;
1249     GST_INFO_OBJECT (src, "seek to title %d ok", src->title + 1);
1250   } else {
1251     g_return_val_if_reached (FALSE);
1252   }
1254   src->need_newsegment = TRUE;
1255   return TRUE;
1258 static gboolean
1259 gst_dvd_read_src_src_event (GstBaseSrc * basesrc, GstEvent * event)
1261   GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
1262   gboolean res;
1264   GST_LOG_OBJECT (src, "handling %s event", GST_EVENT_TYPE_NAME (event));
1266   switch (GST_EVENT_TYPE (event)) {
1267     case GST_EVENT_SEEK:
1268       res = gst_dvd_read_src_handle_seek_event (src, event);
1269       break;
1270     default:
1271       res = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);
1272       break;
1273   }
1275   return res;
1278 static GstEvent *
1279 gst_dvd_read_src_make_clut_change_event (GstDvdReadSrc * src,
1280     const guint * clut)
1282   GstStructure *structure;
1283   gchar name[16];
1284   gint i;
1286   structure = gst_structure_new ("application/x-gst-dvd",
1287       "event", G_TYPE_STRING, "dvd-spu-clut-change", NULL);
1289   /* Create a separate field for each value in the table. */
1290   for (i = 0; i < 16; i++) {
1291     g_snprintf (name, sizeof (name), "clut%02d", i);
1292     gst_structure_set (structure, name, G_TYPE_INT, (int) clut[i], NULL);
1293   }
1295   /* Create the DVD event and put the structure into it. */
1296   return gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, structure);
1299 static gint64
1300 gst_dvd_read_src_convert_timecode (dvd_time_t * time)
1302   gint64 ret_time;
1303   const gint64 one_hour = 3600 * GST_SECOND;
1304   const gint64 one_min = 60 * GST_SECOND;
1306   g_return_val_if_fail ((time->hour >> 4) < 0xa
1307       && (time->hour & 0xf) < 0xa, -1);
1308   g_return_val_if_fail ((time->minute >> 4) < 0x7
1309       && (time->minute & 0xf) < 0xa, -1);
1310   g_return_val_if_fail ((time->second >> 4) < 0x7
1311       && (time->second & 0xf) < 0xa, -1);
1313   ret_time = ((time->hour >> 4) * 10 + (time->hour & 0xf)) * one_hour;
1314   ret_time += ((time->minute >> 4) * 10 + (time->minute & 0xf)) * one_min;
1315   ret_time += ((time->second >> 4) * 10 + (time->second & 0xf)) * GST_SECOND;
1317   return ret_time;
1320 static gboolean
1321 gst_dvd_read_src_do_duration_query (GstDvdReadSrc * src, GstQuery * query)
1323   GstFormat format;
1324   gint64 val;
1326   gst_query_parse_duration (query, &format, NULL);
1328   switch (format) {
1329     case GST_FORMAT_TIME:{
1330       if (src->cur_pgc == NULL)
1331         return FALSE;
1332       val = gst_dvd_read_src_convert_timecode (&src->cur_pgc->playback_time);
1333       if (val < 0)
1334         return FALSE;
1335       break;
1336     }
1337     case GST_FORMAT_BYTES:{
1338       if (!gst_dvd_read_src_get_size (src, &val))
1339         return FALSE;
1340       break;
1341     }
1342     default:{
1343       if (format == sector_format) {
1344         val = DVDFileSize (src->dvd_title);
1345       } else if (format == title_format) {
1346         val = src->tt_srpt->nr_of_srpts;
1347       } else if (format == chapter_format) {
1348         val = src->num_chapters;
1349       } else if (format == angle_format) {
1350         val = src->tt_srpt->title[src->title].nr_of_angles;
1351       } else {
1352         GST_DEBUG_OBJECT (src, "Don't know how to handle format %d (%s)",
1353             format, gst_format_get_name (format));
1354         return FALSE;
1355       }
1356       break;
1357     }
1358   }
1360   GST_LOG_OBJECT (src, "duration = %" G_GINT64_FORMAT " %s", val,
1361       gst_format_get_name (format));
1363   gst_query_set_duration (query, format, val);
1364   return TRUE;
1367 static gboolean
1368 gst_dvd_read_src_do_position_query (GstDvdReadSrc * src, GstQuery * query)
1370   GstFormat format;
1371   gint64 val;
1373   gst_query_parse_position (query, &format, NULL);
1375   switch (format) {
1376     case GST_FORMAT_BYTES:{
1377       val = (gint64) src->cur_pack * DVD_VIDEO_LB_LEN;
1378       break;
1379     }
1380     default:{
1381       if (format == sector_format) {
1382         val = src->cur_pack;
1383       } else if (format == title_format) {
1384         val = src->title;
1385       } else if (format == chapter_format) {
1386         val = src->chapter;
1387       } else if (format == angle_format) {
1388         val = src->angle;
1389       } else {
1390         GST_DEBUG_OBJECT (src, "Don't know how to handle format %d (%s)",
1391             format, gst_format_get_name (format));
1392         return FALSE;
1393       }
1394       break;
1395     }
1396   }
1398   GST_LOG_OBJECT (src, "position = %" G_GINT64_FORMAT " %s", val,
1399       gst_format_get_name (format));
1401   gst_query_set_position (query, format, val);
1402   return TRUE;
1405 static gboolean
1406 gst_dvd_read_src_do_convert_query (GstDvdReadSrc * src, GstQuery * query)
1408   GstFormat src_format, dest_format;
1409   gboolean ret = FALSE;
1410   gint64 src_val, dest_val = -1;
1412   gst_query_parse_convert (query, &src_format, &src_val, &dest_format, NULL);
1414   if (src_format == dest_format) {
1415     dest_val = src_val;
1416     ret = TRUE;
1417     goto done;
1418   }
1420   /* Formats to consider: TIME, DEFAULT, BYTES, title, chapter, sector.
1421    * Note: title and chapter are counted as starting from 0 here, just like
1422    * in the context of seek events. Another note: DEFAULT format is undefined */
1424   if (src_format == GST_FORMAT_BYTES) {
1425     src_format = sector_format;
1426     src_val /= DVD_VIDEO_LB_LEN;
1427   }
1429   if (src_format == sector_format) {
1430     /* SECTOR => xyz */
1431     if (dest_format == GST_FORMAT_TIME && src_val < G_MAXUINT) {
1432       dest_val = gst_dvd_read_src_get_time_for_sector (src, (guint) src_val);
1433       ret = (dest_val >= 0);
1434     } else if (dest_format == GST_FORMAT_BYTES) {
1435       dest_val = src_val * DVD_VIDEO_LB_LEN;
1436       ret = TRUE;
1437     } else {
1438       ret = FALSE;
1439     }
1440   } else if (src_format == title_format) {
1441     /* TITLE => xyz */
1442     if (dest_format == GST_FORMAT_TIME) {
1443       /* not really true, but we use this to trick the base source into
1444        * handling seeks in title-format for us (the source won't know that
1445        * we changed the title in this case) (changing titles should really
1446        * be done with an interface rather than a seek, but for now we're
1447        * stuck with this mechanism. Fix in 0.11) */
1448       dest_val = (GstClockTime) 0;
1449       ret = TRUE;
1450     } else {
1451       ret = FALSE;
1452     }
1453   } else if (src_format == chapter_format) {
1454     /* CHAPTER => xyz */
1455     if (dest_format == GST_FORMAT_TIME) {
1456       if (src->num_chapters >= 0 && src_val < src->num_chapters) {
1457         dest_val = src->chapter_starts[src_val];
1458         ret = TRUE;
1459       }
1460     } else if (dest_format == sector_format) {
1461     } else {
1462       ret = FALSE;
1463     }
1464   } else if (src_format == GST_FORMAT_TIME) {
1465     /* TIME => xyz */
1466     if (dest_format == sector_format || dest_format == GST_FORMAT_BYTES) {
1467       dest_val = gst_dvd_read_src_get_sector_from_time (src, src_val);
1468       ret = (dest_val >= 0);
1469       if (dest_format == GST_FORMAT_BYTES)
1470         dest_val *= DVD_VIDEO_LB_LEN;
1471     } else if (dest_format == chapter_format) {
1472       if (src->chapter_starts != NULL) {
1473         gint i;
1475         for (i = src->num_chapters - 1; i >= 0; --i) {
1476           if (src->chapter_starts && src->chapter_starts[i] >= src_val) {
1477             dest_val = i;
1478             ret = TRUE;
1479             break;
1480           }
1481         }
1482       } else {
1483         ret = FALSE;
1484       }
1485     } else {
1486       ret = FALSE;
1487     }
1488   } else {
1489     ret = FALSE;
1490   }
1492 done:
1494   if (ret) {
1495     gst_query_set_convert (query, src_format, src_val, dest_format, dest_val);
1496   }
1498   return ret;
1501 static gboolean
1502 gst_dvd_read_src_src_query (GstBaseSrc * basesrc, GstQuery * query)
1504   GstDvdReadSrc *src = GST_DVD_READ_SRC (basesrc);
1505   gboolean started;
1506   gboolean res = TRUE;
1508   GST_LOG_OBJECT (src, "handling %s query",
1509       gst_query_type_get_name (GST_QUERY_TYPE (query)));
1511   GST_OBJECT_LOCK (src);
1512   started = (GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_STARTED));
1513   GST_OBJECT_UNLOCK (src);
1515   if (!started) {
1516     GST_DEBUG_OBJECT (src, "query failed: not started");
1517     return FALSE;
1518   }
1520   switch (GST_QUERY_TYPE (query)) {
1521     case GST_QUERY_DURATION:
1522       GST_OBJECT_LOCK (src);
1523       res = gst_dvd_read_src_do_duration_query (src, query);
1524       GST_OBJECT_UNLOCK (src);
1525       break;
1526     case GST_QUERY_POSITION:
1527       GST_OBJECT_LOCK (src);
1528       res = gst_dvd_read_src_do_position_query (src, query);
1529       GST_OBJECT_UNLOCK (src);
1530       break;
1531     case GST_QUERY_CONVERT:
1532       GST_OBJECT_LOCK (src);
1533       res = gst_dvd_read_src_do_convert_query (src, query);
1534       GST_OBJECT_UNLOCK (src);
1535       break;
1536     default:
1537       res = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query);
1538       break;
1539   }
1541   return res;
1544 static gboolean
1545 gst_dvd_read_src_goto_sector (GstDvdReadSrc * src, int angle)
1547   gint seek_to = src->cur_pack;
1548   gint chapter, sectors, next, cur, i;
1550   /* retrieve position */
1551   src->cur_pack = 0;
1552   for (i = 0; i < src->num_chapters; i++) {
1553     gint c1, c2;
1555     cur_title_get_chapter_bounds (src, i, &c1, &c2);
1557     for (next = cur = c1; cur < c2;) {
1558       if (next != cur) {
1559         sectors =
1560             src->cur_pgc->cell_playback[cur].last_sector -
1561             src->cur_pgc->cell_playback[cur].first_sector;
1562         if (src->cur_pack + sectors > seek_to) {
1563           chapter = i;
1564           goto done;
1565         }
1566         src->cur_pack += sectors;
1567       }
1568       cur = next;
1569       if (src->cur_pgc->cell_playback[cur].block_type == BLOCK_TYPE_ANGLE_BLOCK)
1570         cur += angle;
1571       next = gst_dvd_read_src_get_next_cell (src, src->cur_pgc, cur);
1572     }
1573   }
1575   GST_DEBUG_OBJECT (src, "Seek to sector %u failed", seek_to);
1577   return FALSE;
1579 done:
1580   {
1581     /* so chapter $chapter and cell $cur contain our sector
1582      * of interest. Let's go there! */
1583     GST_INFO_OBJECT (src, "Seek succeeded, going to chapter %u, cell %u",
1584         chapter + 1, cur);
1586     gst_dvd_read_src_goto_chapter (src, chapter);
1587     src->cur_cell = cur;
1588     src->next_cell = next;
1589     src->new_cell = FALSE;
1590     src->cur_pack = seek_to;
1592     return TRUE;
1593   }
1597 /*** URI interface ***/
1599 static GstURIType
1600 gst_dvd_read_src_uri_get_type (void)
1602   return GST_URI_SRC;
1605 static gchar **
1606 gst_dvd_read_src_uri_get_protocols (void)
1608   static gchar *protocols[] = { (gchar *) "dvd", NULL };
1610   return protocols;
1613 static const gchar *
1614 gst_dvd_read_src_uri_get_uri (GstURIHandler * handler)
1616   GstDvdReadSrc *src = GST_DVD_READ_SRC (handler);
1618   GST_OBJECT_LOCK (src);
1620   g_free (src->last_uri);
1621   src->last_uri = g_strdup_printf ("dvd://%d,%d,%d", src->uri_title,
1622       src->uri_chapter, src->uri_angle);
1624   GST_OBJECT_UNLOCK (src);
1626   return src->last_uri;
1629 static gboolean
1630 gst_dvd_read_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
1632   GstDvdReadSrc *src = GST_DVD_READ_SRC (handler);
1633   gboolean ret;
1634   gchar *protocol;
1636   protocol = gst_uri_get_protocol (uri);
1637   ret = (protocol != NULL && g_str_equal (protocol, "dvd"));
1638   g_free (protocol);
1639   protocol = NULL;
1641   if (!ret)
1642     return ret;
1644   /* parse out the new t/c/a and seek to them */
1645   {
1646     gchar *location = NULL;
1647     gchar **strs;
1648     gchar **strcur;
1649     gint pos = 0;
1651     location = gst_uri_get_location (uri);
1653     if (!location)
1654       return ret;
1656     GST_OBJECT_LOCK (src);
1658     src->uri_title = 1;
1659     src->uri_chapter = 1;
1660     src->uri_angle = 1;
1662     strcur = strs = g_strsplit (location, ",", 0);
1663     while (strcur && *strcur) {
1664       gint val;
1666       if (!sscanf (*strcur, "%d", &val))
1667         break;
1669       if (val <= 0) {
1670         g_warning ("Invalid value %d in URI '%s'. Must be 1 or greater",
1671             val, location);
1672         break;
1673       }
1675       switch (pos) {
1676         case 0:
1677           src->uri_title = val;
1678           break;
1679         case 1:
1680           src->uri_chapter = val;
1681           break;
1682         case 2:
1683           src->uri_angle = val;
1684           break;
1685       }
1687       strcur++;
1688       pos++;
1689     }
1691     if (pos > 0 && GST_OBJECT_FLAG_IS_SET (src, GST_BASE_SRC_STARTED)) {
1692       src->title = src->uri_title - 1;
1693       src->chapter = src->uri_chapter - 1;
1694       src->angle = src->uri_angle - 1;
1695       src->new_seek = TRUE;
1696     }
1698     GST_OBJECT_UNLOCK (src);
1700     g_strfreev (strs);
1701     g_free (location);
1702   }
1704   return ret;
1707 static void
1708 gst_dvd_read_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
1710   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
1712   iface->get_type = gst_dvd_read_src_uri_get_type;
1713   iface->get_protocols = gst_dvd_read_src_uri_get_protocols;
1714   iface->get_uri = gst_dvd_read_src_uri_get_uri;
1715   iface->set_uri = gst_dvd_read_src_uri_set_uri;
1718 static void
1719 gst_dvd_read_src_do_init (GType dvdreadsrc_type)
1721   static const GInterfaceInfo urihandler_info = {
1722     gst_dvd_read_src_uri_handler_init,
1723     NULL,
1724     NULL
1725   };
1727   g_type_add_interface_static (dvdreadsrc_type, GST_TYPE_URI_HANDLER,
1728       &urihandler_info);
1730   title_format = gst_format_register ("title", "DVD title");
1731   angle_format = gst_format_register ("angle", "DVD angle");
1732   sector_format = gst_format_register ("sector", "DVD sector");
1733   chapter_format = gst_format_register ("chapter", "DVD chapter");
1736 static gboolean
1737 plugin_init (GstPlugin * plugin)
1739   GST_DEBUG_CATEGORY_INIT (gstgst_dvd_read_src_debug, "dvdreadsrc", 0,
1740       "DVD reader element based on dvdreadsrc");
1742 #ifdef ENABLE_NLS
1743   GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE,
1744       LOCALEDIR);
1745   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
1746   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1747 #endif /* ENABLE_NLS */
1749   if (!gst_element_register (plugin, "dvdreadsrc", GST_RANK_SECONDARY,
1750           GST_TYPE_DVD_READ_SRC)) {
1751     return FALSE;
1752   }
1754   return TRUE;
1757 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
1758     GST_VERSION_MINOR,
1759     "dvdread",
1760     "Access a DVD with dvdread",
1761     plugin_init, VERSION, "GPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);