mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-30 21:51:09 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/ext/dvdnav/dvdnavsrc.c
Tal Shalif 71c3c41c66 ext/dvdnav/dvdnavsrc.c: Prevent double free. Fixes bug #541697. 
Original commit message from CVS:
Patch by: Tal Shalif <tshalif at nargila dot org>
* ext/dvdnav/dvdnavsrc.c: (gst_dvd_nav_src_stop):
Prevent double free. Fixes bug #541697.
2008-07-05 18:57:30 +00:00

2664 lines
79 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 2002 David I. Lehn <dlehn@users.sourceforge.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "_stdint.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
//#include <gst/gst-i18n-plugin.h>
#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 <dlehn@users.sourceforge.net>",
};
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);
src->vts_file = NULL;
}
/* 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);
Reference in a new issue View git blame Copy permalink