/* 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 #include #include #include #include #include #include #include #include #include #include GST_DEBUG_CATEGORY_STATIC (dvdnavsrc_debug); #define GST_CAT_DEFAULT (dvdnavsrc_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)) /* Call a dvdnav function and, it it fails, report an error an execute the code in the 'action' parameter. */ #define DVDNAV_RAWCALL(func, params, elem, action) \ if (func params != DVDNAV_STATUS_OK) { \ GST_ELEMENT_ERROR (elem, LIBRARY, FAILED, \ (_("Error invoking \"%s\": %s."), \ #func, dvdnav_err_to_string ((elem)->dvdnav)), \ GST_ERROR_SYSTEM); \ action \ } /* Call a dvdnav function and, it it fails, report an error and return from the current procedure. */ #define DVDNAV_CALL(func, params, elem) \ DVDNAV_RAWCALL (func, params, elem, return;) /* Call a dvdnav function and, it it fails, report an error and return from the current procedure with the value 'retval'. */ #define DVDNAV_CALLVAL(func, params, elem, retval) \ DVDNAV_RAWCALL (func, params, elem, return (retval);) /* The maxinum number of audio and SPU streams in a DVD. */ #define DVDNAVSRC_MAX_AUDIO_STREAMS 8 #define DVDNAVSRC_MAX_SPU_STREAMS 32 #define GST_TYPE_DVDNAVSRC \ (dvdnavsrc_get_type()) #define DVDNAVSRC(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_DVDNAVSRC,DVDNavSrc)) #define DVDNAVSRC_CLASS(klass) \ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_DVDNAVSRC,DVDNavSrcClass)) #define GST_IS_DVDNAVSRC(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_DVDNAVSRC)) #define GST_IS_DVDNAVSRC_CLASS(obj) \ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_DVDNAVSRC)) typedef struct _DVDNavSrc DVDNavSrc; typedef struct _DVDNavSrcClass DVDNavSrcClass; /* The pause modes to handle still frames. */ typedef enum { DVDNAVSRC_PAUSE_OFF, /* No pause active. */ DVDNAVSRC_PAUSE_LIMITED, /* A time limited pause is active. */ DVDNAVSRC_PAUSE_UNLIMITED /* An time unlimited pause is active. */ } DVDNavSrcPauseMode; /* Interval of time to sleep during pauses. */ #define DVDNAVSRC_PAUSE_INTERVAL (GST_SECOND / 20) /* The DVD domain types. */ typedef enum { DVDNAVSRC_DOMAIN_UNKNOWN, /* Unknown domain. */ DVDNAVSRC_DOMAIN_FP, /* First Play domain. */ DVDNAVSRC_DOMAIN_VMGM, /* Video Management Menu domain */ DVDNAVSRC_DOMAIN_VTSM, /* Video Title Menu domain. */ DVDNAVSRC_DOMAIN_VTS /* Video Title domain. */ } DVDNavSrcDomainType; struct _DVDNavSrc { GstElement element; /* Pads */ GstPad *srcpad; GstCaps *streaminfo; /* Location */ gchar *location; gboolean did_seek; gboolean need_flush; gboolean need_discont; /* Timing */ GstClock *clock; /* The clock for this element. */ /* Pause handling */ DVDNavSrcPauseMode pause_mode; /* The current pause mode. */ GstClockTime pause_end; /* The clock time for the end of the pause. */ /* Highligh handling */ int button; /* The currently highlighted button number (0 if no highlight). */ dvdnav_highlight_area_t area; /* The area corresponding to the currently highlighted button. */ /* State handling */ DVDNavSrcDomainType domain; /* The current DVD domain. */ int title, chapter, angle; int audio_phys, audio_log; /* The current audio streams. */ int subp_phys, subp_log; /* The current subpicture streams. */ dvdnav_t *dvdnav; /* The libdvdnav handle. */ GstCaps *buttoninfo; GstBuffer *cur_buf; /* Current output buffer. See dvdnavsrc_get. */ }; struct _DVDNavSrcClass { GstElementClass parent_class; void (*user_op) (DVDNavSrc * src, int op); }; /* elementfactory information */ GstElementDetails dvdnavsrc_details = { "DVD Source", "Source/File/DVD", "Access a DVD with navigation features using libdvdnav", "David I. Lehn ", }; /* DVDNavSrc signals and args */ enum { USER_OP_SIGNAL, LAST_SIGNAL }; enum { ARG_0, ARG_LOCATION, ARG_STREAMINFO, ARG_BUTTONINFO, ARG_TITLE_STRING, ARG_TITLE, ARG_CHAPTER, ARG_ANGLE, ARG_AUDIO_LANGS, ARG_AUDIO_LANG, ARG_SPU_LANGS, ARG_SPU_LANG }; typedef enum { DVDNAVSRC_OPEN = GST_ELEMENT_FLAG_LAST, DVDNAVSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2 } DVDNavSrcFlags; GType dvdnavsrc_get_type (void); static void dvdnavsrc_base_init (gpointer g_class); static void dvdnavsrc_class_init (DVDNavSrcClass * klass); static void dvdnavsrc_init (DVDNavSrc * dvdnavsrc); static void dvdnavsrc_finalize (GObject * object); static void dvdnavsrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void dvdnavsrc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void dvdnavsrc_set_clock (GstElement * element, GstClock * clock); static GstEvent *dvdnavsrc_make_dvd_event (DVDNavSrc * src, const gchar * event_name, const gchar * firstfield, ...); static GstEvent *dvdnavsrc_make_dvd_nav_packet_event (DVDNavSrc * src, const pci_t * pci); static GstEvent *dvdnavsrc_make_clut_change_event (DVDNavSrc * src, const guint * clut); static void dvdnavsrc_loop (GstElement * element); static gboolean dvdnavsrc_event (GstPad * pad, GstEvent * event); static const GstEventMask *dvdnavsrc_get_event_mask (GstPad * pad); static const GstFormat *dvdnavsrc_get_formats (GstPad * pad); static gboolean dvdnavsrc_query (GstPad * pad, GstQueryType type, GstFormat * format, gint64 * value); static const GstQueryType *dvdnavsrc_get_query_types (GstPad * pad); static gboolean dvdnavsrc_convert (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value); static gboolean dvdnavsrc_close (DVDNavSrc * src); static gboolean dvdnavsrc_open (DVDNavSrc * src); static gboolean dvdnavsrc_is_open (DVDNavSrc * src); #ifndef GST_DISABLE_GST_DEBUG static void dvdnavsrc_print_event (DVDNavSrc * src, guint8 * data, int event, int len); #else #define dvdnavsrc_print_event(src, data, event, len) ((void) 0) #endif /* GST_DISABLE_GST_DEBUG */ static void dvdnavsrc_update_streaminfo (DVDNavSrc * src); static void dvdnavsrc_set_domain (DVDNavSrc * src); static void dvdnavsrc_update_highlight (DVDNavSrc * src); static void dvdnavsrc_user_op (DVDNavSrc * src, int op); static GstElementStateReturn dvdnavsrc_change_state (GstElement * element); static GstElementClass *parent_class = NULL; static guint dvdnavsrc_signals[LAST_SIGNAL] = { 0 }; static GstFormat sector_format; static GstFormat title_format; static GstFormat chapter_format; static GstFormat angle_format; GType dvdnavsrc_get_type (void) { static GType dvdnavsrc_type = 0; if (!dvdnavsrc_type) { static const GTypeInfo dvdnavsrc_info = { sizeof (DVDNavSrcClass), dvdnavsrc_base_init, NULL, (GClassInitFunc) dvdnavsrc_class_init, NULL, NULL, sizeof (DVDNavSrc), 0, (GInstanceInitFunc) dvdnavsrc_init, }; dvdnavsrc_type = g_type_register_static (GST_TYPE_ELEMENT, "DVDNavSrc", &dvdnavsrc_info, 0); sector_format = gst_format_register ("sector", "DVD sector"); title_format = gst_format_register ("title", "DVD title"); chapter_format = gst_format_register ("chapter", "DVD chapter"); angle_format = gst_format_register ("angle", "DVD angle"); GST_DEBUG_CATEGORY_INIT (dvdnavsrc_debug, "dvdnavsrc", 0, "DVD navigation element"); } return dvdnavsrc_type; } static void dvdnavsrc_base_init (gpointer g_class) { GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); gst_element_class_set_details (element_class, &dvdnavsrc_details); } static void dvdnavsrc_class_init (DVDNavSrcClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; parent_class = g_type_class_ref (GST_TYPE_ELEMENT); dvdnavsrc_signals[USER_OP_SIGNAL] = g_signal_new ("user-op", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (DVDNavSrcClass, user_op), NULL, NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); gobject_class->finalize = dvdnavsrc_finalize; klass->user_op = dvdnavsrc_user_op; g_object_class_install_property (gobject_class, ARG_LOCATION, g_param_spec_string ("location", "location", "location", NULL, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_TITLE_STRING, g_param_spec_string ("title_string", "title string", "DVD title string", NULL, G_PARAM_READABLE)); 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)); 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)); gobject_class->set_property = GST_DEBUG_FUNCPTR (dvdnavsrc_set_property); gobject_class->get_property = GST_DEBUG_FUNCPTR (dvdnavsrc_get_property); gstelement_class->change_state = dvdnavsrc_change_state; gstelement_class->set_clock = dvdnavsrc_set_clock; } static void dvdnavsrc_init (DVDNavSrc * src) { src->srcpad = gst_pad_new ("src", GST_PAD_SRC); gst_element_set_loop_function (GST_ELEMENT (src), dvdnavsrc_loop); gst_pad_set_event_function (src->srcpad, dvdnavsrc_event); gst_pad_set_event_mask_function (src->srcpad, dvdnavsrc_get_event_mask); gst_pad_set_convert_function (src->srcpad, dvdnavsrc_convert); gst_pad_set_query_function (src->srcpad, dvdnavsrc_query); gst_pad_set_query_type_function (src->srcpad, dvdnavsrc_get_query_types); gst_pad_set_formats_function (src->srcpad, dvdnavsrc_get_formats); gst_element_add_pad (GST_ELEMENT (src), src->srcpad); src->location = g_strdup ("/dev/dvd"); src->did_seek = FALSE; src->need_flush = FALSE; /* Pause mode is initially inactive. */ src->pause_mode = DVDNAVSRC_PAUSE_OFF; /* No highlighted button. */ src->button = 0; /* Domain is unknown at the begining. */ src->domain = DVDNAVSRC_DOMAIN_UNKNOWN; src->title = 0; src->chapter = 1; src->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; } static void dvdnavsrc_finalize (GObject * object) { DVDNavSrc *src = DVDNAVSRC (object); /* If there's a current output buffer, get rid of it. */ if (src->cur_buf != NULL) { gst_buffer_unref (src->cur_buf); } } static gboolean dvdnavsrc_is_open (DVDNavSrc * src) { g_return_val_if_fail (src != NULL, FALSE); g_return_val_if_fail (GST_IS_DVDNAVSRC (src), FALSE); return GST_FLAG_IS_SET (src, DVDNAVSRC_OPEN); } static void dvdnavsrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { DVDNavSrc *src; /* it's not null if we got it, but it might not be ours */ g_return_if_fail (GST_IS_DVDNAVSRC (object)); src = DVDNAVSRC (object); switch (prop_id) { case ARG_LOCATION: /* the element must be stopped in order to do this */ /*g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING)); */ if (src->location) g_free (src->location); /* clear the filename if we get a NULL (is that possible?) */ if (g_value_get_string (value) == NULL) src->location = g_strdup ("/dev/dvd"); /* otherwise set the new filename */ else src->location = g_strdup (g_value_get_string (value)); break; case ARG_TITLE: src->title = g_value_get_int (value); src->did_seek = TRUE; break; case ARG_CHAPTER: src->chapter = g_value_get_int (value); src->did_seek = TRUE; break; case ARG_ANGLE: src->angle = g_value_get_int (value); break; case ARG_AUDIO_LANG: if (dvdnavsrc_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 (dvdnavsrc_is_open (src)) { const gchar *code = g_value_get_string (value); if (code != NULL) { dvdnav_spu_language_select (src->dvdnav, (char *) code); } } break; break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void dvdnavsrc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { DVDNavSrc *src; const char *title_string; /* it's not null if we got it, but it might not be ours */ g_return_if_fail (GST_IS_DVDNAVSRC (object)); src = DVDNAVSRC (object); switch (prop_id) { case ARG_LOCATION: g_value_set_string (value, src->location); break; 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_STRING: if (!dvdnavsrc_is_open (src)) { g_value_set_string (value, ""); } else if (dvdnav_get_title_string (src->dvdnav, &title_string) != DVDNAV_STATUS_OK) { g_value_set_string (value, "UNKNOWN"); } else { g_value_set_string (value, title_string); } break; case ARG_TITLE: g_value_set_int (value, src->title); break; case ARG_CHAPTER: g_value_set_int (value, src->chapter); break; case ARG_ANGLE: g_value_set_int (value, src->angle); break; case ARG_AUDIO_LANGS: if (!dvdnavsrc_is_open (src)) { g_value_set_string (value, ""); } else { uint8_t physical, logical; uint16_t lang_int; gchar langs[DVDNAVSRC_MAX_AUDIO_STREAMS * 3]; gchar *lang_ptr = langs; for (physical = 0; physical < DVDNAVSRC_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 (!dvdnavsrc_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 (!dvdnavsrc_is_open (src)) { g_value_set_string (value, ""); } else { uint8_t physical, logical; uint16_t lang_int; gchar langs[DVDNAVSRC_MAX_SPU_STREAMS * 3]; gchar *lang_ptr = langs; for (physical = 0; physical < DVDNAVSRC_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 (!dvdnavsrc_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; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void dvdnavsrc_set_clock (GstElement * element, GstClock * clock) { DVDNavSrc *src = DVDNAVSRC (element); src->clock = clock; } static gboolean dvdnavsrc_tca_seek (DVDNavSrc * src, int title, int chapter, int angle) { int titles, programs, curangle, angles; g_return_val_if_fail (src != NULL, FALSE); g_return_val_if_fail (src->dvdnav != NULL, FALSE); g_return_val_if_fail (dvdnavsrc_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); dvdnavsrc_close (src); 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_titles (src->dvdnav, &programs) != 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", programs); if (chapter < 0 || chapter > programs) { GST_ERROR_OBJECT (src, "invalid chapter %d", chapter); dvdnavsrc_close (src); 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); dvdnavsrc_close (src); 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; } src->did_seek = TRUE; return TRUE; } static void dvdnavsrc_update_streaminfo (DVDNavSrc * 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 (dvdnavsrc_query (src->srcpad, GST_QUERY_TOTAL, &title_format, &value)) { gst_caps_set_simple (caps, "titles", G_TYPE_INT, value, NULL); } if (dvdnavsrc_query (src->srcpad, GST_QUERY_POSITION, &title_format, &value)) { gst_caps_set_simple (caps, "title", G_TYPE_INT, value, NULL); } if (dvdnavsrc_query (src->srcpad, GST_QUERY_TOTAL, &chapter_format, &value)) { gst_caps_set_simple (caps, "chapters", G_TYPE_INT, value, NULL); } if (dvdnavsrc_query (src->srcpad, GST_QUERY_POSITION, &chapter_format, &value)) { gst_caps_set_simple (caps, "chapter", G_TYPE_INT, value, NULL); } if (dvdnavsrc_query (src->srcpad, GST_QUERY_TOTAL, &angle_format, &value)) { gst_caps_set_simple (caps, "angles", G_TYPE_INT, value, NULL); } if (dvdnavsrc_query (src->srcpad, GST_QUERY_POSITION, &angle_format, &value)) { gst_caps_set_simple (caps, "angle", G_TYPE_INT, value, NULL); } if (src->streaminfo) { gst_caps_free (src->streaminfo); } src->streaminfo = caps; g_object_notify (G_OBJECT (src), "streaminfo"); } /** * Check for a new DVD domain area, and update the structure if * necessary. */ static void dvdnavsrc_set_domain (DVDNavSrc * src) { DVDNavSrcDomainType domain; if (dvdnav_is_domain_fp (src->dvdnav)) { domain = DVDNAVSRC_DOMAIN_FP; } else if (dvdnav_is_domain_vmgm (src->dvdnav)) { domain = DVDNAVSRC_DOMAIN_VMGM; } else if (dvdnav_is_domain_vtsm (src->dvdnav)) { domain = DVDNAVSRC_DOMAIN_VTSM; } else if (dvdnav_is_domain_vts (src->dvdnav)) { domain = DVDNAVSRC_DOMAIN_VTS; } else { domain = DVDNAVSRC_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 dvdnavsrc_update_highlight (DVDNavSrc * src) { int button = 0; pci_t *pci; dvdnav_highlight_area_t area; GstEvent *event; DVDNAV_CALL (dvdnav_get_current_highlight, (src->dvdnav, &button), src); 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; event = dvdnavsrc_make_dvd_event (src, "dvd-spu-reset-highlight", NULL); gst_pad_push (src->srcpad, GST_DATA (event)); } return; } DVDNAV_CALL (dvdnav_get_highlight_area, (pci, button, 0, &area), src); /* Check if we have a new button number, or a new highlight region. */ if (button != src->button || memcmp (&area, &(src->area), sizeof (dvdnav_highlight_area_t)) != 0) { memcpy (&(src->area), &area, sizeof (dvdnav_highlight_area_t)); event = dvdnavsrc_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); gst_pad_push (src->srcpad, GST_DATA (event)); } } static void dvdnavsrc_user_op (DVDNavSrc * src, int 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 gchar * dvdnav_get_event_name (int event) { switch (event) { case DVDNAV_BLOCK_OK: return "DVDNAV_BLOCK_OK"; break; case DVDNAV_NOP: return "DVDNAV_NOP"; break; case DVDNAV_STILL_FRAME: return "DVDNAV_STILL_FRAME"; break; case DVDNAV_WAIT: return "DVDNAV_WAIT"; break; case DVDNAV_SPU_STREAM_CHANGE: return "DVDNAV_SPU_STREAM_CHANGE"; break; case DVDNAV_AUDIO_STREAM_CHANGE: return "DVDNAV_AUDIO_STREAM_CHANGE"; break; case DVDNAV_VTS_CHANGE: return "DVDNAV_VTS_CHANGE"; break; case DVDNAV_CELL_CHANGE: return "DVDNAV_CELL_CHANGE"; break; case DVDNAV_NAV_PACKET: return "DVDNAV_NAV_PACKET"; break; case DVDNAV_STOP: return "DVDNAV_STOP"; break; case DVDNAV_HIGHLIGHT: return "DVDNAV_HIGHLIGHT"; break; case DVDNAV_SPU_CLUT_CHANGE: return "DVDNAV_SPU_CLUT_CHANGE"; break; case DVDNAV_HOP_CHANNEL: return "DVDNAV_HOP_CHANNEL"; break; } return "UNKNOWN"; } static gchar * dvdnav_get_read_domain_name (dvd_read_domain_t domain) { switch (domain) { case DVD_READ_INFO_FILE: return "DVD_READ_INFO_FILE"; break; case DVD_READ_INFO_BACKUP_FILE: return "DVD_READ_INFO_BACKUP_FILE"; break; case DVD_READ_MENU_VOBS: return "DVD_READ_MENU_VOBS"; break; case DVD_READ_TITLE_VOBS: return "DVD_READ_TITLE_VOBS"; break; } return "UNKNOWN"; } static void dvdnavsrc_print_event (DVDNavSrc * src, guint8 * data, int event, int len) { g_return_if_fail (src != NULL); g_return_if_fail (GST_IS_DVDNAVSRC (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 = (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: { /*dvdnav_cell_change_event_t *event = (dvdnav_cell_change_event_t *)data; */ /* FIXME: Print something relevant here. */ } 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 * dvdnavsrc_make_dvd_event (DVDNavSrc * 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 (GST_EVENT_ANY); event->event_data.structure.structure = structure; #ifndef GST_DISABLE_GST_DEBUG { gchar *text = gst_structure_to_string (structure); GST_LOG_OBJECT (src, "creating event \"%s\"", text); g_free (text); } #endif return event; } static GstEvent * dvdnavsrc_make_dvd_nav_packet_event (DVDNavSrc * src, const pci_t * pci) { GstEvent *event; GstStructure *structure; GValue start_ptm = { 0 }, end_ptm = { 0}; /* Store the time values in GValues. */ g_value_init (&start_ptm, G_TYPE_UINT64); g_value_set_uint64 (&start_ptm, MPEGTIME_TO_GSTTIME (pci->pci_gi.vobu_s_ptm)); g_value_init (&end_ptm, G_TYPE_UINT64); g_value_set_uint64 (&end_ptm, MPEGTIME_TO_GSTTIME (pci->pci_gi.vobu_e_ptm)); /* Add the values to a new structure. */ structure = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING, "dvd-nav-packet", NULL); gst_structure_set_value (structure, "start_ptm", &start_ptm); gst_structure_set_value (structure, "end_ptm", &end_ptm); /* Create the DVD event and put the structure into it. */ event = gst_event_new (GST_EVENT_ANY); event->event_data.structure.structure = structure; #ifndef GST_DISABLE_GST_DEBUG { gchar *text = gst_structure_to_string (structure); GST_LOG_OBJECT (src, "creating event \"%s\"", text); g_free (text); } #endif return event; } static GstEvent * dvdnavsrc_make_clut_change_event (DVDNavSrc * src, const guint * clut) { GstEvent *event; GstStructure *structure; guchar 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 (GST_EVENT_ANY); event->event_data.structure.structure = structure; #ifndef GST_DISABLE_GST_DEBUG { gchar *text = gst_structure_to_string (structure); GST_LOG_OBJECT (src, "creating event \"%s\"", text); g_free (text); } #endif return event; } static void dvdnavsrc_loop (GstElement * element) { DVDNavSrc *src = DVDNAVSRC (element); int event, len; guint8 *data; GstData *send_data; g_return_if_fail (dvdnavsrc_is_open (src)); if (src->did_seek) { GstEvent *event; src->did_seek = FALSE; GST_INFO_OBJECT (src, "sending discont"); event = gst_event_new_discontinuous (FALSE, 0); src->need_flush = FALSE; gst_pad_push (src->srcpad, GST_DATA (event)); return; } if (src->need_flush) { src->need_flush = FALSE; GST_INFO_OBJECT (src, "sending flush"); gst_pad_push (src->srcpad, GST_DATA (gst_event_new_flush ())); return; } /* Loop processing blocks until there is data to send. */ send_data = NULL; while (send_data == NULL) { if (src->cur_buf == NULL) { src->cur_buf = gst_buffer_new_and_alloc (DVD_VIDEO_LB_LEN); if (src->cur_buf == NULL) { GST_ELEMENT_ERROR (src, CORE, TOO_LAZY, (NULL), ("Failed to create a new GstBuffer")); return; } } data = GST_BUFFER_DATA (src->cur_buf); DVDNAV_CALL (dvdnav_get_next_block, (src->dvdnav, data, &event, &len), src); switch (event) { case DVDNAV_NOP: break; case DVDNAV_BLOCK_OK: send_data = GST_DATA (src->cur_buf); src->cur_buf = NULL; break; case DVDNAV_STILL_FRAME: { dvdnav_still_event_t *info = (dvdnav_still_event_t *) data; GstClockTime current_time = gst_element_get_time (GST_ELEMENT (src)); if (src->pause_mode == DVDNAVSRC_PAUSE_OFF) { dvdnavsrc_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 = DVDNAVSRC_PAUSE_UNLIMITED; } else { src->pause_mode = DVDNAVSRC_PAUSE_LIMITED; src->pause_end = current_time + info->length * GST_SECOND; GST_INFO_OBJECT (src, "starting limited pause: %d seconds at %llu until %llu", info->length, current_time, src->pause_end); } /* 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"); send_data = GST_DATA (dvdnavsrc_make_dvd_event (src, "dvd-spu-still-frame", NULL)); break; } if (src->pause_mode == DVDNAVSRC_PAUSE_UNLIMITED || current_time < src->pause_end) { GstEvent *event; /* We are in pause mode. Make this element sleep for a fraction of a second. */ if (current_time + DVDNAVSRC_PAUSE_INTERVAL > src->pause_end) { gst_element_wait (GST_ELEMENT (src), src->pause_end); } else { gst_element_wait (GST_ELEMENT (src), current_time + DVDNAVSRC_PAUSE_INTERVAL); } /* Send an empty event to keep the pipeline going. */ /* FIXME: Use an interrupt/filler event here. */ event = gst_event_new (GST_EVENT_EMPTY); send_data = GST_DATA (event); GST_EVENT_TIMESTAMP (event) = gst_element_get_time (GST_ELEMENT (src)); break; } else { /* We reached the end of the pause. */ src->pause_mode = DVDNAVSRC_PAUSE_OFF; DVDNAV_CALL (dvdnav_still_skip, (src->dvdnav), src); } } break; case DVDNAV_WAIT: /* 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"); DVDNAV_CALL (dvdnav_wait_skip, (src->dvdnav), src); break; case DVDNAV_STOP: GST_INFO_OBJECT (src, "sending eos"); gst_element_set_eos (GST_ELEMENT (src)); dvdnavsrc_close (src); send_data = GST_DATA (gst_event_new (GST_EVENT_EOS)); break; case DVDNAV_CELL_CHANGE: dvdnavsrc_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); } } dvdnavsrc_update_highlight (src); /* Send a dvd nav packet event. */ send_data = GST_DATA (dvdnavsrc_make_dvd_nav_packet_event (src, pci)); } break; case DVDNAV_SPU_CLUT_CHANGE: send_data = GST_DATA (dvdnavsrc_make_clut_change_event (src, (guint *) data)); break; case DVDNAV_VTS_CHANGE: { dvdnavsrc_set_domain (src); send_data = GST_DATA (dvdnavsrc_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 = (dvdnav_audio_stream_change_event_t *) data; int phys = info->physical; dvdnavsrc_print_event (src, data, event, len); if (phys < 0 || phys > DVDNAVSRC_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); send_data = GST_DATA (dvdnavsrc_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 = (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. */ int phys = info->physical_wide; dvdnavsrc_print_event (src, data, event, len); if (phys < 0 || phys > DVDNAVSRC_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); send_data = GST_DATA (dvdnavsrc_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: dvdnavsrc_print_event (src, data, event, len); dvdnavsrc_update_highlight (src); break; case DVDNAV_HOP_CHANNEL: dvdnavsrc_print_event (src, data, event, len); src->button = 0; src->pause_mode = DVDNAVSRC_PAUSE_OFF; send_data = GST_DATA (gst_event_new_flush ()); break; default: g_error ("dvdnavsrc: Unknown dvdnav event %d", event); break; } } gst_pad_push (src->srcpad, send_data); } /* open the file, necessary to go to RUNNING state */ static gboolean dvdnavsrc_open (DVDNavSrc * src) { g_return_val_if_fail (src != NULL, FALSE); g_return_val_if_fail (GST_IS_DVDNAVSRC (src), FALSE); g_return_val_if_fail (!dvdnavsrc_is_open (src), FALSE); g_return_val_if_fail (src->location != NULL, FALSE); DVDNAV_CALLVAL (dvdnav_open, (&src->dvdnav, (char *) src->location), src, FALSE); GST_FLAG_SET (src, DVDNAVSRC_OPEN); /* 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. */ if (src->title > 0) { unsigned char buf[2048]; int event, buflen = sizeof (buf); DVDNAV_CALLVAL (dvdnav_get_next_block, (src->dvdnav, buf, &event, &buflen), src, FALSE); dvdnavsrc_print_event (src, buf, event, buflen); if (!dvdnavsrc_tca_seek (src, src->title, src->chapter, src->angle)) { return FALSE; } } return TRUE; } /* close the file */ static gboolean dvdnavsrc_close (DVDNavSrc * src) { g_return_val_if_fail (src != NULL, FALSE); g_return_val_if_fail (GST_IS_DVDNAVSRC (src), FALSE); g_return_val_if_fail (dvdnavsrc_is_open (src), FALSE); g_return_val_if_fail (src->dvdnav != NULL, FALSE); DVDNAV_CALLVAL (dvdnav_close, (src->dvdnav), src, FALSE); GST_FLAG_UNSET (src, DVDNAVSRC_OPEN); return TRUE; } static GstElementStateReturn dvdnavsrc_change_state (GstElement * element) { DVDNavSrc *src; g_return_val_if_fail (GST_IS_DVDNAVSRC (element), GST_STATE_FAILURE); src = DVDNAVSRC (element); switch (GST_STATE_TRANSITION (element)) { case GST_STATE_NULL_TO_READY: break; case GST_STATE_READY_TO_PAUSED: if (!dvdnavsrc_is_open (src)) { if (!dvdnavsrc_open (src)) { return GST_STATE_FAILURE; } } src->streaminfo = NULL; break; case GST_STATE_PAUSED_TO_PLAYING: break; case GST_STATE_PLAYING_TO_PAUSED: break; case GST_STATE_PAUSED_TO_READY: if (dvdnavsrc_is_open (src)) { if (!dvdnavsrc_close (src)) { return GST_STATE_FAILURE; } } break; case GST_STATE_READY_TO_NULL: break; } /* if we haven't failed already, give the parent class a chance to ;-) */ if (GST_ELEMENT_CLASS (parent_class)->change_state) return GST_ELEMENT_CLASS (parent_class)->change_state (element); return GST_STATE_SUCCESS; } static const GstEventMask * dvdnavsrc_get_event_mask (GstPad * pad) { static const GstEventMask masks[] = { {GST_EVENT_SEEK, GST_SEEK_METHOD_SET | GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH}, {GST_EVENT_FLUSH, 0}, {GST_EVENT_NAVIGATION, GST_EVENT_FLAG_NONE}, {0,} }; return masks; } static gboolean dvdnav_handle_navigation_event (DVDNavSrc * src, GstEvent * event) { GstStructure *structure = event->event_data.structure.structure; const char *event_type = gst_structure_get_string (structure, "event"); g_return_val_if_fail (event != NULL, FALSE); if (strcmp (event_type, "key-press") == 0) { const char *key = gst_structure_get_string (structure, "key"); g_assert (key != NULL); GST_DEBUG ("dvdnavsrc got a keypress: %s", key); } else if (strcmp (event_type, "mouse-move") == 0) { double 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); dvdnavsrc_update_highlight (src); } else if (strcmp (event_type, "mouse-button-release") == 0) { double x, y; gst_structure_get_double (structure, "pointer_x", &x); gst_structure_get_double (structure, "pointer_y", &y); dvdnav_mouse_activate (src->dvdnav, dvdnav_get_current_nav_pci (src->dvdnav), (int) x, (int) y); } return TRUE; } static gboolean dvdnavsrc_event (GstPad * pad, GstEvent * event) { DVDNavSrc *src; gboolean res = TRUE; src = DVDNAVSRC (gst_pad_get_parent (pad)); if (!GST_FLAG_IS_SET (src, DVDNAVSRC_OPEN)) goto error; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK: { gint64 offset; gint format; int titles, title, new_title; int parts, part, new_part; int angles, angle, new_angle; int origin; format = GST_EVENT_SEEK_FORMAT (event); offset = GST_EVENT_SEEK_OFFSET (event); switch (format) { case GST_FORMAT_BYTES: 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 / DVD_SECTOR_SIZE), origin) != DVDNAV_STATUS_OK) { goto error; } 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->need_flush = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH; break; } case GST_EVENT_NAVIGATION: res = dvdnav_handle_navigation_event (src, event); break; case GST_EVENT_FLUSH: src->need_flush = TRUE; break; default: goto error; } if (FALSE) { error: res = FALSE; } gst_event_unref (event); return res; } static const GstFormat * dvdnavsrc_get_formats (GstPad * pad) { int i; static GstFormat formats[] = { GST_FORMAT_BYTES, /* GST_FORMAT_TIME, GST_FORMAT_DEFAULT, */ 0, /* filled later */ 0, /* filled later */ 0, /* filled later */ 0, /* filled later */ 0 }; static gboolean format_initialized = FALSE; if (!format_initialized) { for (i = 0; formats[i] != 0; i++) { } formats[i++] = sector_format; formats[i++] = title_format; formats[i++] = chapter_format; formats[i++] = angle_format; format_initialized = TRUE; } return formats; } static gboolean dvdnavsrc_convert (GstPad * pad, GstFormat src_format, gint64 src_value, GstFormat * dest_format, gint64 * dest_value) { DVDNavSrc *src; src = DVDNAVSRC (gst_pad_get_parent (pad)); if (!GST_FLAG_IS_SET (src, DVDNAVSRC_OPEN)) return FALSE; switch (src_format) { case GST_FORMAT_BYTES: if (*dest_format == sector_format) { *dest_value = src_value / DVD_SECTOR_SIZE; } else return FALSE; default: if ((src_format == sector_format) && (*dest_format == GST_FORMAT_BYTES)) { *dest_value = src_value * DVD_SECTOR_SIZE; } else return FALSE; } return TRUE; } static const GstQueryType * dvdnavsrc_get_query_types (GstPad * pad) { static const GstQueryType src_query_types[] = { GST_QUERY_TOTAL, GST_QUERY_POSITION, 0 }; return src_query_types; } static gboolean dvdnavsrc_query (GstPad * pad, GstQueryType type, GstFormat * format, gint64 * value) { gboolean res = TRUE; DVDNavSrc *src; int titles, title; int parts, part; int angles, angle; unsigned int pos, len; src = DVDNAVSRC (gst_pad_get_parent (pad)); if (!GST_FLAG_IS_SET (src, DVDNAVSRC_OPEN)) return FALSE; switch (type) { case GST_QUERY_TOTAL: if (*format == sector_format) { if (dvdnav_get_position (src->dvdnav, &pos, &len) != DVDNAV_STATUS_OK) { res = FALSE; } *value = len; } else if (*format == GST_FORMAT_BYTES) { if (dvdnav_get_position (src->dvdnav, &pos, &len) != DVDNAV_STATUS_OK) { res = FALSE; } *value = len * DVD_SECTOR_SIZE; } else if (*format == title_format) { if (dvdnav_get_number_of_titles (src->dvdnav, &titles) != DVDNAV_STATUS_OK) { res = FALSE; } *value = titles; } else if (*format == chapter_format) { if (dvdnav_get_number_of_titles (src->dvdnav, &parts) != DVDNAV_STATUS_OK) { res = FALSE; } *value = parts; } else if (*format == angle_format) { if (dvdnav_get_angle_info (src->dvdnav, &angle, &angles) != DVDNAV_STATUS_OK) { res = FALSE; } *value = angles; } else { res = FALSE; } break; case GST_QUERY_POSITION: if (*format == sector_format) { if (dvdnav_get_position (src->dvdnav, &pos, &len) != DVDNAV_STATUS_OK) { res = FALSE; } *value = pos; } else if (*format == title_format) { if (dvdnav_current_title_info (src->dvdnav, &title, &part) != DVDNAV_STATUS_OK) { res = FALSE; } *value = title; } else if (*format == chapter_format) { if (dvdnav_current_title_info (src->dvdnav, &title, &part) != DVDNAV_STATUS_OK) { res = FALSE; } *value = part; } else if (*format == angle_format) { if (dvdnav_get_angle_info (src->dvdnav, &angle, &angles) != DVDNAV_STATUS_OK) { res = FALSE; } *value = angle; } else { res = FALSE; } break; default: res = FALSE; break; } return res; } static gboolean plugin_init (GstPlugin * plugin) { if (!gst_element_register (plugin, "dvdnavsrc", GST_RANK_NONE, GST_TYPE_DVDNAVSRC)) return FALSE; return TRUE; } GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, "dvdnavsrc", "Access a DVD with navigation features using libdvdnav", plugin_init, VERSION, "GPL", GST_PACKAGE, GST_ORIGIN)