/* GStreamer * Copyright (C) 2002 David I. Lehn * * 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 #include #include #include #include #include #include //#include #define _(s) s /* FIXME */ #include "dvdnavsrc.h" GST_DEBUG_CATEGORY_STATIC (gst_dvd_nav_src_debug); #define GST_CAT_DEFAULT (gst_dvd_nav_src_debug) /* Size of a DVD sector, used for sector-byte format conversions */ #define DVD_SECTOR_SIZE 2048 #define CLOCK_BASE 9LL #define CLOCK_FREQ CLOCK_BASE * 10000 #define MPEGTIME_TO_GSTTIME(time) (((time) * (GST_MSECOND/10)) / CLOCK_BASE) #define GSTTIME_TO_MPEGTIME(time) (((time) * CLOCK_BASE) / (GST_MSECOND/10)) /* The maxinum number of audio and SPU streams in a DVD. */ #define GST_DVD_NAV_SRC_MAX_AUDIO_STREAMS 8 #define GST_DVD_NAV_SRC_MAX_SPU_STREAMS 32 /* Interval of time to sleep during pauses. */ #define GST_DVD_NAV_SRC_PAUSE_INTERVAL (GST_SECOND / 30) static const GstElementDetails gst_dvd_nav_src_details = { "DVD Source", "Source/File/DVD", "Access a DVD with navigation features using libdvdnav", "David I. Lehn ", }; enum { USER_OP_SIGNAL, LAST_SIGNAL }; enum { ARG_0, ARG_DEVICE #if 0 ARG_STREAMINFO, ARG_BUTTONINFO, ARG_TITLE, ARG_CHAPTER, ARG_ANGLE, ARG_AUDIO_LANGS, ARG_AUDIO_LANG, ARG_SPU_LANGS, ARG_SPU_LANG #endif }; static void gst_dvd_nav_src_do_init (GType dvdnavsrc_type); static gboolean gst_dvd_nav_src_start (GstBaseSrc * basesrc); static gboolean gst_dvd_nav_src_stop (GstBaseSrc * basesrc); static GstEvent * gst_dvd_nav_src_make_dvd_event (GstDvdNavSrc * src, const gchar * event_name, const gchar * firstfield, ...) G_GNUC_NULL_TERMINATED; static void gst_dvd_nav_src_finalize (GObject * object); static void gst_dvd_nav_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_dvd_nav_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void gst_dvd_nav_src_push_dvd_nav_packet_event (GstDvdNavSrc * src, const pci_t * pci); static void gst_dvd_nav_src_push_clut_change_event (GstDvdNavSrc * src, const guint32 * clut); static GstFlowReturn gst_dvd_nav_src_create (GstPushSrc * pushsrc, GstBuffer ** p_buf); static gboolean gst_dvd_nav_src_src_event (GstBaseSrc * basesrc, GstEvent * event); static gboolean gst_dvd_nav_src_query (GstBaseSrc * basesrc, GstQuery * query); static gboolean gst_dvd_nav_src_do_seek (GstBaseSrc * src, GstSegment * s); static gboolean gst_dvd_nav_src_is_open (GstDvdNavSrc * src); #if 0 static void gst_dvd_nav_src_set_clock (GstElement * element, GstClock * clock); #endif #ifndef GST_DISABLE_GST_DEBUG static void gst_dvd_nav_src_print_event (GstDvdNavSrc * src, guint8 * data, int event, int len); #else #define gst_dvd_nav_src_print_event(src, data, event, len) ((void) 0) #endif /* GST_DISABLE_GST_DEBUG */ static void gst_dvd_nav_src_update_streaminfo (GstDvdNavSrc * src); static void gst_dvd_nav_src_set_domain (GstDvdNavSrc * src); static void gst_dvd_nav_src_update_highlight (GstDvdNavSrc * src, gboolean force); static void gst_dvd_nav_src_user_op (GstDvdNavSrc * src, gint op); static void gst_dvd_nav_src_uri_handler_init (gpointer g_iface, gpointer iface_data); static gboolean gst_dvd_nav_src_query_position (GstDvdNavSrc * src, GstFormat format, gint64 * p_val); static gboolean gst_dvd_nav_src_query_duration (GstDvdNavSrc * src, GstFormat format, gint64 * p_val); static guint gst_dvd_nav_src_signals[LAST_SIGNAL]; static GstFormat sector_format; static GstFormat title_format; static GstFormat chapter_format; static GstFormat angle_format; #define DVD_NAV_SRC_CAPS \ "video/mpeg, mpegversion=(int)1, systemstream=(boolean)true" static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS (DVD_NAV_SRC_CAPS)); GST_BOILERPLATE_FULL (GstDvdNavSrc, gst_dvd_nav_src, GstPushSrc, GST_TYPE_PUSH_SRC, gst_dvd_nav_src_do_init); static void gst_dvd_nav_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_nav_src_details); } static gboolean gst_dvd_nav_src_is_seekable (GstBaseSrc * src) { return TRUE; } static void gst_dvd_nav_src_class_init (GstDvdNavSrcClass * klass) { GObjectClass *gobject_class; GstBaseSrcClass *gstbasesrc_class; GstPushSrcClass *gstpushsrc_class; gobject_class = (GObjectClass *) klass; gstbasesrc_class = (GstBaseSrcClass *) klass; gstpushsrc_class = (GstPushSrcClass *) klass; gst_dvd_nav_src_signals[USER_OP_SIGNAL] = g_signal_new ("user-op", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstDvdNavSrcClass, user_op), NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); klass->user_op = gst_dvd_nav_src_user_op; gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_finalize); gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_set_property); gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_get_property); g_object_class_install_property (gobject_class, ARG_DEVICE, g_param_spec_string ("device", "Device", "DVD device location", NULL, G_PARAM_READWRITE)); #if 0 g_object_class_install_property (gobject_class, ARG_TITLE, g_param_spec_int ("title", "title", "title", 0, 99, 1, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_CHAPTER, g_param_spec_int ("chapter", "chapter", "chapter", 1, 99, 1, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_ANGLE, g_param_spec_int ("angle", "angle", "angle", 1, 9, 1, G_PARAM_READWRITE)); /* FIXME: use tags instead of this? */ /* g_object_class_install_property (gobject_class, ARG_STREAMINFO, g_param_spec_boxed ("streaminfo", "streaminfo", "streaminfo", GST_TYPE_CAPS, G_PARAM_READABLE)); */ g_object_class_install_property (gobject_class, ARG_BUTTONINFO, g_param_spec_boxed ("buttoninfo", "buttoninfo", "buttoninfo", GST_TYPE_CAPS, G_PARAM_READABLE)); g_object_class_install_property (gobject_class, ARG_AUDIO_LANGS, g_param_spec_string ("audio_languages", "audio_languages", "Available audio languages", NULL, G_PARAM_READABLE)); g_object_class_install_property (gobject_class, ARG_AUDIO_LANG, g_param_spec_string ("audio_language", "audio_language", "Current audio language", NULL, G_PARAM_READABLE)); g_object_class_install_property (gobject_class, ARG_SPU_LANGS, g_param_spec_string ("spu_languages", "spu_languages", "Available SPU languages", NULL, G_PARAM_READABLE)); g_object_class_install_property (gobject_class, ARG_SPU_LANG, g_param_spec_string ("spu_language", "spu_language", "Current SPU language", NULL, G_PARAM_READABLE)); #endif gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_start); gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_stop); gstbasesrc_class->event = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_src_event); gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_query); gstpushsrc_class->create = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_create); gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_do_seek); gstbasesrc_class->is_seekable = GST_DEBUG_FUNCPTR (gst_dvd_nav_src_is_seekable); #if 0 gstelement_class->set_clock = gst_dvd_nav_src_set_clock; #endif } static gboolean gst_dvd_nav_src_check_get_range (GstPad * pad) { return FALSE; } static void gst_dvd_nav_src_init (GstDvdNavSrc * src, GstDvdNavSrcClass * klass) { src->device = g_strdup ("/dev/dvd"); src->last_uri = NULL; src->pending_offset = -1; src->new_seek = FALSE; src->seek_pending = FALSE; src->need_flush = FALSE; src->use_tmaps = FALSE; src->still_frame = FALSE; /* Pause mode is initially inactive. */ src->pause_mode = GST_DVD_NAV_SRC_PAUSE_OFF; /* No highlighted button. */ src->button = 0; /* Domain is unknown at the begining. */ src->domain = GST_DVD_NAV_SRC_DOMAIN_UNKNOWN; src->uri_title = 0; src->uri_chapter = 1; src->uri_angle = 1; src->streaminfo = NULL; src->buttoninfo = NULL; src->audio_phys = -1; src->audio_log = -1; src->subp_phys = -1; src->subp_log = -1; /* No current output buffer. */ src->cur_buf = NULL; src->pgc_length = GST_CLOCK_TIME_NONE; src->cell_start = 0; src->pg_start = 0; src->vmg_file = NULL; src->vts_attrs = NULL; src->vts_file = NULL; src->cur_vts = 0; /* avoid unnecessary start/stop in gst_base_src_check_get_range() */ gst_pad_set_checkgetrange_function (GST_BASE_SRC_PAD (src), GST_DEBUG_FUNCPTR (gst_dvd_nav_src_check_get_range)); } static void gst_dvd_nav_src_finalize (GObject * object) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (object); /* If there's a current output buffer, get rid of it. */ if (src->cur_buf != NULL) { gst_buffer_unref (src->cur_buf); } g_free (src->last_uri); if (src->vts_attrs) g_array_free (src->vts_attrs, TRUE); G_OBJECT_CLASS (parent_class)->finalize (object); } static gboolean gst_dvd_nav_src_is_open (GstDvdNavSrc * src) { return GST_OBJECT_FLAG_IS_SET (GST_OBJECT (src), GST_BASE_SRC_STARTED); } static void gst_dvd_nav_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (object); switch (prop_id) { case ARG_DEVICE: /* the element must be stopped in order to do this */ GST_OBJECT_LOCK (src); if (!gst_dvd_nav_src_is_open (src)) { g_free (src->device); if (g_value_get_string (value) == NULL) src->device = g_strdup ("/dev/dvd"); else src->device = g_value_dup_string (value); } else { g_warning ("dvdnavsrc: cannot change device while running"); } GST_OBJECT_UNLOCK (src); break; #if 0 case ARG_TITLE: src->uri_title = g_value_get_int (value); break; case ARG_CHAPTER: src->uri_chapter = g_value_get_int (value); break; case ARG_ANGLE: src->uri_angle = g_value_get_int (value); break; case ARG_AUDIO_LANG: if (gst_dvd_nav_src_is_open (src)) { const gchar *code = g_value_get_string (value); if (code != NULL) { GST_INFO_OBJECT (src, "setting language %s", code); if (dvdnav_audio_language_select (src->dvdnav, (char *) code) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "setting language: %s", dvdnav_err_to_string (src->dvdnav)); } } } break; case ARG_SPU_LANG: if (gst_dvd_nav_src_is_open (src)) { const gchar *code = g_value_get_string (value); if (code != NULL) { dvdnav_spu_language_select (src->dvdnav, (char *) code); } } break; #endif default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_dvd_nav_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (object); switch (prop_id) { case ARG_DEVICE: g_value_set_string (value, src->device); break; #if 0 case ARG_STREAMINFO: g_value_set_boxed (value, src->streaminfo); break; case ARG_BUTTONINFO: g_value_set_boxed (value, src->buttoninfo); 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; case ARG_AUDIO_LANGS: if (!gst_dvd_nav_src_is_open (src)) { g_value_set_string (value, ""); } else { uint8_t physical, logical; uint16_t lang_int; gchar langs[DVD_NAV_SRC_MAX_AUDIO_STREAMS * 3]; gchar *lang_ptr = langs; for (physical = 0; physical < DVD_NAV_SRC_MAX_AUDIO_STREAMS; physical++) { logical = dvdnav_get_audio_logical_stream (src->dvdnav, physical); lang_int = dvdnav_audio_stream_to_lang (src->dvdnav, logical); if (lang_int != 0xffff) { lang_ptr[0] = (lang_int >> 8) & 0xff; lang_ptr[1] = lang_int & 0xff; lang_ptr[2] = ' '; lang_ptr += 3; } } if (lang_ptr > langs) { /* Overwrite the space at the end. */ lang_ptr[-1] = '\0'; } else { langs[0] = '\0'; } g_value_set_string (value, langs); } break; case ARG_AUDIO_LANG: if (!gst_dvd_nav_src_is_open (src)) { g_value_set_string (value, ""); } else { uint8_t logical; uint16_t lang_int; gchar lang[3]; logical = dvdnav_get_active_audio_stream (src->dvdnav); lang_int = dvdnav_audio_stream_to_lang (src->dvdnav, logical); if (lang_int != 0xffff) { lang[0] = (lang_int >> 8) & 0xff; lang[1] = lang_int & 0xff; lang[2] = '\0'; g_value_set_string (value, lang); } else { g_value_set_string (value, ""); } } break; case ARG_SPU_LANGS: if (!gst_dvd_nav_src_is_open (src)) { g_value_set_string (value, ""); } else { uint8_t physical, logical; uint16_t lang_int; gchar langs[DVD_NAV_SRC_MAX_SPU_STREAMS * 3]; gchar *lang_ptr = langs; for (physical = 0; physical < DVD_NAV_SRC_MAX_SPU_STREAMS; physical++) { logical = dvdnav_get_spu_logical_stream (src->dvdnav, physical); lang_int = dvdnav_spu_stream_to_lang (src->dvdnav, logical); if (lang_int != 0xffff) { lang_ptr[0] = (lang_int >> 8) & 0xff; lang_ptr[1] = lang_int & 0xff; lang_ptr[2] = ' '; lang_ptr += 3; } } if (lang_ptr > langs) { /* Overwrite the space at the end. */ lang_ptr[-1] = '\0'; } else { langs[0] = '\0'; } g_value_set_string (value, langs); } break; case ARG_SPU_LANG: if (!gst_dvd_nav_src_is_open (src)) { g_value_set_string (value, ""); } else { uint8_t logical; uint16_t lang_int; gchar lang[3]; logical = dvdnav_get_active_spu_stream (src->dvdnav); lang_int = dvdnav_spu_stream_to_lang (src->dvdnav, logical); if (lang_int != 0xffff) { lang[0] = (lang_int >> 8) & 0xff; lang[1] = lang_int & 0xff; lang[2] = '\0'; g_value_set_string (value, lang); } else { g_value_set_string (value, ""); } } break; #endif default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } #if 0 static void gst_dvd_nav_src_set_clock (GstElement * element, GstClock * clock) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (element); src->clock = clock; } #endif /* update the time map when the title change */ static gint gst_dvd_nav_src_update_tmaps (GstDvdNavSrc * src) { int32_t title, part; title_info_t *info; gint title_set_nr, title_ttn; gint i; /* Reset stuffs */ src->use_tmaps = FALSE; src->title_tmap = NULL; /* FIXME: check if the title really changed, by now it's called on every * DVDNAV_CELL_CHANGE event. */ if (dvdnav_current_title_info (src->dvdnav, &title, &part) != DVDNAV_STATUS_OK) { GST_LOG_OBJECT (src, "Failed getting current title informations!"); return FALSE; } GST_LOG_OBJECT (src, "title = %d, part = %d", title, part); /* load the VTS information for the title set our title is in */ /* Close old vts file */ if (src->vts_file) { ifoClose (src->vts_file); src->vts_file = NULL; } /* There isn't a timemap for the menus */ if (title < 1) { GST_LOG_OBJECT (src, "Time map not available for menus"); return FALSE; } info = &src->tt_srpt->title[title - 1]; title_set_nr = info->title_set_nr; GST_LOG_OBJECT (src, "title_set_nr = %d", title_set_nr); title_ttn = info->vts_ttn; GST_LOG_OBJECT (src, "title_ttn= %d", title_ttn); src->vts_file = ifoOpen (src->dvd, title_set_nr); if (src->vts_file == NULL) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (_("Could not open DVD")), ("ifoOpen() failed: %s", g_strerror (errno))); return FALSE; } src->vts_tmapt = src->vts_file->vts_tmapt; src->vts_ptt_srpt = src->vts_file->vts_ptt_srpt; if (src->vts_file->vts_tmapt != NULL) { i = title_ttn - 1; if (i >= 0 && i < src->vts_tmapt->nr_of_tmaps) { src->title_tmap = &src->vts_tmapt->tmap[i]; GST_LOG_OBJECT (src, "Time map table number: %d", i); } else { src->title_tmap = NULL; GST_LOG_OBJECT (src, "Cannot find table number for title %d", title_ttn); return FALSE; } } /* Check that the max map entry sector size is >= then the length reported * by dvdnav_get_position, as looks like this function doesn't compute * correctly the pos and length values. */ guint32 pos; guint32 dvdnav_length; if (dvdnav_get_position (src->dvdnav, &pos, &dvdnav_length) != DVDNAV_STATUS_OK) { GST_WARNING_OBJECT (src, "Cannot get stream length by dvdnav, " "won't enable tmaps use as we cannot check if they're interaction with dvdnav is right"); return FALSE; } else { if (src->title_tmap) { int tmap_length; tmap_length = (src->title_tmap->map_ent[src->title_tmap-> nr_of_entries] & 0x7fffffff); if (tmap_length >= dvdnav_length) { GST_LOG_OBJECT (src, "Using time maps for seeking"); } else { GST_WARNING_OBJECT (src, "Time maps has max sector (%d) < than length (%d) reported by dvdnav: " "tmap problem or dvdnav bug?", dvdnav_length); } } } /* Dump all tmaps for title set for debugging */ 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: %d %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_LOG_OBJECT (src, "no vts_tmapt to dump"); return FALSE; } src->use_tmaps = TRUE; return TRUE; } /* Find sector from time using time map if available */ /* FIXME: do interpolation as in gst_dvd_nav_src_get_time_for_sector_tmap */ static gint gst_dvd_nav_src_get_sector_from_time_tmap (GstDvdNavSrc * src, GstClockTime ts) { gint sector, i; if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0) return -1; sector = 0; for (i = 0; i < src->title_tmap->nr_of_entries; ++i) { GstClockTime entry_time; entry_time = src->title_tmap->tmu * (i + 1) * GST_SECOND; if (entry_time <= ts) { sector = src->title_tmap->map_ent[i] & 0x7fffffff; } if (entry_time >= ts) { return sector; } } if (ts == 0) return 0; return -1; } /* Find time for sector using time map, does interpolation */ static GstClockTime gst_dvd_nav_src_get_time_for_sector_tmap (GstDvdNavSrc * src, guint sector) { gint i; guint prev_sector = 0; guint cur_sector = 0; GstClockTime target, diff; if (src->vts_tmapt == NULL || src->vts_tmapt->nr_of_tmaps == 0) { return GST_CLOCK_TIME_NONE; } for (i = 0; i < src->title_tmap->nr_of_entries; ++i) { prev_sector = cur_sector; cur_sector = src->title_tmap->map_ent[i] & 0x7fffffff; if (sector >= prev_sector && sector <= cur_sector) { target = src->title_tmap->tmu * i * GST_SECOND; if (i < src->title_tmap->nr_of_entries - 1) { diff = src->title_tmap->tmu * GST_SECOND * (sector - prev_sector) / (cur_sector - prev_sector); target += diff; } return target; } } if (sector == 0) return (GstClockTime) 0; return GST_CLOCK_TIME_NONE; } /* Find time for sector */ static GstClockTime gst_dvd_nav_src_get_time_for_sector (GstDvdNavSrc * src, guint sector) { GstClockTime time; GST_OBJECT_LOCK (src); if (src->use_tmaps) { time = gst_dvd_nav_src_get_time_for_sector_tmap (src, sector); if (time != GST_CLOCK_TIME_NONE) { GST_OBJECT_UNLOCK (src); return time; } } /* Fallback to average time calculation */ time = (GstClockTime) ((float) sector / src->sector_length * src->pgc_length); GST_OBJECT_UNLOCK (src); return time; } /* Find sector from time */ static GstClockTime gst_dvd_nav_src_get_sector_from_time (GstDvdNavSrc * src, GstClockTime time) { gint sector; GST_OBJECT_LOCK (src); if (src->use_tmaps) { sector = gst_dvd_nav_src_get_sector_from_time_tmap (src, time); if (sector >= 0) { GST_OBJECT_UNLOCK (src); return sector; } } /* Fallback to average sector calculation */ sector = (GstClockTime) ((float) time / src->pgc_length * src->sector_length); GST_OBJECT_UNLOCK (src); return sector; } static gboolean gst_dvd_nav_src_do_convert_query (GstDvdNavSrc * src, GstQuery * query) { GstFormat src_format, dest_format; gboolean ret = FALSE; gint64 src_val, dest_val = -1; gst_query_parse_convert (query, &src_format, &src_val, &dest_format, NULL); if (src_format == dest_format) { dest_val = src_val; ret = TRUE; goto done; } /* FIXME: handle also chapter format */ /* Formats to consider: TIME, DEFAULT, BYTES, title, chapter, sector. * Note: title and chapter are counted as starting from 0 here, just like * in the context of seek events. Another note: DEFAULT format is undefined */ if (src_format == GST_FORMAT_BYTES) { src_format = sector_format; src_val /= DVD_SECTOR_SIZE; } if (src_format == sector_format) { /* SECTOR => xyz */ if (dest_format == GST_FORMAT_TIME && src_val < G_MAXUINT) { dest_val = gst_dvd_nav_src_get_time_for_sector (src, src_val); ret = (dest_val >= 0); } else if (dest_format == GST_FORMAT_BYTES) { dest_val = src_val * DVD_SECTOR_SIZE; ret = TRUE; } else { ret = FALSE; } } else if (src_format == title_format) { /* TITLE => xyz */ if (dest_format == GST_FORMAT_TIME) { /* not really true, but we use this to trick the base source into * handling seeks in title-format for us (the source won't know that * we changed the title in this case) (changing titles should really * be done with an interface rather than a seek, but for now we're * stuck with this mechanism. Fix in 0.11) */ dest_val = (GstClockTime) 0; ret = TRUE; } else { ret = FALSE; } } else if (src_format == GST_FORMAT_TIME) { /* TIME => sectors */ if (dest_format == sector_format || dest_format == GST_FORMAT_BYTES) { dest_val = gst_dvd_nav_src_get_sector_from_time (src, src_val); ret = (dest_val >= 0); /* TIME => bytes */ if (dest_format == GST_FORMAT_BYTES) { dest_val *= DVD_VIDEO_LB_LEN; } } } else { ret = FALSE; } done: if (ret) { gst_query_set_convert (query, src_format, src_val, dest_format, dest_val); } return ret; } /* FIXME: handle also title, chapter, angle format */ static gboolean gst_dvd_nav_src_do_seek (GstBaseSrc * basesrc, GstSegment * s) { GstDvdNavSrc *src; src = GST_DVD_NAV_SRC (basesrc); /* On the first call of do_seek in gstbasesrc during gst_base_src_activate_push the dvdnav vm * isn't running. Return TRUE as the seek was done. */ if (src->first_seek == TRUE) { src->first_seek = FALSE; return TRUE; } 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) { gint sector = 0; /* Convert in sector format */ if (s->format == GST_FORMAT_BYTES) { sector = s->last_stop / DVD_SECTOR_SIZE; } else if (s->format == GST_FORMAT_TIME) { sector = gst_dvd_nav_src_get_sector_from_time (src, s->last_stop); } if (dvdnav_sector_search (src->dvdnav, sector, SEEK_SET) != DVDNAV_STATUS_OK) { GST_DEBUG_OBJECT (src, "seek to %s %d failed", gst_format_get_name (s->format), s->last_stop); return FALSE; } GST_LOG_OBJECT (src, "seek to %s %d ok", gst_format_get_name (s->format), s->last_stop); } else { g_return_val_if_reached (FALSE); } return TRUE; } static gboolean gst_dvd_nav_src_tca_seek (GstDvdNavSrc * src, gint title, gint chapter, gint angle) { int titles, chapters, curangle, angles; g_return_val_if_fail (src != NULL, FALSE); g_return_val_if_fail (src->dvdnav != NULL, FALSE); // g_return_val_if_fail (gst_dvd_nav_src_is_open (src), FALSE); /* Dont try to seek to track 0 - First Play program chain */ g_return_val_if_fail (src->title > 0, FALSE); GST_INFO_OBJECT (src, "seeking to %d/%d/%d", title, chapter, angle); /* Make sure our title number is valid */ if (dvdnav_get_number_of_titles (src->dvdnav, &titles) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "dvdnav_get_number_of_titles: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } GST_INFO_OBJECT (src, "there are %d titles on this DVD", titles); if (title < 1 || title > titles) { GST_ERROR_OBJECT (src, "invalid title %d", title); return FALSE; } /* Before we can get the number of chapters (programs) we need to call * dvdnav_title_play so that dvdnav_get_number_of_programs knows which title * to operate on (also needed to get the number of angles) */ /* FIXME: This is probably not necessary anymore! */ if (dvdnav_title_play (src->dvdnav, title) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "dvdnav_title_play: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } /* Make sure the chapter number is valid for this title */ if (dvdnav_get_number_of_parts (src->dvdnav, title, &chapters) != DVDNAV_STATUS_OK) { GST_ERROR ("dvdnav_get_number_of_programs: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } GST_INFO_OBJECT (src, "there are %d chapters in this title", chapters); if (chapter < 0 || chapter > chapters) { GST_ERROR_OBJECT (src, "invalid chapter %d", chapter); return FALSE; } /* Make sure the angle number is valid for this title */ if (dvdnav_get_angle_info (src->dvdnav, &curangle, &angles) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "dvdnav_get_angle_info: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } GST_INFO_OBJECT (src, "there are %d angles in this title", angles); if (angle < 1 || angle > angles) { GST_ERROR_OBJECT (src, "invalid angle %d", angle); return FALSE; } /* We've got enough info, time to open the title set data */ if (src->chapter == 0) { if (dvdnav_title_play (src->dvdnav, title) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "dvdnav_title_play: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } } else { if (dvdnav_part_play (src->dvdnav, title, chapter) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "dvdnav_part_play: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } } if (dvdnav_angle_change (src->dvdnav, angle) != DVDNAV_STATUS_OK) { GST_ERROR_OBJECT (src, "dvdnav_angle_change: %s", dvdnav_err_to_string (src->dvdnav)); return FALSE; } return TRUE; } static void gst_dvd_nav_src_update_streaminfo (GstDvdNavSrc * src) { /* FIXME: we should really use TAGS for this stuff, shouldn't we? */ #if 0 GstBaseSrc *bsrc = GST_BASE_SRC (src); GstCaps *caps; GstStructure *structure; gint64 value; caps = gst_caps_new_empty (); structure = gst_structure_empty_new ("application/x-gst-streaminfo"); gst_caps_append_structure (caps, structure); if (gst_dvd_nav_src_query_duration (bsrc, title_format, &value)) { gst_caps_set_simple (caps, "titles", G_TYPE_INT, value, NULL); } if (gst_dvd_nav_src_query_position (bsrc, title_format, &value)) { gst_caps_set_simple (caps, "title", G_TYPE_INT, value, NULL); } if (gst_dvd_nav_src_query_duration (bsrc, chapter_format, &value)) { gst_caps_set_simple (caps, "chapters", G_TYPE_INT, value, NULL); } if (gst_dvd_nav_src_query_position (bsrc, chapter_format, &value)) { gst_caps_set_simple (caps, "chapter", G_TYPE_INT, value, NULL); } if (gst_dvd_nav_src_query_duration (bsrc, angle_format, &value)) { gst_caps_set_simple (caps, "angles", G_TYPE_INT, value, NULL); } if (gst_dvd_nav_src_query_position (bsrc, angle_format, &value)) { gst_caps_set_simple (caps, "angle", G_TYPE_INT, value, NULL); } gst_caps_replace (&src->streaminfo, caps); gst_caps_unref (caps); g_object_notify (G_OBJECT (src), "streaminfo"); #endif } /* * Check for a new DVD domain area, and update the structure if * necessary. */ static void gst_dvd_nav_src_set_domain (GstDvdNavSrc * src) { GstDvdNavSrcDomainType domain; if (dvdnav_is_domain_fp (src->dvdnav)) { domain = GST_DVD_NAV_SRC_DOMAIN_FP; } else if (dvdnav_is_domain_vmgm (src->dvdnav)) { domain = GST_DVD_NAV_SRC_DOMAIN_VMGM; } else if (dvdnav_is_domain_vtsm (src->dvdnav)) { domain = GST_DVD_NAV_SRC_DOMAIN_VTSM; } else if (dvdnav_is_domain_vts (src->dvdnav)) { domain = GST_DVD_NAV_SRC_DOMAIN_VTS; } else { domain = GST_DVD_NAV_SRC_DOMAIN_UNKNOWN; } /* FIXME: We may send a signal if we have a new domain. */ src->domain = domain; } /* * Check for a new highlighted area, and send an spu highlight event if * necessary. */ static void gst_dvd_nav_src_update_highlight (GstDvdNavSrc * src, gboolean force) { int button = 0; pci_t *pci; dvdnav_highlight_area_t area; GstEvent *event; if (dvdnav_get_current_highlight (src->dvdnav, &button) != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (NULL), ("dvdnav_get_current_highlight: %s", dvdnav_err_to_string (src->dvdnav))); return; } pci = dvdnav_get_current_nav_pci (src->dvdnav); if ((button > pci->hli.hl_gi.btn_ns) || (button < 0)) { /* button is out of the range of possible buttons. */ button = 0; } if (!pci->hli.hl_gi.hli_ss) { /* Not in menu */ button = 0; } if (button == 0) { if (src->button != 0) { src->button = 0; gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_dvd_nav_src_make_dvd_event (src, "dvd-spu-reset-highlight", NULL, NULL)); } return; } if (dvdnav_get_highlight_area (pci, button, 0, &area) != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (NULL), ("dvdnav_get_highlight_area: %s", dvdnav_err_to_string (src->dvdnav))); return; } /* Check if we have a new button number, or a new highlight region. */ if (button != src->button || force || memcmp (&area, &(src->area), sizeof (dvdnav_highlight_area_t)) != 0) { memcpy (&(src->area), &area, sizeof (dvdnav_highlight_area_t)); event = gst_dvd_nav_src_make_dvd_event (src, "dvd-spu-highlight", "button", G_TYPE_INT, (gint) button, "palette", G_TYPE_INT, (gint) area.palette, "sx", G_TYPE_INT, (gint) area.sx, "sy", G_TYPE_INT, (gint) area.sy, "ex", G_TYPE_INT, (gint) area.ex, "ey", G_TYPE_INT, (gint) area.ey, NULL); if (src->button == 0) { /* When setting the button for the first time, take the timestamp into account. */ GST_EVENT_TIMESTAMP (event) = MPEGTIME_TO_GSTTIME (area.pts); } src->button = button; GST_DEBUG ("Sending dvd-spu-highlight for button %d", button); int ret = gst_pad_push_event (GST_BASE_SRC_PAD (src), event); GST_DEBUG ("End Sending dvd-spu-highlight for button %d, ret: %d", button, ret); } } static void gst_dvd_nav_src_user_op (GstDvdNavSrc * src, gint op) { pci_t *pci = dvdnav_get_current_nav_pci (src->dvdnav); GST_INFO_OBJECT (src, "user operation %d", op); /* Magic user_op ids */ switch (op) { case 0: /* None */ break; case 1: /* Upper */ if (dvdnav_upper_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) { goto naverr; } break; case 2: /* Lower */ if (dvdnav_lower_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) { goto naverr; } break; case 3: /* Left */ if (dvdnav_left_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) { goto naverr; } break; case 4: /* Right */ if (dvdnav_right_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) { goto naverr; } break; case 5: /* Activate */ if (dvdnav_button_activate (src->dvdnav, pci) != DVDNAV_STATUS_OK) { goto naverr; } break; case 6: /* GoUp */ if (dvdnav_go_up (src->dvdnav) != DVDNAV_STATUS_OK) { goto naverr; } break; case 7: /* TopPG */ if (dvdnav_top_pg_search (src->dvdnav) != DVDNAV_STATUS_OK) { goto naverr; } break; case 8: /* PrevPG */ if (dvdnav_prev_pg_search (src->dvdnav) != DVDNAV_STATUS_OK) { goto naverr; } break; case 9: /* NextPG */ if (dvdnav_next_pg_search (src->dvdnav) != DVDNAV_STATUS_OK) { goto naverr; } break; case 10: /* Menu - Title */ if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Title) != DVDNAV_STATUS_OK) { goto naverr; } break; case 11: /* Menu - Root */ if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Root) != DVDNAV_STATUS_OK) { goto naverr; } break; case 12: /* Menu - Subpicture */ if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Subpicture) != DVDNAV_STATUS_OK) { goto naverr; } break; case 13: /* Menu - Audio */ if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Audio) != DVDNAV_STATUS_OK) { goto naverr; } break; case 14: /* Menu - Angle */ if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Angle) != DVDNAV_STATUS_OK) { goto naverr; } break; case 15: /* Menu - Part */ if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Part) != DVDNAV_STATUS_OK) { goto naverr; } break; case 50: /* Select button */ { int32_t button; dvdnav_get_current_highlight (src->dvdnav, &button); if (button == 0) { for (button = 1; button <= 36; button++) { if (dvdnav_button_select (src->dvdnav, pci, button) == DVDNAV_STATUS_OK) { break; } } dvdnav_get_current_highlight (src->dvdnav, &button); } GST_INFO_OBJECT (src, "Selected button: %d", button); } break; } return; naverr: GST_WARNING_OBJECT (src, "user op %d failure: %s", op, dvdnav_err_to_string (src->dvdnav)); } #ifndef GST_DISABLE_GST_DEBUG static const gchar * dvdnav_get_event_name (int event) { switch (event) { case DVDNAV_BLOCK_OK: return "DVDNAV_BLOCK_OK"; case DVDNAV_NOP: return "DVDNAV_NOP"; case DVDNAV_STILL_FRAME: return "DVDNAV_STILL_FRAME"; case DVDNAV_WAIT: return "DVDNAV_WAIT"; case DVDNAV_SPU_STREAM_CHANGE: return "DVDNAV_SPU_STREAM_CHANGE"; case DVDNAV_AUDIO_STREAM_CHANGE: return "DVDNAV_AUDIO_STREAM_CHANGE"; case DVDNAV_VTS_CHANGE: return "DVDNAV_VTS_CHANGE"; case DVDNAV_CELL_CHANGE: return "DVDNAV_CELL_CHANGE"; case DVDNAV_NAV_PACKET: return "DVDNAV_NAV_PACKET"; case DVDNAV_STOP: return "DVDNAV_STOP"; case DVDNAV_HIGHLIGHT: return "DVDNAV_HIGHLIGHT"; case DVDNAV_SPU_CLUT_CHANGE: return "DVDNAV_SPU_CLUT_CHANGE"; case DVDNAV_HOP_CHANNEL: return "DVDNAV_HOP_CHANNEL"; default: break; } return "UNKNOWN"; } static const gchar * dvdnav_get_read_domain_name (dvd_read_domain_t domain) { switch (domain) { case DVD_READ_INFO_FILE: return "DVD_READ_INFO_FILE"; case DVD_READ_INFO_BACKUP_FILE: return "DVD_READ_INFO_BACKUP_FILE"; case DVD_READ_MENU_VOBS: return "DVD_READ_MENU_VOBS"; case DVD_READ_TITLE_VOBS: return "DVD_READ_TITLE_VOBS"; default: break; } return "UNKNOWN"; } static void gst_dvd_nav_src_print_event (GstDvdNavSrc * src, guint8 * data, int event, int len) { g_return_if_fail (src != NULL); g_return_if_fail (GST_IS_DVD_NAV_SRC (src)); GST_DEBUG_OBJECT (src, "dvdnavsrc (%p): event: %s", src, dvdnav_get_event_name (event)); switch (event) { case DVDNAV_BLOCK_OK: break; case DVDNAV_NOP: break; case DVDNAV_STILL_FRAME:{ dvdnav_still_event_t *event = (dvdnav_still_event_t *) data; GST_DEBUG_OBJECT (src, " still frame: %d seconds", event->length); break; } case DVDNAV_WAIT: break; case DVDNAV_SPU_STREAM_CHANGE:{ dvdnav_spu_stream_change_event_t *event; event = (dvdnav_spu_stream_change_event_t *) data; GST_DEBUG_OBJECT (src, " physical_wide: %d", event->physical_wide); GST_DEBUG_OBJECT (src, " physical_letterbox: %d", event->physical_letterbox); GST_DEBUG_OBJECT (src, " physical_pan_scan: %d", event->physical_pan_scan); GST_DEBUG_OBJECT (src, " logical: %d", event->logical); break; } case DVDNAV_AUDIO_STREAM_CHANGE:{ dvdnav_audio_stream_change_event_t *event = (dvdnav_audio_stream_change_event_t *) data; GST_DEBUG_OBJECT (src, " physical: %d", event->physical); GST_DEBUG_OBJECT (src, " logical: %d", event->logical); break; } case DVDNAV_VTS_CHANGE:{ dvdnav_vts_change_event_t *event = (dvdnav_vts_change_event_t *) data; GST_DEBUG_OBJECT (src, " old_vtsN: %d", event->old_vtsN); GST_DEBUG_OBJECT (src, " old_domain: %s", dvdnav_get_read_domain_name (event->old_domain)); GST_DEBUG_OBJECT (src, " new_vtsN: %d", event->new_vtsN); GST_DEBUG_OBJECT (src, " new_domain: %s", dvdnav_get_read_domain_name (event->new_domain)); break; } case DVDNAV_CELL_CHANGE: break; case DVDNAV_NAV_PACKET:{ /* FIXME: Print something relevant here. */ break; } case DVDNAV_STOP: break; case DVDNAV_HIGHLIGHT:{ dvdnav_highlight_event_t *event = (dvdnav_highlight_event_t *) data; GST_DEBUG_OBJECT (src, " display: %s", event->display == 0 ? "hide" : (event->display == 1 ? "show" : "unknown")); if (event->display == 1) { GST_DEBUG_OBJECT (src, " palette: %08x", event->palette); GST_DEBUG_OBJECT (src, " coords (%u, %u) - (%u, %u)", event->sx, event->sy, event->ex, event->ey); GST_DEBUG_OBJECT (src, " pts: %u", event->pts); GST_DEBUG_OBJECT (src, " button: %u", event->buttonN); } break; } case DVDNAV_SPU_CLUT_CHANGE: break; case DVDNAV_HOP_CHANNEL: break; default:{ GST_DEBUG_OBJECT (src, " event id: %d", event); break; } } } #endif /* GST_DISABLE_GST_DEBUG */ static GstEvent * gst_dvd_nav_src_make_dvd_event (GstDvdNavSrc * src, const gchar * event_name, const gchar * firstfield, ...) { GstEvent *event; GstStructure *structure; va_list varargs; g_return_val_if_fail (event_name != NULL, NULL); /* Create a structure with the given fields. */ va_start (varargs, firstfield); structure = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING, event_name, NULL); gst_structure_set_valist (structure, firstfield, varargs); va_end (varargs); /* Create the DVD event and put the structure into it. */ event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_OOB, structure); GST_LOG_OBJECT (src, "created event %" GST_PTR_FORMAT, event); return event; } static void gst_dvd_nav_src_structure_set_uint64 (GstStructure * structure, const gchar * name, guint64 val) { GValue gvalue = { 0, }; g_value_init (&gvalue, G_TYPE_UINT64); g_value_set_uint64 (&gvalue, val); gst_structure_set_value (structure, name, &gvalue); } static void gst_dvd_nav_src_push_dvd_nav_packet_event (GstDvdNavSrc * src, const pci_t * pci) { GstEvent *event; GstStructure *structure; /* Build the event structure. */ structure = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING, "dvd-nav-packet", NULL); gst_dvd_nav_src_structure_set_uint64 (structure, "start_ptm", MPEGTIME_TO_GSTTIME (pci->pci_gi.vobu_s_ptm)); gst_dvd_nav_src_structure_set_uint64 (structure, "end_ptm", MPEGTIME_TO_GSTTIME (pci->pci_gi.vobu_e_ptm)); gst_dvd_nav_src_structure_set_uint64 (structure, "cell_start", src->cell_start); gst_dvd_nav_src_structure_set_uint64 (structure, "pg_start", src->pg_start); /* Create the DVD event and put the structure into it. */ event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, structure); GST_LOG_OBJECT (src, "pushing nav packet event %" GST_PTR_FORMAT, event); gst_pad_push_event (GST_BASE_SRC_PAD (src), event); } static void gst_dvd_nav_src_push_clut_change_event (GstDvdNavSrc * src, const guint32 * clut) { GstEvent *event; GstStructure *structure; gchar name[16]; int 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++) { sprintf (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. */ event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, structure); GST_LOG_OBJECT (src, "pushing clut change event %" GST_PTR_FORMAT, event); gst_pad_push_event (GST_BASE_SRC_PAD (src), event); } /* Use libdvdread to read and cache info from the IFO file about * streams in each VTS */ static gboolean read_vts_info (GstDvdNavSrc * src) { dvd_reader_t *dvdi; ifo_handle_t *ifo; gint i; gint n_vts; if (src->vts_attrs) { g_array_free (src->vts_attrs, TRUE); src->vts_attrs = NULL; } dvdi = DVDOpen (src->device); if (!dvdi) return FALSE; ifo = ifoOpen (dvdi, 0); if (!ifo) { GST_ERROR ("Can't open VMG info"); return FALSE; } n_vts = ifo->vts_atrt->nr_of_vtss; memcpy (&src->vmgm_attr, ifo->vmgi_mat, sizeof (vmgi_mat_t)); ifoClose (ifo); GST_DEBUG ("Reading IFO info for %d VTSs", n_vts); src->vts_attrs = g_array_sized_new (FALSE, TRUE, sizeof (vtsi_mat_t), n_vts + 1); if (!src->vts_attrs) return FALSE; g_array_set_size (src->vts_attrs, n_vts + 1); for (i = 1; i <= n_vts; i++) { ifo = ifoOpen (dvdi, i); if (!ifo) { GST_ERROR ("Can't open VTS %d", i); return FALSE; } GST_DEBUG ("VTS %d, Menu has %d audio %d subpictures. " "Title has %d and %d", i, ifo->vtsi_mat->nr_of_vtsm_audio_streams, ifo->vtsi_mat->nr_of_vtsm_subp_streams, ifo->vtsi_mat->nr_of_vts_audio_streams, ifo->vtsi_mat->nr_of_vts_subp_streams); memcpy (&g_array_index (src->vts_attrs, vtsi_mat_t, i), ifo->vtsi_mat, sizeof (vtsi_mat_t)); ifoClose (ifo); } DVDClose (dvdi); return TRUE; } static gboolean gst_dvd_nav_src_push_titlelang_event (GstDvdNavSrc * src) { vtsi_mat_t *vts_attr; audio_attr_t *a_attrs; subp_attr_t *s_attrs; gint n_audio, n_subp; GstStructure *s; GstEvent *e; gint i; gchar lang_code[3] = { '\0', '\0', '\0' }; gchar *t; if (src->vts_attrs == NULL || src->cur_vts >= src->vts_attrs->len) { if (src->vts_attrs) GST_ERROR ("No stream info for VTS %d (have %d)", src->cur_vts, src->vts_attrs->len); else GST_ERROR ("No stream info"); return FALSE; } if (src->domain == GST_DVD_NAV_SRC_DOMAIN_VMGM) { vts_attr = NULL; a_attrs = &src->vmgm_attr.vmgm_audio_attr; n_audio = MIN (1, src->vmgm_attr.nr_of_vmgm_audio_streams); s_attrs = &src->vmgm_attr.vmgm_subp_attr; n_subp = MIN (1, src->vmgm_attr.nr_of_vmgm_subp_streams); } else { vts_attr = &g_array_index (src->vts_attrs, vtsi_mat_t, src->cur_vts); a_attrs = vts_attr->vts_audio_attr; n_audio = vts_attr->nr_of_vts_audio_streams; s_attrs = vts_attr->vts_subp_attr; n_subp = vts_attr->nr_of_vts_subp_streams; } /* build event */ s = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING, "dvd-lang-codes", NULL); e = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM, s); /* audio */ for (i = 0; i < n_audio; i++) { const audio_attr_t *a = a_attrs + 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); GST_DEBUG ("Audio stream %d is format %d", i, (int) a->audio_format); 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); GST_DEBUG ("Audio stream %d is language %s", i, lang_code); } else GST_DEBUG ("Audio stream %d - no language", i, lang_code); } /* subtitle */ for (i = 0; i < n_subp; i++) { const subp_attr_t *u = s_attrs + i; t = g_strdup_printf ("subtitle-%d-language", i); if (u->type) { 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); } else { gst_structure_set (s, t, G_TYPE_STRING, "MENU", NULL); } g_free (t); GST_DEBUG ("Subtitle stream %d is language %s", i, lang_code[0] ? lang_code : "NONE"); } gst_pad_push_event (GST_BASE_SRC_PAD (src), e); return TRUE; } static GstFlowReturn gst_dvd_nav_src_process_next_block (GstDvdNavSrc * src, GstBuffer ** p_buf) { dvdnav_status_t navret; guint8 *data; gint event, len; if (src->cur_buf == NULL) src->cur_buf = gst_buffer_new_and_alloc (DVD_VIDEO_LB_LEN); data = GST_BUFFER_DATA (src->cur_buf); len = GST_BUFFER_SIZE (src->cur_buf); navret = dvdnav_get_next_block (src->dvdnav, data, &event, &len); if (navret != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("dvdnav_get_next_block: %s", dvdnav_err_to_string (src->dvdnav))); return GST_FLOW_ERROR; } /* If the next block is not DVDNAV_STILL_FRAME we can seek */ if (event != DVDNAV_STILL_FRAME) { src->still_frame = FALSE; } switch (event) { case DVDNAV_NOP: break; case DVDNAV_BLOCK_OK:{ *p_buf = src->cur_buf; src->cur_buf = NULL; break; } case DVDNAV_STILL_FRAME:{ src->still_frame = TRUE; dvdnav_still_event_t *info = (dvdnav_still_event_t *) data; gst_dvd_nav_src_print_event (src, data, event, len); if (src->pause_mode == GST_DVD_NAV_SRC_PAUSE_OFF) { gst_dvd_nav_src_print_event (src, data, event, len); /* We just saw a still frame. Start a pause now. */ if (info->length == 0xff) { GST_INFO_OBJECT (src, "starting unlimited pause"); src->pause_mode = GST_DVD_NAV_SRC_PAUSE_UNLIMITED; src->pause_remain = -1; } else { src->pause_mode = GST_DVD_NAV_SRC_PAUSE_LIMITED; src->pause_remain = info->length * GST_SECOND; gint64 val; gst_dvd_nav_src_query_position (src, GST_FORMAT_TIME, &val); GST_INFO_OBJECT (src, "starting limited pause: %d seconds at %" GST_TIME_FORMAT, info->length, GST_TIME_ARGS (val)); } /* For the moment, send the first empty event to let everyone know that we are displaying a still frame. Subsequent calls to this function will take care of the rest of the pause. */ GST_DEBUG_OBJECT (src, "sending still frame event"); gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_dvd_nav_src_make_dvd_event (src, "dvd-spu-still-frame", NULL, NULL)); break; } if (src->pause_mode == GST_DVD_NAV_SRC_PAUSE_UNLIMITED || src->pause_remain > 0) { GST_DEBUG_OBJECT (src, "sleeping %d during still frame", GST_DVD_NAV_SRC_PAUSE_INTERVAL); GstClock *system_clock = gst_system_clock_obtain (); GstClockTime cur_time = gst_clock_get_internal_time (system_clock); GstClockID id = gst_clock_new_single_shot_id (system_clock, cur_time + GST_DVD_NAV_SRC_PAUSE_INTERVAL); gst_clock_id_wait (id, NULL); gst_clock_id_unref (id); if (src->pause_mode == GST_DVD_NAV_SRC_PAUSE_LIMITED) { if (src->pause_remain < GST_DVD_NAV_SRC_PAUSE_INTERVAL) src->pause_remain = 0; else src->pause_remain -= GST_DVD_NAV_SRC_PAUSE_INTERVAL; } /* If pause isn't finished, discont because time isn't actually * advancing */ if (src->pause_mode == GST_DVD_NAV_SRC_PAUSE_UNLIMITED || src->pause_remain > 0) break; } else { /* We reached the end of the pause. */ src->pause_mode = GST_DVD_NAV_SRC_PAUSE_OFF; if (dvdnav_still_skip (src->dvdnav) != DVDNAV_STATUS_OK) { GST_WARNING_OBJECT (src, "dvdnav_still_skip failed: %s", dvdnav_err_to_string (src->dvdnav)); } /* Flush to ensure that data after the wait is played correctly */ src->need_flush = TRUE; } break; } case DVDNAV_WAIT:{ /* was commented out already: */ #if 0 GstEvent *event; /* FIXME: We should really wait here until the fifos are empty, but I have no idea how to do that. In the mean time, just clean the wait state. */ GST_INFO_OBJECT (src, "sending wait"); gst_element_wait (GST_ELEMENT (src), gst_element_get_time (GST_ELEMENT (src)) + 1.5 * GST_SECOND); #endif if (dvdnav_wait_skip (src->dvdnav) != DVDNAV_STATUS_OK) { GST_WARNING_OBJECT (src, "dvdnav_wait_skip failed: %s", dvdnav_err_to_string (src->dvdnav)); } /* was commented out already: */ #if 0 event = gst_event_new_filler (); send_data = GST_DATA (event); #endif break; } case DVDNAV_STOP:{ GST_INFO_OBJECT (src, "stop - EOS"); return GST_FLOW_UNEXPECTED; } case DVDNAV_CELL_CHANGE:{ dvdnav_cell_change_event_t *event = (dvdnav_cell_change_event_t *) data; src->pgc_length = MPEGTIME_TO_GSTTIME (event->pgc_length); src->cell_start = MPEGTIME_TO_GSTTIME (event->cell_start); src->pg_start = MPEGTIME_TO_GSTTIME (event->pg_start); GST_LOG_OBJECT (src, "New cell. PGC Len %" GST_TIME_FORMAT " cell_start %" GST_TIME_FORMAT ", pg_start %" GST_TIME_FORMAT, GST_TIME_ARGS (src->pgc_length), GST_TIME_ARGS (src->cell_start), GST_TIME_ARGS (src->pg_start)); /* Update the current length in sectors */ guint32 pos; if (dvdnav_get_position (src->dvdnav, &pos, &src->sector_length) != DVDNAV_STATUS_OK) GST_WARNING_OBJECT (src, "Cannot get new stream length after DVDNAV_CELL_CHANGE"); /* Update the time maps */ gst_dvd_nav_src_update_tmaps (src); gst_dvd_nav_src_update_streaminfo (src); break; } case DVDNAV_NAV_PACKET:{ pci_t *pci = dvdnav_get_current_nav_pci (src->dvdnav); /* Check for forced buttons. */ if (pci->hli.hl_gi.hli_ss == 1) { GST_LOG_OBJECT (src, "menu ahead"); if (pci->hli.hl_gi.fosl_btnn > 0) { GST_DEBUG_OBJECT (src, "forced button"); dvdnav_button_select (src->dvdnav, pci, pci->hli.hl_gi.fosl_btnn); } } gst_dvd_nav_src_update_highlight (src, FALSE); /* Send a dvd nav packet event. */ gst_dvd_nav_src_push_dvd_nav_packet_event (src, pci); /* The NAV packet contains also data, so send it */ *p_buf = src->cur_buf; src->cur_buf = NULL; break; } case DVDNAV_SPU_CLUT_CHANGE:{ /* Does this work on 64-bit/big-endian machines? (tpm) - * Should do! (jan) */ gst_dvd_nav_src_push_clut_change_event (src, (const guint32 *) data); break; } case DVDNAV_VTS_CHANGE:{ dvdnav_vts_change_event_t *event = (dvdnav_vts_change_event_t *) data; gst_dvd_nav_src_set_domain (src); if (src->domain == GST_DVD_NAV_SRC_DOMAIN_VMGM) src->cur_vts = 0; else src->cur_vts = event->new_vtsN; /* FIXME */ #if 0 gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_discontinuous (FALSE, GST_FORMAT_UNDEFINED)); #endif if (src->domain == GST_DVD_NAV_SRC_DOMAIN_VTSM || src->domain == GST_DVD_NAV_SRC_DOMAIN_VTS || src->domain == GST_DVD_NAV_SRC_DOMAIN_VMGM) { if (!gst_dvd_nav_src_push_titlelang_event (src)) { GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (_("Invalid title information on DVD.")), GST_ERROR_SYSTEM); } } gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_dvd_nav_src_make_dvd_event (src, "dvd-vts-change", "domain", G_TYPE_INT, (gint) src->domain, NULL)); break; } case DVDNAV_AUDIO_STREAM_CHANGE:{ dvdnav_audio_stream_change_event_t *info; gint phys; info = (dvdnav_audio_stream_change_event_t *) data; phys = info->physical; gst_dvd_nav_src_print_event (src, data, event, len); if (phys < 0 || phys > GST_DVD_NAV_SRC_MAX_AUDIO_STREAMS) { phys = -1; } if (phys == src->audio_phys && dvdnav_get_active_audio_stream (src->dvdnav) == src->audio_log) { /* Audio state hasn't changed. */ break; } src->audio_phys = phys; src->audio_log = dvdnav_get_active_audio_stream (src->dvdnav); gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_dvd_nav_src_make_dvd_event (src, "dvd-audio-stream-change", "physical", G_TYPE_INT, (gint) src->audio_phys, "logical", G_TYPE_INT, (gint) src->audio_log, NULL)); break; } case DVDNAV_SPU_STREAM_CHANGE:{ dvdnav_spu_stream_change_event_t *info; gint phys; info = (dvdnav_spu_stream_change_event_t *) data; /* FIXME: Which type of physical stream to use here should be configurable through a property. We take widescreen for the moment. */ phys = info->physical_wide; gst_dvd_nav_src_print_event (src, data, event, len); if (phys < 0 || phys > GST_DVD_NAV_SRC_MAX_SPU_STREAMS) { phys = -1; } if (phys == src->subp_phys && dvdnav_get_active_spu_stream (src->dvdnav) == src->subp_log) { /* Subpicture state hasn't changed. */ break; } src->subp_phys = phys; src->subp_log = dvdnav_get_active_spu_stream (src->dvdnav); gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_dvd_nav_src_make_dvd_event (src, "dvd-spu-stream-change", "physical", G_TYPE_INT, (gint) phys, "logical", G_TYPE_INT, (gint) dvdnav_get_active_spu_stream (src->dvdnav), NULL)); break; } case DVDNAV_HIGHLIGHT:{ gst_dvd_nav_src_print_event (src, data, event, len); gst_dvd_nav_src_update_highlight (src, FALSE); break; } case DVDNAV_HOP_CHANNEL:{ gst_dvd_nav_src_print_event (src, data, event, len); src->button = 0; src->pause_mode = GST_DVD_NAV_SRC_PAUSE_OFF; /* If seeking the flush is already sent by the basesrc parent class */ if (!src->seek_pending) src->need_flush = TRUE; /* was commented out already: */ /* send_data = GST_DATA (gst_event_new_flush ()); */ break; } default: g_error ("dvdnavsrc: Unknown dvdnav event %d", event); break; } return GST_FLOW_OK; } static GstFlowReturn gst_dvd_nav_src_create (GstPushSrc * pushsrc, GstBuffer ** p_buf) { GstFlowReturn ret; GstDvdNavSrc *src; src = GST_DVD_NAV_SRC (pushsrc); if (src->new_seek) { gst_dvd_nav_src_tca_seek (src, src->title, src->chapter, src->angle); src->new_seek = FALSE; } *p_buf = NULL; /* Loop processing blocks until there is data to send. */ do { if (src->need_flush) { if (src->pause_mode != GST_DVD_NAV_SRC_PAUSE_OFF) { if (dvdnav_still_skip (src->dvdnav) != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (NULL), ("dvdnav_still_skip: %s", dvdnav_err_to_string (src->dvdnav))); return GST_FLOW_ERROR; } src->pause_mode = GST_DVD_NAV_SRC_PAUSE_OFF; } src->need_flush = FALSE; GST_INFO_OBJECT (src, "sending flush"); gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_flush_start ()); gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_flush_stop ()); gst_dvd_nav_src_update_highlight (src, TRUE); } ret = gst_dvd_nav_src_process_next_block (src, p_buf); } while (ret == GST_FLOW_OK && *p_buf == NULL); src->seek_pending = FALSE; return ret; } static gboolean gst_dvd_nav_src_start (GstBaseSrc * basesrc) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (basesrc); GstTagList *tags; const char *title_str; if (!read_vts_info (src)) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (_("Could not read title information for DVD.")), GST_ERROR_SYSTEM); return FALSE; } /* Load the video manager to find out the information about the titles */ src->dvd = DVDOpen (src->device); if (!src->dvd) return FALSE; GST_DEBUG_OBJECT (src, "Loading VMG info"); if (!(src->vmg_file = ifoOpen (src->dvd, 0))) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (_("Could not open DVD")), ("ifoOpen() failed: %s", g_strerror (errno))); return FALSE; } src->tt_srpt = src->vmg_file->tt_srpt; if (dvdnav_open (&src->dvdnav, src->device) != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), (_("Failed to open DVD device '%s'."), src->device)); return FALSE; } if (dvdnav_set_PGC_positioning_flag (src->dvdnav, 1) != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, LIBRARY, FAILED, (_("Failed to set PGC based seeking.")), GST_ERROR_SYSTEM); return FALSE; } /* Read the first block before seeking to force a libdvdnav internal * call to vm_start, otherwise it ignores our seek position. * This happens because vm_start sets the domain to the first-play (FP) * domain, overriding any other title that has been set. * Track/chapter setting used to work, but libdvdnav has delayed the call * to vm_start from _open, to _get_block. * FIXME: But, doing it this way has problems too, as there is no way to * get back to the FP domain. * Maybe we could title==0 to mean FP domain, and not do this read & seek. * If title subsequently gets set to 0, we would need to dvdnav_close * followed by dvdnav_open to get back to the FP domain. * Since we dont currently support seeking by setting the title/chapter/angle * after opening, we'll forget about close/open for now, and just do the * title==0 thing. */ src->title = src->uri_title; src->chapter = src->uri_chapter; src->angle = src->uri_angle; if (src->title > 0) { dvdnav_status_t ret; guint8 buf[DVD_SECTOR_SIZE]; gint event, buflen = sizeof (buf); ret = dvdnav_get_next_block (src->dvdnav, buf, &event, &buflen); if (ret != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("dvdnav_get_next_block: %s", dvdnav_err_to_string (src->dvdnav))); return FALSE; } gst_dvd_nav_src_print_event (src, buf, event, buflen); if (!gst_dvd_nav_src_tca_seek (src, src->title, src->chapter, src->angle)) { return FALSE; } } tags = gst_tag_list_new (); if (dvdnav_get_title_string (src->dvdnav, &title_str) == DVDNAV_STATUS_OK) { gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_TITLE, title_str, NULL); } if (tags && gst_structure_n_fields ((GstStructure *) tags) > 0) { gst_element_found_tags (GST_ELEMENT (src), tags); } src->streaminfo = NULL; src->use_tmaps = FALSE; src->first_seek = TRUE; return TRUE; } static gboolean gst_dvd_nav_src_stop (GstBaseSrc * basesrc) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (basesrc); if (src->dvdnav && dvdnav_close (src->dvdnav) != DVDNAV_STATUS_OK) { GST_ELEMENT_ERROR (src, RESOURCE, CLOSE, (NULL), ("dvdnav_close failed: %s", dvdnav_err_to_string (src->dvdnav))); return FALSE; } /* Close old vts file if opened */ if (src->vts_file) ifoClose (src->vts_file); /* Close the video manager */ ifoClose (src->vmg_file); DVDClose (src->dvd); return TRUE; } static gboolean gst_dvd_nav_src_handle_navigation_event (GstDvdNavSrc * src, GstEvent * event) { const GstStructure *structure; const gchar *event_type; structure = gst_event_get_structure (event); event_type = gst_structure_get_string (structure, "event"); if (strcmp (event_type, "key-press") == 0) { const gchar *key = gst_structure_get_string (structure, "key"); if (key == NULL) return TRUE; if (g_str_equal (key, "Return")) { dvdnav_button_activate (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav)); } else if (g_str_equal (key, "Left")) { dvdnav_left_button_select (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav)); } else if (g_str_equal (key, "Right")) { dvdnav_right_button_select (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav)); } else if (g_str_equal (key, "Up")) { dvdnav_upper_button_select (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav)); } else if (g_str_equal (key, "Down")) { dvdnav_lower_button_select (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav)); } else if (g_str_equal (key, "m")) { dvdnav_menu_call (src->dvdnav, DVD_MENU_Escape); } else if (g_str_equal (key, "t")) { dvdnav_menu_call (src->dvdnav, DVD_MENU_Title); } else if (g_str_equal (key, "r")) { dvdnav_menu_call (src->dvdnav, DVD_MENU_Root); } else if (g_str_equal (key, "comma")) { gint title = 0; gint part = 0; if (dvdnav_current_title_info (src->dvdnav, &title, &part) && title > 0 && part > 1) { dvdnav_part_play (src->dvdnav, title, part - 1); } } else if (g_str_equal (key, "period")) { gint title = 0; gint part = 0; if (dvdnav_current_title_info (src->dvdnav, &title, &part) && title > 0) { dvdnav_part_play (src->dvdnav, title, part + 1); } } GST_DEBUG ("dvdnavsrc got a keypress: %s", key); } else if (strcmp (event_type, "mouse-move") == 0) { gdouble x, y; gst_structure_get_double (structure, "pointer_x", &x); gst_structure_get_double (structure, "pointer_y", &y); dvdnav_mouse_select (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav), (int) x, (int) y); gst_dvd_nav_src_update_highlight (src, FALSE); } else if (strcmp (event_type, "mouse-button-release") == 0) { gdouble x, y; gst_structure_get_double (structure, "pointer_x", &x); gst_structure_get_double (structure, "pointer_y", &y); GST_DEBUG_OBJECT (src, "Got click at %g, %g", x, y); dvdnav_mouse_activate (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav), (int) x, (int) y); } return TRUE; } /* FIXME: handle also angle format */ static gboolean gst_dvd_nav_src_handle_seek_event (GstDvdNavSrc * src, GstEvent * event) { GstSeekFlags flags; GstSeekType cur_type, end_type; gint64 new_off; GstFormat format; gdouble rate; gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &new_off, &end_type, NULL); /* Cannot seek during another seek */ if (src->seek_pending) { GST_WARNING_OBJECT (src, "Cannot seek during another seek"); return FALSE; } /* If we are in a still frame we cannot seek */ if (src->still_frame) { GST_WARNING_OBJECT (src, "Cannot seek during a still frame"); return FALSE; } 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 != 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; } src->seek_pending = TRUE; return GST_BASE_SRC_CLASS (parent_class)->event (GST_BASE_SRC (src), event); } /* FIXME: please remove me, I use disk space without a reason. thanks. */ #if 0 static gboolean gst_dvd_nav_src_handle_seek_event (GstDvdNavSrc * src, GstEvent * event) { gint64 offset; gint format; int titles, title, new_title; int parts, part, new_part; int angles, angle, new_angle; int origin; guint32 curoff, len; format = GST_EVENT_SEEK_FORMAT (event); offset = GST_EVENT_SEEK_OFFSET (event); /* Disallow seek before the DVD VM has started or if we haven't finished a * previous seek yet */ if (dvdnav_get_position (src->dvdnav, &curoff, &len) != DVDNAV_STATUS_OK || src->seek_pending) goto error; GST_DEBUG_OBJECT (src, "Seeking to %lld, format %d, method %d\n", offset, format, GST_EVENT_SEEK_METHOD (event)); switch (format) { case GST_FORMAT_BYTES: switch (GST_EVENT_SEEK_METHOD (event)) { case GST_SEEK_METHOD_SET: origin = SEEK_SET; src->pending_offset = offset; break; case GST_SEEK_METHOD_CUR: origin = SEEK_CUR; src->pending_offset = curoff + offset; break; case GST_SEEK_METHOD_END: origin = SEEK_END; src->pending_offset = len + offset; break; default: goto error; } if (dvdnav_sector_search (src->dvdnav, (offset / DVD_SECTOR_SIZE), origin) != DVDNAV_STATUS_OK) { goto error; } break; default: if (format == sector_format) { switch (GST_EVENT_SEEK_METHOD (event)) { case GST_SEEK_METHOD_SET: origin = SEEK_SET; break; case GST_SEEK_METHOD_CUR: origin = SEEK_CUR; break; case GST_SEEK_METHOD_END: origin = SEEK_END; break; default: goto error; } if (dvdnav_sector_search (src->dvdnav, offset, origin) != DVDNAV_STATUS_OK) { goto error; } } else if (format == title_format) { if (dvdnav_current_title_info (src->dvdnav, &title, &part) != DVDNAV_STATUS_OK) { goto error; } switch (GST_EVENT_SEEK_METHOD (event)) { case GST_SEEK_METHOD_SET: new_title = offset; break; case GST_SEEK_METHOD_CUR: new_title = title + offset; break; case GST_SEEK_METHOD_END: if (dvdnav_get_number_of_titles (src->dvdnav, &titles) != DVDNAV_STATUS_OK) { goto error; } new_title = titles + offset; break; default: goto error; } if (dvdnav_title_play (src->dvdnav, new_title) != DVDNAV_STATUS_OK) { goto error; } } else if (format == chapter_format) { if (dvdnav_current_title_info (src->dvdnav, &title, &part) != DVDNAV_STATUS_OK) { goto error; } switch (GST_EVENT_SEEK_METHOD (event)) { case GST_SEEK_METHOD_SET: new_part = offset; break; case GST_SEEK_METHOD_CUR: new_part = part + offset; break; case GST_SEEK_METHOD_END: if (dvdnav_get_number_of_titles (src->dvdnav, &parts) != DVDNAV_STATUS_OK) { goto error; } new_part = parts + offset; break; default: goto error; } /*if (dvdnav_part_search(src->dvdnav, new_part) != */ if (dvdnav_part_play (src->dvdnav, title, new_part) != DVDNAV_STATUS_OK) { goto error; } } else if (format == angle_format) { if (dvdnav_get_angle_info (src->dvdnav, &angle, &angles) != DVDNAV_STATUS_OK) { goto error; } switch (GST_EVENT_SEEK_METHOD (event)) { case GST_SEEK_METHOD_SET: new_angle = offset; break; case GST_SEEK_METHOD_CUR: new_angle = angle + offset; break; case GST_SEEK_METHOD_END: new_angle = angles + offset; break; default: goto error; } if (dvdnav_angle_change (src->dvdnav, new_angle) != DVDNAV_STATUS_OK) { goto error; } } else { goto error; } } src->did_seek = TRUE; src->seek_pending = TRUE; src->need_flush = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH; return TRUE; error: GST_DEBUG_OBJECT (src, "seek failed"); return FALSE; } #endif static gboolean gst_dvd_nav_src_src_event (GstBaseSrc * basesrc, GstEvent * event) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (basesrc); gboolean res; GST_LOG_OBJECT (src, "handling %s event", GST_EVENT_TYPE_NAME (event)); if (!gst_dvd_nav_src_is_open (src)) { GST_DEBUG_OBJECT (src, "device not open yet"); return FALSE; } switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK: res = gst_dvd_nav_src_handle_seek_event (src, event); break; case GST_EVENT_NAVIGATION: res = gst_dvd_nav_src_handle_navigation_event (src, event); break; case GST_EVENT_FLUSH_START: /* FIXME: hmm? */ src->need_flush = TRUE; /* fall through */ default: res = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event); break; } return res; } static gboolean gst_dvd_nav_src_query_position (GstDvdNavSrc * src, GstFormat format, gint64 * p_val) { guint32 pos, len; gint32 title, angle, ch, x; *p_val = -1; if (format == sector_format) { if (dvdnav_get_position (src->dvdnav, &pos, &len) == DVDNAV_STATUS_OK) *p_val = pos; } else if (format == GST_FORMAT_BYTES) { if (dvdnav_get_position (src->dvdnav, &pos, &len) == DVDNAV_STATUS_OK) *p_val = (gint64) pos *DVD_SECTOR_SIZE; } else if (format == GST_FORMAT_TIME) { if (dvdnav_get_position (src->dvdnav, &pos, &len) == DVDNAV_STATUS_OK) *p_val = (gint64) gst_dvd_nav_src_get_time_for_sector (src, pos); /* libdvnav from svn at at least 20070503 provide this new function * dvdnav_get_current_time, I used it just to test that the values * provided by the timemap were rights but I won't use it as the values * it return changes only every ~0.5 seconds or less depending on how * much sectors are contained in a cell. *p_val = dvdnav_get_current_time(src->dvdnav) * GST_SECOND / 90000; */ } else if (format == title_format) { if (dvdnav_current_title_info (src->dvdnav, &title, &x) == DVDNAV_STATUS_OK) *p_val = title; } else if (format == chapter_format) { if (dvdnav_current_title_info (src->dvdnav, &x, &ch) == DVDNAV_STATUS_OK) *p_val = ch; } else if (format == angle_format) { if (dvdnav_get_angle_info (src->dvdnav, &angle, &x) == DVDNAV_STATUS_OK) *p_val = angle; } return (*p_val != -1); } static gboolean gst_dvd_nav_src_query_duration (GstDvdNavSrc * src, GstFormat format, gint64 * p_val) { guint32 pos, len; gint32 titles, t, angles, parts, x; *p_val = -1; if (format == GST_FORMAT_TIME) { if (src->pgc_length != GST_CLOCK_TIME_NONE) *p_val = src->pgc_length; } else if (format == sector_format) { if (dvdnav_get_position (src->dvdnav, &pos, &len) == DVDNAV_STATUS_OK) *p_val = len; } else if (format == GST_FORMAT_BYTES) { if (dvdnav_get_position (src->dvdnav, &pos, &len) == DVDNAV_STATUS_OK) *p_val = (gint64) len *DVD_SECTOR_SIZE; } else if (format == title_format) { if (dvdnav_get_number_of_titles (src->dvdnav, &titles) == DVDNAV_STATUS_OK) *p_val = titles; } else if (format == chapter_format) { if (dvdnav_current_title_info (src->dvdnav, &t, &x) == DVDNAV_STATUS_OK && dvdnav_get_number_of_parts (src->dvdnav, t, &parts) == DVDNAV_STATUS_OK) *p_val = parts; } else if (format == angle_format) { if (dvdnav_get_angle_info (src->dvdnav, &x, &angles) == DVDNAV_STATUS_OK) *p_val = angles; } return (*p_val != -1); } static gboolean gst_dvd_nav_src_query (GstBaseSrc * basesrc, GstQuery * query) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (basesrc); GstFormat format; gboolean res; gint64 val; if (!gst_dvd_nav_src_is_open (src)) { GST_DEBUG_OBJECT (src, "query failed: device not open yet"); return FALSE; } switch (GST_QUERY_TYPE (query)) { case GST_QUERY_DURATION:{ gst_query_parse_duration (query, &format, NULL); res = gst_dvd_nav_src_query_duration (src, format, &val); if (res) { gst_query_set_duration (query, format, val); } break; } case GST_QUERY_POSITION:{ gst_query_parse_position (query, &format, NULL); res = gst_dvd_nav_src_query_position (src, format, &val); if (res) { gst_query_set_position (query, format, val); } break; } case GST_QUERY_CONVERT:{ res = gst_dvd_nav_src_do_convert_query (src, query); break; } default:{ res = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query); break; } } return res; } /* URI interface */ static guint gst_dvd_nav_src_uri_get_type (void) { return GST_URI_SRC; } static gchar ** gst_dvd_nav_src_uri_get_protocols (void) { static gchar *protocols[] = { "dvd", "dvdnav", NULL }; return protocols; } static const gchar * gst_dvd_nav_src_uri_get_uri (GstURIHandler * handler) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (handler); g_free (src->last_uri); src->last_uri = g_strdup_printf ("dvd://%d,%d,%d", src->uri_title, src->uri_chapter, src->uri_angle); return src->last_uri; } static gboolean gst_dvd_nav_src_uri_set_uri (GstURIHandler * handler, const gchar * uri) { GstDvdNavSrc *src = GST_DVD_NAV_SRC (handler); gboolean ret; gchar *protocol = gst_uri_get_protocol (uri); ret = (protocol && (!strcmp (protocol, "dvdnav") || !strcmp (protocol, "dvd"))) ? TRUE : FALSE; 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; strcur = strs = g_strsplit (location, ",", 0); while (strcur && *strcur) { gint val; if (!sscanf (*strcur, "%d", &val)) break; switch (pos) { case 0: if (val != src->uri_title) { src->uri_title = val; src->new_seek = TRUE; } break; case 1: if (val != src->uri_chapter) { src->uri_chapter = val; src->new_seek = TRUE; } break; case 2: src->uri_angle = val; break; } strcur++; pos++; } g_strfreev (strs); g_free (location); } return ret; } static void gst_dvd_nav_src_uri_handler_init (gpointer g_iface, gpointer iface_data) { GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface; iface->get_type = gst_dvd_nav_src_uri_get_type; iface->get_protocols = gst_dvd_nav_src_uri_get_protocols; iface->get_uri = gst_dvd_nav_src_uri_get_uri; iface->set_uri = gst_dvd_nav_src_uri_set_uri; } static void gst_dvd_nav_src_do_init (GType dvdnavsrc_type) { static const GInterfaceInfo urihandler_info = { gst_dvd_nav_src_uri_handler_init, NULL, NULL }; g_type_add_interface_static (dvdnavsrc_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) { if (!gst_element_register (plugin, "dvdnavsrc", GST_RANK_PRIMARY, /* GST_RANK_PRIMARY + 1, */ GST_TYPE_DVD_NAV_SRC)) { return FALSE; } GST_DEBUG_CATEGORY_INIT (gst_dvd_nav_src_debug, "dvdnavsrc", 0, "DVD navigation element based on libdvdnav"); return TRUE; } GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, "dvdnav", "Access a DVD with navigation features using libdvdnav", plugin_init, VERSION, "GPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);