2002-05-26 17:39:45 +00:00
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
2003-06-29 19:46:09 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
2003-11-07 12:46:51 +00:00
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <assert.h>
|
2002-09-08 04:21:36 +00:00
|
|
|
#include <gst/gst.h>
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
#include <dvdnav/dvdnav.h>
|
2004-02-03 12:04:43 +00:00
|
|
|
#include <dvdnav/nav_print.h>
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
#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;
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
struct _DVDNavSrc
|
|
|
|
{
|
2002-05-26 17:39:45 +00:00
|
|
|
GstElement element;
|
2002-09-08 04:21:36 +00:00
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
/* pads */
|
2004-03-14 22:34:30 +00:00
|
|
|
GstPad *srcpad;
|
2003-01-07 08:09:28 +00:00
|
|
|
GstCaps *streaminfo;
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
/* location */
|
|
|
|
gchar *location;
|
2003-01-07 08:09:28 +00:00
|
|
|
|
|
|
|
gboolean did_seek;
|
|
|
|
gboolean need_flush;
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
int title, chapter, angle;
|
|
|
|
dvdnav_t *dvdnav;
|
2003-01-07 08:09:28 +00:00
|
|
|
|
|
|
|
GstCaps *buttoninfo;
|
2002-05-26 17:39:45 +00:00
|
|
|
};
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
struct _DVDNavSrcClass
|
|
|
|
{
|
2002-09-08 04:21:36 +00:00
|
|
|
GstElementClass parent_class;
|
2003-01-07 08:09:28 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
void (*button_pressed) (DVDNavSrc * src, int button);
|
|
|
|
void (*pointer_select) (DVDNavSrc * src, int x, int y);
|
|
|
|
void (*pointer_activate) (DVDNavSrc * src, int x, int y);
|
|
|
|
void (*user_op) (DVDNavSrc * src, int op);
|
2002-09-08 04:21:36 +00:00
|
|
|
};
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2002-09-18 19:02:46 +00:00
|
|
|
/* elementfactory information */
|
2002-05-26 17:39:45 +00:00
|
|
|
GstElementDetails dvdnavsrc_details = {
|
|
|
|
"DVD Source",
|
|
|
|
"Source/File/DVD",
|
|
|
|
"Access a DVD with navigation features using libdvdnav",
|
|
|
|
"David I. Lehn <dlehn@users.sourceforge.net>",
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* DVDNavSrc signals and args */
|
2004-03-14 22:34:30 +00:00
|
|
|
enum
|
|
|
|
{
|
2003-01-07 08:09:28 +00:00
|
|
|
BUTTON_PRESSED_SIGNAL,
|
|
|
|
POINTER_SELECT_SIGNAL,
|
|
|
|
POINTER_ACTIVATE_SIGNAL,
|
2003-01-09 08:56:58 +00:00
|
|
|
USER_OP_SIGNAL,
|
2002-05-26 17:39:45 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
enum
|
|
|
|
{
|
2002-05-26 17:39:45 +00:00
|
|
|
ARG_0,
|
|
|
|
ARG_LOCATION,
|
2003-01-07 08:09:28 +00:00
|
|
|
ARG_STREAMINFO,
|
|
|
|
ARG_BUTTONINFO,
|
2003-01-02 08:21:29 +00:00
|
|
|
ARG_TITLE_STRING,
|
2002-05-26 17:39:45 +00:00
|
|
|
ARG_TITLE,
|
|
|
|
ARG_CHAPTER,
|
|
|
|
ARG_ANGLE
|
|
|
|
};
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
DVDNAVSRC_OPEN = GST_ELEMENT_FLAG_LAST,
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
DVDNAVSRC_FLAG_LAST = GST_ELEMENT_FLAG_LAST + 2,
|
2004-03-15 19:32:25 +00:00
|
|
|
}
|
|
|
|
DVDNavSrcFlags;
|
2002-09-08 04:21:36 +00:00
|
|
|
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
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_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);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static GstData *dvdnavsrc_get (GstPad * pad);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
/*static GstBuffer * dvdnavsrc_get_region (GstPad *pad,gulong offset,gulong size); */
|
2004-03-14 22:34:30 +00:00
|
|
|
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);
|
|
|
|
|
2003-01-02 08:21:29 +00:00
|
|
|
/*static gboolean dvdnavsrc_convert (GstPad *pad,
|
|
|
|
GstFormat src_format,
|
|
|
|
gint64 src_value,
|
|
|
|
GstFormat *dest_format,
|
|
|
|
gint64 *dest_value);*/
|
2004-03-14 22:34:30 +00:00
|
|
|
static gboolean dvdnavsrc_query (GstPad * pad, GstQueryType type,
|
|
|
|
GstFormat * format, gint64 * value);
|
|
|
|
static const GstQueryType *dvdnavsrc_get_query_types (GstPad * pad);
|
2003-01-02 08:21:29 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static gboolean dvdnavsrc_close (DVDNavSrc * src);
|
|
|
|
static gboolean dvdnavsrc_open (DVDNavSrc * src);
|
|
|
|
static gboolean dvdnavsrc_is_open (DVDNavSrc * src);
|
|
|
|
static void dvdnavsrc_print_event (DVDNavSrc * src, guint8 * data, int event,
|
|
|
|
int len);
|
|
|
|
static void dvdnavsrc_update_streaminfo (DVDNavSrc * src);
|
|
|
|
static void dvdnavsrc_update_buttoninfo (DVDNavSrc * src);
|
|
|
|
static void dvdnavsrc_button_pressed (DVDNavSrc * src, int button);
|
|
|
|
static void dvdnavsrc_pointer_select (DVDNavSrc * src, int x, int y);
|
|
|
|
static void dvdnavsrc_pointer_activate (DVDNavSrc * src, int x, int y);
|
|
|
|
static void dvdnavsrc_user_op (DVDNavSrc * src, int op);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static GstElementStateReturn dvdnavsrc_change_state (GstElement * element);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
|
|
|
|
static GstElementClass *parent_class = NULL;
|
2003-01-07 08:09:28 +00:00
|
|
|
static guint dvdnavsrc_signals[LAST_SIGNAL] = { 0 };
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-02 08:21:29 +00:00
|
|
|
static GstFormat sector_format;
|
|
|
|
static GstFormat title_format;
|
|
|
|
static GstFormat chapter_format;
|
|
|
|
static GstFormat angle_format;
|
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
GType
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_get_type (void)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
|
|
|
static GType dvdnavsrc_type = 0;
|
|
|
|
|
|
|
|
if (!dvdnavsrc_type) {
|
|
|
|
static const GTypeInfo dvdnavsrc_info = {
|
2004-03-14 22:34:30 +00:00
|
|
|
sizeof (DVDNavSrcClass),
|
2003-11-01 15:16:06 +00:00
|
|
|
dvdnavsrc_base_init,
|
2002-05-26 17:39:45 +00:00
|
|
|
NULL,
|
2004-03-14 22:34:30 +00:00
|
|
|
(GClassInitFunc) dvdnavsrc_class_init,
|
2002-05-26 17:39:45 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2004-03-14 22:34:30 +00:00
|
|
|
sizeof (DVDNavSrc),
|
2002-05-26 17:39:45 +00:00
|
|
|
0,
|
2004-03-14 22:34:30 +00:00
|
|
|
(GInstanceInitFunc) dvdnavsrc_init,
|
2002-05-26 17:39:45 +00:00
|
|
|
};
|
2004-03-15 19:32:25 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_type =
|
2004-03-15 19:32:25 +00:00
|
|
|
g_type_register_static (GST_TYPE_ELEMENT, "DVDNavSrc", &dvdnavsrc_info,
|
|
|
|
0);
|
2003-01-02 08:21:29 +00:00
|
|
|
|
|
|
|
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");
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
return dvdnavsrc_type;
|
|
|
|
}
|
|
|
|
|
2003-11-01 15:16:06 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_class_init (DVDNavSrcClass * klass)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
|
|
|
GObjectClass *gobject_class;
|
|
|
|
GstElementClass *gstelement_class;
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
gobject_class = (GObjectClass *) klass;
|
|
|
|
gstelement_class = (GstElementClass *) klass;
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
|
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
dvdnavsrc_signals[BUTTON_PRESSED_SIGNAL] =
|
2004-03-14 22:34:30 +00:00
|
|
|
g_signal_new ("button-pressed",
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
G_STRUCT_OFFSET (DVDNavSrcClass, button_pressed),
|
|
|
|
NULL, NULL, gst_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
|
2003-01-07 08:09:28 +00:00
|
|
|
|
|
|
|
dvdnavsrc_signals[POINTER_SELECT_SIGNAL] =
|
2004-03-14 22:34:30 +00:00
|
|
|
g_signal_new ("pointer-select",
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
G_STRUCT_OFFSET (DVDNavSrcClass, pointer_select),
|
|
|
|
NULL, NULL,
|
|
|
|
gst_marshal_VOID__INT_INT, G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
|
2003-01-07 08:09:28 +00:00
|
|
|
|
|
|
|
dvdnavsrc_signals[POINTER_ACTIVATE_SIGNAL] =
|
2004-03-14 22:34:30 +00:00
|
|
|
g_signal_new ("pointer-activate",
|
|
|
|
G_TYPE_FROM_CLASS (klass),
|
|
|
|
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
|
|
|
|
G_STRUCT_OFFSET (DVDNavSrcClass, pointer_activate),
|
|
|
|
NULL, NULL,
|
|
|
|
gst_marshal_VOID__INT_INT, G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
|
2003-01-07 08:09:28 +00:00
|
|
|
|
2003-01-09 08:56:58 +00:00
|
|
|
dvdnavsrc_signals[USER_OP_SIGNAL] =
|
2004-03-14 22:34:30 +00:00
|
|
|
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, gst_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
|
2003-01-09 08:56:58 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
klass->button_pressed = dvdnavsrc_button_pressed;
|
|
|
|
klass->pointer_select = dvdnavsrc_pointer_select;
|
|
|
|
klass->pointer_activate = dvdnavsrc_pointer_activate;
|
2003-01-09 08:56:58 +00:00
|
|
|
klass->user_op = dvdnavsrc_user_op;
|
2004-03-14 22:34:30 +00:00
|
|
|
|
|
|
|
g_object_class_install_property (gobject_class, ARG_LOCATION,
|
|
|
|
g_param_spec_string ("location", "location", "location",
|
2004-03-15 19:32:25 +00:00
|
|
|
NULL, G_PARAM_READWRITE));
|
2004-03-14 22:34:30 +00:00
|
|
|
g_object_class_install_property (gobject_class, ARG_TITLE_STRING,
|
|
|
|
g_param_spec_string ("title_string", "title string", "DVD title string",
|
2004-03-15 19:32:25 +00:00
|
|
|
NULL, G_PARAM_READABLE));
|
2004-03-14 22:34:30 +00:00
|
|
|
g_object_class_install_property (gobject_class, ARG_TITLE,
|
|
|
|
g_param_spec_int ("title", "title", "title",
|
2004-03-15 19:32:25 +00:00
|
|
|
0, 99, 1, G_PARAM_READWRITE));
|
2004-03-14 22:34:30 +00:00
|
|
|
g_object_class_install_property (gobject_class, ARG_CHAPTER,
|
|
|
|
g_param_spec_int ("chapter", "chapter", "chapter",
|
2004-03-15 19:32:25 +00:00
|
|
|
0, 99, 1, G_PARAM_READWRITE));
|
2004-03-14 22:34:30 +00:00
|
|
|
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",
|
2004-03-15 19:32:25 +00:00
|
|
|
GST_TYPE_CAPS, G_PARAM_READABLE));
|
2004-03-14 22:34:30 +00:00
|
|
|
g_object_class_install_property (gobject_class, ARG_BUTTONINFO,
|
|
|
|
g_param_spec_boxed ("buttoninfo", "buttoninfo", "buttoninfo",
|
2004-03-15 19:32:25 +00:00
|
|
|
GST_TYPE_CAPS, G_PARAM_READABLE));
|
2004-03-14 22:34:30 +00:00
|
|
|
|
|
|
|
gobject_class->set_property = GST_DEBUG_FUNCPTR (dvdnavsrc_set_property);
|
|
|
|
gobject_class->get_property = GST_DEBUG_FUNCPTR (dvdnavsrc_get_property);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
gstelement_class->change_state = dvdnavsrc_change_state;
|
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static void
|
|
|
|
dvdnavsrc_init (DVDNavSrc * src)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
2003-01-07 08:09:28 +00:00
|
|
|
src->srcpad = gst_pad_new ("src", GST_PAD_SRC);
|
|
|
|
|
|
|
|
gst_pad_set_get_function (src->srcpad, dvdnavsrc_get);
|
|
|
|
gst_pad_set_event_function (src->srcpad, dvdnavsrc_event);
|
|
|
|
gst_pad_set_event_mask_function (src->srcpad, dvdnavsrc_get_event_mask);
|
2004-03-14 22:34:30 +00:00
|
|
|
/*gst_pad_set_convert_function (src->srcpad, dvdnavsrc_convert); */
|
2003-01-07 08:09:28 +00:00
|
|
|
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);
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
src->location = g_strdup ("/dev/dvd");
|
2003-01-07 08:09:28 +00:00
|
|
|
src->did_seek = FALSE;
|
|
|
|
src->need_flush = FALSE;
|
|
|
|
src->title = 0;
|
|
|
|
src->chapter = 0;
|
|
|
|
src->angle = 1;
|
|
|
|
src->streaminfo = NULL;
|
|
|
|
src->buttoninfo = NULL;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static gboolean
|
|
|
|
dvdnavsrc_is_open (DVDNavSrc * src)
|
2002-09-08 04:21:36 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static void
|
|
|
|
dvdnavsrc_set_property (GObject * object, guint prop_id, const GValue * value,
|
|
|
|
GParamSpec * pspec)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
|
|
|
DVDNavSrc *src;
|
|
|
|
|
|
|
|
/* it's not null if we got it, but it might not be ours */
|
|
|
|
g_return_if_fail (GST_IS_DVDNAVSRC (object));
|
2004-03-14 22:34:30 +00:00
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
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)); */
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
if (src->location)
|
2004-03-15 19:32:25 +00:00
|
|
|
g_free (src->location);
|
2002-05-26 17:39:45 +00:00
|
|
|
/* clear the filename if we get a NULL (is that possible?) */
|
|
|
|
if (g_value_get_string (value) == NULL)
|
2004-03-15 19:32:25 +00:00
|
|
|
src->location = g_strdup ("/dev/dvd");
|
2002-05-26 17:39:45 +00:00
|
|
|
/* otherwise set the new filename */
|
|
|
|
else
|
2004-03-15 19:32:25 +00:00
|
|
|
src->location = g_strdup (g_value_get_string (value));
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
case ARG_TITLE:
|
2002-09-08 04:21:36 +00:00
|
|
|
src->title = g_value_get_int (value);
|
2003-01-07 08:09:28 +00:00
|
|
|
src->did_seek = TRUE;
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
case ARG_CHAPTER:
|
2002-09-08 04:21:36 +00:00
|
|
|
src->chapter = g_value_get_int (value);
|
2003-01-07 08:09:28 +00:00
|
|
|
src->did_seek = TRUE;
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
case ARG_ANGLE:
|
2002-09-08 04:21:36 +00:00
|
|
|
src->angle = g_value_get_int (value);
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static void
|
|
|
|
dvdnavsrc_get_property (GObject * object, guint prop_id, GValue * value,
|
|
|
|
GParamSpec * pspec)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
|
|
|
DVDNavSrc *src;
|
2003-04-13 18:08:42 +00:00
|
|
|
const char *title_string;
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
/* it's not null if we got it, but it might not be ours */
|
|
|
|
g_return_if_fail (GST_IS_DVDNAVSRC (object));
|
2004-03-14 22:34:30 +00:00
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
src = DVDNAVSRC (object);
|
|
|
|
|
|
|
|
switch (prop_id) {
|
|
|
|
case ARG_LOCATION:
|
2002-09-08 04:21:36 +00:00
|
|
|
g_value_set_string (value, src->location);
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
2003-01-07 08:09:28 +00:00
|
|
|
case ARG_STREAMINFO:
|
|
|
|
g_value_set_boxed (value, src->streaminfo);
|
|
|
|
break;
|
|
|
|
case ARG_BUTTONINFO:
|
|
|
|
g_value_set_boxed (value, src->buttoninfo);
|
|
|
|
break;
|
2003-01-02 08:21:29 +00:00
|
|
|
case ARG_TITLE_STRING:
|
2004-03-14 22:34:30 +00:00
|
|
|
if (!dvdnavsrc_is_open (src)) {
|
2004-03-15 19:32:25 +00:00
|
|
|
g_value_set_string (value, "");
|
2004-03-14 22:34:30 +00:00
|
|
|
} else if (dvdnav_get_title_string (src->dvdnav, &title_string) !=
|
2004-03-15 19:32:25 +00:00
|
|
|
DVDNAV_STATUS_OK) {
|
|
|
|
g_value_set_string (value, "UNKNOWN");
|
2003-01-02 08:21:29 +00:00
|
|
|
} else {
|
2004-03-15 19:32:25 +00:00
|
|
|
g_value_set_string (value, title_string);
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
break;
|
2002-05-26 17:39:45 +00:00
|
|
|
case ARG_TITLE:
|
2002-09-08 04:21:36 +00:00
|
|
|
g_value_set_int (value, src->title);
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
case ARG_CHAPTER:
|
2002-09-08 04:21:36 +00:00
|
|
|
g_value_set_int (value, src->chapter);
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
case ARG_ANGLE:
|
2002-09-08 04:21:36 +00:00
|
|
|
g_value_set_int (value, src->angle);
|
2002-05-26 17:39:45 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_tca_seek (DVDNavSrc * src, int title, int chapter, int angle)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
|
|
|
int titles, programs, curangle, angles;
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
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);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2002-10-03 03:24:04 +00:00
|
|
|
/* Dont try to seek to track 0 - First Play program chain */
|
|
|
|
g_return_val_if_fail (src->title > 0, FALSE);
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
fprintf (stderr, "dvdnav: seeking to %d/%d/%d\n", title, chapter, angle);
|
|
|
|
/**
|
|
|
|
* Make sure our title number is valid.
|
|
|
|
*/
|
|
|
|
if (dvdnav_get_number_of_titles (src->dvdnav, &titles) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_get_number_of_titles error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-09-08 04:21:36 +00:00
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
fprintf (stderr, "There are %d titles on this DVD.\n", titles);
|
2002-09-08 04:21:36 +00:00
|
|
|
if (title < 1 || title > titles) {
|
|
|
|
fprintf (stderr, "Invalid title %d.\n", 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)
|
|
|
|
*/
|
|
|
|
if (dvdnav_title_play (src->dvdnav, title) != DVDNAV_STATUS_OK) {
|
|
|
|
fprintf (stderr, "dvdnav_title_play error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-09-08 04:21:36 +00:00
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Make sure the chapter number is valid for this title.
|
|
|
|
*/
|
2003-04-13 18:08:42 +00:00
|
|
|
if (dvdnav_get_number_of_titles (src->dvdnav, &programs) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_get_number_of_programs error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-09-08 04:21:36 +00:00
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
fprintf (stderr, "There are %d chapters in this title.\n", programs);
|
2002-10-03 03:24:04 +00:00
|
|
|
if (chapter < 0 || chapter > programs) {
|
2002-09-08 04:21:36 +00:00
|
|
|
fprintf (stderr, "Invalid chapter %d\n", chapter);
|
|
|
|
dvdnavsrc_close (src);
|
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Make sure the angle number is valid for this title.
|
|
|
|
*/
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_get_angle_info (src->dvdnav, &curangle,
|
2004-03-15 19:32:25 +00:00
|
|
|
&angles) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_get_angle_info error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-09-08 04:21:36 +00:00
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
fprintf (stderr, "There are %d angles in this title.\n", angles);
|
2004-03-14 22:34:30 +00:00
|
|
|
if (angle < 1 || angle > angles) {
|
2002-09-08 04:21:36 +00:00
|
|
|
fprintf (stderr, "Invalid angle %d\n", angle);
|
|
|
|
dvdnavsrc_close (src);
|
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* We've got enough info, time to open the title set data.
|
|
|
|
*/
|
2002-10-03 03:24:04 +00:00
|
|
|
if (src->chapter == 0) {
|
|
|
|
if (dvdnav_title_play (src->dvdnav, title) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_title_play error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-10-03 03:24:04 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (dvdnav_part_play (src->dvdnav, title, chapter) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_part_play error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-10-03 03:24:04 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
2002-09-08 04:21:36 +00:00
|
|
|
if (dvdnav_angle_change (src->dvdnav, angle) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_angle_change error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-09-08 04:21:36 +00:00
|
|
|
return FALSE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_physical_audio_stream_change (src->dvdnav, 0) != DVDNAV_STATUS_OK) {
|
|
|
|
fprintf (stderr, "dvdnav_physical_audio_stream_change error: %s\n", dvdnav_err_to_string(src->dvdnav));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (dvdnav_logical_audio_stream_change (src->dvdnav, 0) != DVDNAV_STATUS_OK) {
|
|
|
|
fprintf (stderr, "dvdnav_logical_audio_stream_change error: %s\n", dvdnav_err_to_string(src->dvdnav));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
*/
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
src->did_seek = TRUE;
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_update_streaminfo (DVDNavSrc * src)
|
2003-01-07 08:09:28 +00:00
|
|
|
{
|
|
|
|
GstCaps *caps;
|
2003-12-22 01:47:08 +00:00
|
|
|
GstStructure *structure;
|
2003-01-07 08:09:28 +00:00
|
|
|
gint64 value;
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
caps = gst_caps_new_empty ();
|
2003-12-22 01:47:08 +00:00
|
|
|
structure = gst_structure_empty_new ("application/x-gst-streaminfo");
|
|
|
|
gst_caps_append_structure (caps, structure);
|
2003-01-07 08:09:28 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnavsrc_query (src->srcpad, GST_QUERY_TOTAL, &title_format, &value)) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_set_simple (caps, "titles", G_TYPE_INT, value, NULL);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnavsrc_query (src->srcpad, GST_QUERY_POSITION, &title_format, &value)) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_set_simple (caps, "title", G_TYPE_INT, value, NULL);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnavsrc_query (src->srcpad, GST_QUERY_TOTAL, &chapter_format, &value)) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_set_simple (caps, "chapters", G_TYPE_INT, value, NULL);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnavsrc_query (src->srcpad, GST_QUERY_POSITION, &chapter_format,
|
2004-03-15 19:32:25 +00:00
|
|
|
&value)) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_set_simple (caps, "chapter", G_TYPE_INT, value, NULL);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnavsrc_query (src->srcpad, GST_QUERY_TOTAL, &angle_format, &value)) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_set_simple (caps, "angles", G_TYPE_INT, value, NULL);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnavsrc_query (src->srcpad, GST_QUERY_POSITION, &angle_format, &value)) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_set_simple (caps, "angle", G_TYPE_INT, value, NULL);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (src->streaminfo) {
|
2003-12-22 01:47:08 +00:00
|
|
|
gst_caps_free (src->streaminfo);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
|
|
|
src->streaminfo = caps;
|
|
|
|
g_object_notify (G_OBJECT (src), "streaminfo");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_update_buttoninfo (DVDNavSrc * src)
|
2003-01-07 08:09:28 +00:00
|
|
|
{
|
|
|
|
GstCaps *caps;
|
|
|
|
pci_t *pci;
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
pci = dvdnav_get_current_nav_pci (src->dvdnav);
|
2003-01-07 08:09:28 +00:00
|
|
|
|
|
|
|
if (src->buttoninfo) {
|
2004-01-06 16:42:10 +00:00
|
|
|
gint btn_ns;
|
|
|
|
|
|
|
|
/* Don't notify if there is no actual change */
|
|
|
|
if (gst_structure_get_int (gst_caps_get_structure (src->buttoninfo, 0),
|
2004-03-15 19:32:25 +00:00
|
|
|
"total", &btn_ns)
|
|
|
|
&& (btn_ns == pci->hli.hl_gi.btn_ns)) {
|
2004-01-06 16:42:10 +00:00
|
|
|
return;
|
|
|
|
}
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
2004-01-06 16:42:10 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
caps = gst_caps_new_simple ("application/x-gst-dvdnavsrc-buttoninfo",
|
|
|
|
"total", G_TYPE_INT, (gint) pci->hli.hl_gi.btn_ns, NULL);
|
2004-01-06 16:42:10 +00:00
|
|
|
|
|
|
|
if (src->buttoninfo)
|
|
|
|
gst_caps_free (src->buttoninfo);
|
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
src->buttoninfo = caps;
|
|
|
|
g_object_notify (G_OBJECT (src), "buttoninfo");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_button_pressed (DVDNavSrc * src, int button)
|
2003-01-07 08:09:28 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_pointer_select (DVDNavSrc * src, int x, int y)
|
2002-09-08 04:21:36 +00:00
|
|
|
{
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnav_mouse_select (src->dvdnav,
|
|
|
|
dvdnav_get_current_nav_pci (src->dvdnav), x, y);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_pointer_activate (DVDNavSrc * src, int x, int y)
|
2003-01-07 08:09:28 +00:00
|
|
|
{
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnav_mouse_activate (src->dvdnav,
|
|
|
|
dvdnav_get_current_nav_pci (src->dvdnav), x, y);
|
2002-09-08 04:21:36 +00:00
|
|
|
}
|
|
|
|
|
2003-01-09 08:56:58 +00:00
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_user_op (DVDNavSrc * src, int op)
|
2003-01-09 08:56:58 +00:00
|
|
|
{
|
2004-03-14 22:34:30 +00:00
|
|
|
pci_t *pci = dvdnav_get_current_nav_pci (src->dvdnav);
|
2003-04-13 11:24:55 +00:00
|
|
|
|
2003-01-09 08:56:58 +00:00
|
|
|
fprintf (stderr, "user_op %d\n", op);
|
|
|
|
/* Magic user_op ids */
|
|
|
|
switch (op) {
|
2004-03-15 19:32:25 +00:00
|
|
|
case 0: /* None */
|
2003-01-09 08:56:58 +00:00
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 1: /* Upper */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_upper_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 2: /* Lower */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_lower_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 3: /* Left */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_left_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 4: /* Right */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_right_button_select (src->dvdnav, pci) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 5: /* Activate */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_button_activate (src->dvdnav, pci) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 6: /* GoUp */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_go_up (src->dvdnav) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 7: /* TopPG */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_top_pg_search (src->dvdnav) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 8: /* PrevPG */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_prev_pg_search (src->dvdnav) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 9: /* NextPG */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_next_pg_search (src->dvdnav) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 10: /* Menu - Title */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Title) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 11: /* Menu - Root */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Root) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 12: /* Menu - Subpicture */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_menu_call (src->dvdnav,
|
2004-03-15 19:32:25 +00:00
|
|
|
DVD_MENU_Subpicture) != DVDNAV_STATUS_OK) {
|
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 13: /* Menu - Audio */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Audio) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 14: /* Menu - Angle */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Angle) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
2004-03-15 19:32:25 +00:00
|
|
|
case 15: /* Menu - Part */
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_menu_call (src->dvdnav, DVD_MENU_Part) != DVDNAV_STATUS_OK) {
|
2004-03-15 19:32:25 +00:00
|
|
|
goto naverr;
|
2003-01-09 08:56:58 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
naverr:
|
2004-02-02 17:23:32 +00:00
|
|
|
GST_ELEMENT_ERROR (src, LIBRARY, TOO_LAZY, (NULL),
|
2004-03-14 22:34:30 +00:00
|
|
|
("user op %d failure: %s", op, dvdnav_err_to_string (src->dvdnav)));
|
2003-01-09 08:56:58 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
static gchar *
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnav_get_event_name (int event)
|
2002-09-08 04:21:36 +00:00
|
|
|
{
|
|
|
|
switch (event) {
|
2004-03-14 22:34:30 +00:00
|
|
|
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_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;
|
|
|
|
case DVDNAV_WAIT:
|
|
|
|
return "DVDNAV_WAIT";
|
|
|
|
break;
|
2002-09-08 04:21:36 +00:00
|
|
|
}
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
|
|
|
|
|
|
|
static gchar *
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnav_get_read_domain_name (dvd_read_domain_t domain)
|
2002-09-08 04:21:36 +00:00
|
|
|
{
|
|
|
|
switch (domain) {
|
2004-03-14 22:34:30 +00:00
|
|
|
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;
|
2002-09-08 04:21:36 +00:00
|
|
|
}
|
|
|
|
return "UNKNOWN";
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_print_event (DVDNavSrc * src, guint8 * data, int event, int len)
|
2002-10-03 03:24:04 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (src != NULL);
|
|
|
|
g_return_if_fail (GST_IS_DVDNAVSRC (src));
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnavsrc (%p): event: %s\n", src,
|
|
|
|
dvdnav_get_event_name (event));
|
2002-10-03 03:24:04 +00:00
|
|
|
switch (event) {
|
|
|
|
case DVDNAV_BLOCK_OK:
|
|
|
|
break;
|
|
|
|
case DVDNAV_NOP:
|
|
|
|
break;
|
|
|
|
case DVDNAV_STILL_FRAME:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
|
|
|
dvdnav_still_event_t *event = (dvdnav_still_event_t *) data;
|
|
|
|
|
|
|
|
fprintf (stderr, " still frame: %d seconds\n", event->length);
|
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_SPU_STREAM_CHANGE:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
|
|
|
dvdnav_spu_stream_change_event_t *event =
|
2004-03-15 19:32:25 +00:00
|
|
|
(dvdnav_spu_stream_change_event_t *) data;
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, " physical_wide: %d\n", event->physical_wide);
|
|
|
|
fprintf (stderr, " physical_letterbox: %d\n", event->physical_letterbox);
|
|
|
|
fprintf (stderr, " physical_pan_scan: %d\n", event->physical_pan_scan);
|
|
|
|
fprintf (stderr, " logical: %d\n", event->logical);
|
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_AUDIO_STREAM_CHANGE:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
|
|
|
dvdnav_audio_stream_change_event_t *event =
|
2004-03-15 19:32:25 +00:00
|
|
|
(dvdnav_audio_stream_change_event_t *) data;
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, " physical: %d\n", event->physical);
|
|
|
|
fprintf (stderr, " logical: %d\n", event->logical);
|
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_VTS_CHANGE:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
|
|
|
dvdnav_vts_change_event_t *event = (dvdnav_vts_change_event_t *) data;
|
|
|
|
|
|
|
|
fprintf (stderr, " old_vtsN: %d\n", event->old_vtsN);
|
|
|
|
fprintf (stderr, " old_domain: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_get_read_domain_name (event->old_domain));
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, " new_vtsN: %d\n", event->new_vtsN);
|
|
|
|
fprintf (stderr, " new_domain: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_get_read_domain_name (event->new_domain));
|
2004-03-14 22:34:30 +00:00
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_CELL_CHANGE:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
|
|
|
/*dvdnav_cell_change_event_t *event = (dvdnav_cell_change_event_t *)data; */
|
|
|
|
/*fprintf (stderr, " old_cell: %p\n", event->old_cell); */
|
|
|
|
/*fprintf (stderr, " new_cell: %p\n", event->new_cell); */
|
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_NAV_PACKET:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
2003-04-13 18:08:42 +00:00
|
|
|
/*
|
2002-10-03 03:24:04 +00:00
|
|
|
dvdnav_nav_packet_event_t *event = (dvdnav_nav_packet_event_t *)data;
|
2003-01-07 08:09:28 +00:00
|
|
|
pci_t *pci;
|
|
|
|
dsi_t *dsi;
|
2003-04-13 18:08:42 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
pci = event->pci;
|
|
|
|
dsi = event->dsi;
|
2003-04-13 18:08:42 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
pci = dvdnav_get_current_nav_pci(src->dvdnav);
|
|
|
|
dsi = dvdnav_get_current_nav_dsi(src->dvdnav);
|
2002-10-03 03:24:04 +00:00
|
|
|
fprintf (stderr, " pci: %p\n", event->pci);
|
|
|
|
fprintf (stderr, " dsi: %p\n", event->dsi);
|
2003-04-13 18:08:42 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
navPrint_PCI(pci);
|
|
|
|
navPrint_DSI(dsi);
|
2003-04-13 18:08:42 +00:00
|
|
|
*/
|
2004-03-14 22:34:30 +00:00
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_STOP:
|
|
|
|
break;
|
|
|
|
case DVDNAV_HIGHLIGHT:
|
2004-03-14 22:34:30 +00:00
|
|
|
{
|
|
|
|
dvdnav_highlight_event_t *event = (dvdnav_highlight_event_t *) data;
|
|
|
|
|
|
|
|
fprintf (stderr, " display: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
event->display == 0 ? "hide" : (event->display ==
|
|
|
|
1 ? "show" : "unknown")
|
|
|
|
);
|
2004-03-14 22:34:30 +00:00
|
|
|
if (event->display == 1) {
|
2004-03-15 19:32:25 +00:00
|
|
|
fprintf (stderr, " palette: %08x\n", event->palette);
|
|
|
|
fprintf (stderr, " coords (%u, %u) - (%u, %u)\n", event->sx, event->sy,
|
|
|
|
event->ex, event->ey);
|
|
|
|
fprintf (stderr, " pts: %u\n", event->pts);
|
|
|
|
fprintf (stderr, " button: %u\n", event->buttonN);
|
2002-10-03 03:24:04 +00:00
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
}
|
2002-10-03 03:24:04 +00:00
|
|
|
break;
|
|
|
|
case DVDNAV_SPU_CLUT_CHANGE:
|
|
|
|
break;
|
|
|
|
case DVDNAV_HOP_CHANNEL:
|
|
|
|
break;
|
2003-04-13 18:08:42 +00:00
|
|
|
case DVDNAV_WAIT:
|
|
|
|
break;
|
2002-10-03 03:24:04 +00:00
|
|
|
default:
|
|
|
|
fprintf (stderr, " event id: %d\n", event);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-08 16:08:10 +00:00
|
|
|
static GstData *
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_get (GstPad * pad)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
2002-09-08 04:21:36 +00:00
|
|
|
DVDNavSrc *src;
|
2003-01-07 08:09:28 +00:00
|
|
|
int event, len;
|
|
|
|
GstBuffer *buf;
|
|
|
|
guint8 *data;
|
|
|
|
gboolean have_buf;
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
g_return_val_if_fail (pad != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
src = DVDNAVSRC (gst_pad_get_parent (pad));
|
|
|
|
g_return_val_if_fail (dvdnavsrc_is_open (src), NULL);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
if (src->did_seek) {
|
|
|
|
GstEvent *event;
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
src->did_seek = FALSE;
|
2003-06-29 19:46:09 +00:00
|
|
|
GST_DEBUG ("dvdnavsrc sending discont");
|
2003-01-07 08:09:28 +00:00
|
|
|
event = gst_event_new_discontinuous (FALSE, 0);
|
|
|
|
src->need_flush = FALSE;
|
2003-10-09 02:23:01 +00:00
|
|
|
return GST_DATA (event);
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
|
|
|
if (src->need_flush) {
|
|
|
|
src->need_flush = FALSE;
|
2003-06-29 19:46:09 +00:00
|
|
|
GST_DEBUG ("dvdnavsrc sending flush");
|
2004-03-14 22:34:30 +00:00
|
|
|
return GST_DATA (gst_event_new_flush ());
|
2003-01-07 08:09:28 +00:00
|
|
|
}
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
/* loop processing blocks until data is pushed */
|
|
|
|
have_buf = FALSE;
|
|
|
|
while (!have_buf) {
|
2003-12-22 01:47:08 +00:00
|
|
|
buf = gst_buffer_new_and_alloc (DVD_VIDEO_LB_LEN);
|
2002-09-08 08:34:34 +00:00
|
|
|
if (!buf) {
|
2004-03-14 22:34:30 +00:00
|
|
|
GST_ELEMENT_ERROR (src, CORE, TOO_LAZY, (NULL),
|
2004-03-15 19:32:25 +00:00
|
|
|
("Failed to create a new GstBuffer"));
|
2003-01-07 08:09:28 +00:00
|
|
|
return NULL;
|
2002-09-08 08:34:34 +00:00
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
data = GST_BUFFER_DATA (buf);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2003-01-07 08:09:28 +00:00
|
|
|
if (dvdnav_get_next_block (src->dvdnav, data, &event, &len) !=
|
2004-03-15 19:32:25 +00:00
|
|
|
DVDNAV_STATUS_OK) {
|
2004-02-02 17:23:32 +00:00
|
|
|
GST_ELEMENT_ERROR (src, STREAM, DECODE, (NULL),
|
2004-03-15 19:32:25 +00:00
|
|
|
("dvdnav_get_next_block error: %s\n",
|
|
|
|
dvdnav_err_to_string (src->dvdnav)));
|
2003-01-07 08:09:28 +00:00
|
|
|
return NULL;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (event) {
|
2002-09-08 04:21:36 +00:00
|
|
|
case DVDNAV_NOP:
|
2004-03-15 19:32:25 +00:00
|
|
|
break;
|
2003-01-07 08:09:28 +00:00
|
|
|
case DVDNAV_BLOCK_OK:
|
2004-03-15 19:32:25 +00:00
|
|
|
g_return_val_if_fail (GST_BUFFER_DATA (buf) != NULL, NULL);
|
|
|
|
g_return_val_if_fail (GST_BUFFER_SIZE (buf) == DVD_VIDEO_LB_LEN, NULL);
|
|
|
|
have_buf = TRUE;
|
|
|
|
break;
|
2002-09-08 04:21:36 +00:00
|
|
|
case DVDNAV_STILL_FRAME:
|
2004-03-15 19:32:25 +00:00
|
|
|
/* FIXME: we should pause for event->length seconds before
|
|
|
|
* dvdnav_still_skip */
|
|
|
|
dvdnavsrc_print_event (src, data, event, len);
|
|
|
|
if (dvdnav_still_skip (src->dvdnav) != DVDNAV_STATUS_OK) {
|
|
|
|
GST_ELEMENT_ERROR (src, STREAM, TOO_LAZY, (NULL),
|
|
|
|
("dvdnav_still_skip error: %s\n",
|
|
|
|
dvdnav_err_to_string (src->dvdnav)));
|
|
|
|
/* FIXME: close the stream??? */
|
|
|
|
}
|
|
|
|
break;
|
2003-01-07 08:09:28 +00:00
|
|
|
case DVDNAV_STOP:
|
2004-03-15 19:32:25 +00:00
|
|
|
GST_DEBUG ("dvdnavsrc sending eos");
|
|
|
|
gst_element_set_eos (GST_ELEMENT (src));
|
|
|
|
dvdnavsrc_close (src);
|
|
|
|
buf = GST_BUFFER (gst_event_new (GST_EVENT_EOS));
|
|
|
|
have_buf = TRUE;
|
|
|
|
break;
|
2002-09-08 04:21:36 +00:00
|
|
|
case DVDNAV_CELL_CHANGE:
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnavsrc_update_streaminfo (src);
|
|
|
|
break;
|
2002-09-08 04:21:36 +00:00
|
|
|
case DVDNAV_NAV_PACKET:
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnavsrc_update_buttoninfo (src);
|
|
|
|
break;
|
2003-07-26 17:27:10 +00:00
|
|
|
case DVDNAV_WAIT:
|
2004-03-15 19:32:25 +00:00
|
|
|
/* FIXME: supposed to make sure all the data has made
|
|
|
|
* it to the sinks before skipping the wait
|
|
|
|
*/
|
|
|
|
dvdnavsrc_print_event (src, data, event, len);
|
|
|
|
dvdnav_wait_skip (src->dvdnav);
|
|
|
|
break;
|
2004-01-06 16:42:10 +00:00
|
|
|
case DVDNAV_HOP_CHANNEL:
|
2004-03-15 19:32:25 +00:00
|
|
|
/* Indicates a time discontinuity, and the downstream should
|
|
|
|
* flush
|
|
|
|
*/
|
|
|
|
dvdnavsrc_print_event (src, data, event, len);
|
|
|
|
buf = GST_BUFFER (gst_event_new (GST_EVENT_DISCONTINUOUS));
|
|
|
|
have_buf = TRUE;
|
|
|
|
break;
|
2004-01-06 16:42:10 +00:00
|
|
|
case DVDNAV_HIGHLIGHT:
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnavsrc_print_event (src, data, event, len);
|
|
|
|
break;
|
2004-01-06 16:42:10 +00:00
|
|
|
|
2004-03-15 19:32:25 +00:00
|
|
|
/* SPU_STREAM_CHANGE provides MPEG stream numbers for different
|
|
|
|
* formats of the video, eg letterbox/pan&scan
|
|
|
|
*/
|
2003-01-07 08:09:28 +00:00
|
|
|
case DVDNAV_SPU_STREAM_CHANGE:
|
2004-03-15 19:32:25 +00:00
|
|
|
/* AUDIO_STREAM_CHANGE indicates that the user selected an alternate
|
|
|
|
* audio stream (from a menu)
|
|
|
|
*/
|
2003-01-07 08:09:28 +00:00
|
|
|
case DVDNAV_AUDIO_STREAM_CHANGE:
|
2004-03-15 19:32:25 +00:00
|
|
|
/* VTS_CHANGE Indicates a change in VTS (Video Title Set) */
|
2004-01-06 16:42:10 +00:00
|
|
|
case DVDNAV_VTS_CHANGE:
|
2002-09-08 04:21:36 +00:00
|
|
|
case DVDNAV_SPU_CLUT_CHANGE:
|
2002-05-26 17:39:45 +00:00
|
|
|
default:
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnavsrc_print_event (src, data, event, len);
|
|
|
|
break;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
return GST_DATA (buf);
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* open the file, necessary to go to RUNNING state */
|
2004-03-14 22:34:30 +00:00
|
|
|
static gboolean
|
|
|
|
dvdnavsrc_open (DVDNavSrc * src)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (src != NULL, FALSE);
|
2004-03-14 22:34:30 +00:00
|
|
|
g_return_val_if_fail (GST_IS_DVDNAVSRC (src), FALSE);
|
2002-09-08 04:21:36 +00:00
|
|
|
g_return_val_if_fail (!dvdnavsrc_is_open (src), FALSE);
|
|
|
|
g_return_val_if_fail (src->location != NULL, FALSE);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
if (dvdnav_open (&src->dvdnav, (char *) src->location) != DVDNAV_STATUS_OK) {
|
|
|
|
fprintf (stderr, "dvdnav_open error: %s location: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav), src->location);
|
2002-05-26 17:39:45 +00:00
|
|
|
return FALSE;
|
2002-09-08 04:21:36 +00:00
|
|
|
}
|
2002-09-08 08:34:34 +00:00
|
|
|
|
|
|
|
GST_FLAG_SET (src, DVDNAVSRC_OPEN);
|
|
|
|
|
2002-10-03 03:24:04 +00:00
|
|
|
/* 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];
|
2004-03-14 22:34:30 +00:00
|
|
|
int event, buflen = sizeof (buf);
|
|
|
|
|
|
|
|
fprintf (stderr, "+XXX\n");
|
|
|
|
if (dvdnav_get_next_block (src->dvdnav, buf, &event,
|
2004-03-15 19:32:25 +00:00
|
|
|
&buflen) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "pre seek dvdnav_get_next_block error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-10-03 03:24:04 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
dvdnavsrc_print_event (src, buf, event, buflen);
|
|
|
|
/*
|
2004-03-14 22:34:30 +00:00
|
|
|
while (dvdnav_get_next_block(src->dvdnav, buf, &event, &buflen) == DVDNAV_STATUS_OK) {
|
|
|
|
if (event != DVDNAV_BLOCK_OK)
|
|
|
|
dvdnavsrc_print_event (src, buf, event, buflen);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
fprintf (stderr, "pre seek dvdnav_get_next_block error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "-XXX\n");
|
|
|
|
|
|
|
|
if (!dvdnavsrc_tca_seek (src, src->title, src->chapter, src->angle))
|
2002-10-03 03:24:04 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2004-03-14 22:34:30 +00:00
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* close the file */
|
2002-09-08 04:21:36 +00:00
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_close (DVDNavSrc * src)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
2002-09-08 04:21:36 +00:00
|
|
|
g_return_val_if_fail (src != NULL, FALSE);
|
2004-03-14 22:34:30 +00:00
|
|
|
g_return_val_if_fail (GST_IS_DVDNAVSRC (src), FALSE);
|
2002-09-08 04:21:36 +00:00
|
|
|
g_return_val_if_fail (dvdnavsrc_is_open (src), FALSE);
|
|
|
|
g_return_val_if_fail (src->dvdnav != NULL, FALSE);
|
2002-05-26 17:39:45 +00:00
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
if (dvdnav_close (src->dvdnav) != DVDNAV_STATUS_OK) {
|
2004-03-14 22:34:30 +00:00
|
|
|
fprintf (stderr, "dvdnav_close error: %s\n",
|
2004-03-15 19:32:25 +00:00
|
|
|
dvdnav_err_to_string (src->dvdnav));
|
2002-09-08 04:21:36 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2002-05-26 17:39:45 +00:00
|
|
|
|
|
|
|
GST_FLAG_UNSET (src, DVDNAVSRC_OPEN);
|
2002-09-08 04:21:36 +00:00
|
|
|
|
|
|
|
return TRUE;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static GstElementStateReturn
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_change_state (GstElement * element)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
2002-09-08 04:21:36 +00:00
|
|
|
DVDNavSrc *src;
|
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
g_return_val_if_fail (GST_IS_DVDNAVSRC (element), GST_STATE_FAILURE);
|
|
|
|
|
2002-09-08 04:21:36 +00:00
|
|
|
src = DVDNAVSRC (element);
|
|
|
|
|
|
|
|
switch (GST_STATE_TRANSITION (element)) {
|
|
|
|
case GST_STATE_NULL_TO_READY:
|
|
|
|
break;
|
|
|
|
case GST_STATE_READY_TO_PAUSED:
|
2002-09-08 08:34:34 +00:00
|
|
|
if (!dvdnavsrc_is_open (src)) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (!dvdnavsrc_open (src)) {
|
|
|
|
return GST_STATE_FAILURE;
|
|
|
|
}
|
2002-09-08 04:21:36 +00:00
|
|
|
}
|
2003-01-07 08:09:28 +00:00
|
|
|
src->streaminfo = NULL;
|
2002-09-08 04:21:36 +00:00
|
|
|
break;
|
|
|
|
case GST_STATE_PAUSED_TO_PLAYING:
|
|
|
|
break;
|
|
|
|
case GST_STATE_PLAYING_TO_PAUSED:
|
|
|
|
break;
|
|
|
|
case GST_STATE_PAUSED_TO_READY:
|
2002-09-08 08:34:34 +00:00
|
|
|
if (dvdnavsrc_is_open (src)) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (!dvdnavsrc_close (src)) {
|
|
|
|
return GST_STATE_FAILURE;
|
|
|
|
}
|
2002-09-08 08:34:34 +00:00
|
|
|
}
|
2002-09-08 04:21:36 +00:00
|
|
|
break;
|
|
|
|
case GST_STATE_READY_TO_NULL:
|
|
|
|
break;
|
2002-05-26 17:39:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2003-01-02 08:21:29 +00:00
|
|
|
static const GstEventMask *
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_get_event_mask (GstPad * pad)
|
2003-01-02 08:21:29 +00:00
|
|
|
{
|
|
|
|
static const GstEventMask masks[] = {
|
2004-03-14 22:34:30 +00:00
|
|
|
{GST_EVENT_SEEK, GST_SEEK_METHOD_SET |
|
2004-03-15 19:32:25 +00:00
|
|
|
GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH},
|
2004-03-14 22:34:30 +00:00
|
|
|
/*
|
|
|
|
{GST_EVENT_SEEK_SEGMENT, GST_SEEK_METHOD_SET |
|
|
|
|
GST_SEEK_METHOD_CUR |
|
|
|
|
GST_SEEK_METHOD_END |
|
|
|
|
GST_SEEK_FLAG_FLUSH },
|
|
|
|
*/
|
|
|
|
{GST_EVENT_NAVIGATION, GST_EVENT_FLAG_NONE},
|
2003-01-02 08:21:29 +00:00
|
|
|
{0,}
|
|
|
|
};
|
|
|
|
|
|
|
|
return masks;
|
|
|
|
}
|
|
|
|
|
2004-01-06 16:42:10 +00:00
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnav_handle_navigation_event (DVDNavSrc * src, GstEvent * event)
|
2004-01-06 16:42:10 +00:00
|
|
|
{
|
|
|
|
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);
|
2004-03-14 22:34:30 +00:00
|
|
|
|
|
|
|
if (strcmp (event_type, "key-press") == 0) {
|
|
|
|
const char *key = gst_structure_get_string (structure, "key");
|
2004-01-06 16:42:10 +00:00
|
|
|
|
|
|
|
g_assert (key != NULL);
|
|
|
|
g_print ("dvdnavsrc got a keypress: %s\n", key);
|
2004-03-14 22:34:30 +00:00
|
|
|
} else if (strcmp (event_type, "mouse-move") == 0) {
|
2004-01-06 16:42:10 +00:00
|
|
|
double x, y;
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
gst_structure_get_double (structure, "pointer_x", &x);
|
|
|
|
gst_structure_get_double (structure, "pointer_y", &y);
|
2004-01-06 16:42:10 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_pointer_select (src, (int) x, (int) y);
|
|
|
|
} else if (strcmp (event_type, "mouse-button-release") == 0) {
|
2004-01-06 16:42:10 +00:00
|
|
|
double x, y;
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
gst_structure_get_double (structure, "pointer_x", &x);
|
|
|
|
gst_structure_get_double (structure, "pointer_y", &y);
|
2004-01-06 16:42:10 +00:00
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_pointer_activate (src, (int) x, (int) y);
|
2004-01-06 16:42:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2003-01-02 08:21:29 +00:00
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_event (GstPad * pad, GstEvent * event)
|
2003-01-02 08:21:29 +00:00
|
|
|
{
|
|
|
|
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;
|
2003-01-08 07:49:16 +00:00
|
|
|
int origin;
|
2004-03-14 22:34:30 +00:00
|
|
|
|
|
|
|
format = GST_EVENT_SEEK_FORMAT (event);
|
|
|
|
offset = GST_EVENT_SEEK_OFFSET (event);
|
2003-01-02 08:21:29 +00:00
|
|
|
|
|
|
|
switch (format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
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;
|
|
|
|
}
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
2003-01-07 08:09:28 +00:00
|
|
|
src->did_seek = TRUE;
|
2004-03-14 22:34:30 +00:00
|
|
|
src->need_flush = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH;
|
2003-01-02 08:21:29 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-01-06 16:42:10 +00:00
|
|
|
case GST_EVENT_NAVIGATION:
|
|
|
|
res = dvdnav_handle_navigation_event (src, event);
|
2003-01-07 08:09:28 +00:00
|
|
|
case GST_EVENT_FLUSH:
|
|
|
|
src->need_flush = TRUE;
|
|
|
|
break;
|
2003-01-02 08:21:29 +00:00
|
|
|
default:
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FALSE) {
|
2004-03-14 22:34:30 +00:00
|
|
|
error:
|
2003-01-02 08:21:29 +00:00
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
gst_event_unref (event);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const GstFormat *
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_get_formats (GstPad * pad)
|
2003-01-02 08:21:29 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
static GstFormat formats[] = {
|
|
|
|
/*
|
2004-03-14 22:34:30 +00:00
|
|
|
GST_FORMAT_TIME,
|
|
|
|
GST_FORMAT_BYTES,
|
|
|
|
GST_FORMAT_DEFAULT,
|
|
|
|
*/
|
2004-03-15 19:32:25 +00:00
|
|
|
0, /* filled later */
|
|
|
|
0, /* filled later */
|
|
|
|
0, /* filled later */
|
|
|
|
0, /* filled later */
|
2003-01-02 08:21:29 +00:00
|
|
|
0
|
|
|
|
};
|
|
|
|
static gboolean format_initialized = FALSE;
|
|
|
|
|
|
|
|
if (!format_initialized) {
|
2004-03-14 22:34:30 +00:00
|
|
|
for (i = 0; formats[i] != 0; i++) {
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
formats[i++] = sector_format;
|
|
|
|
formats[i++] = title_format;
|
|
|
|
formats[i++] = chapter_format;
|
|
|
|
formats[i++] = angle_format;
|
|
|
|
format_initialized = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return formats;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_convert (GstPad * pad,
|
|
|
|
GstFormat src_format, gint64 src_value,
|
|
|
|
GstFormat * dest_format, gint64 * dest_value)
|
2003-01-02 08:21:29 +00:00
|
|
|
{
|
|
|
|
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_TIME:
|
|
|
|
switch (*dest_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
case GST_FORMAT_BYTES:
|
|
|
|
src_value <<= 2; /* 4 bytes per sample */
|
|
|
|
case GST_FORMAT_DEFAULT:
|
|
|
|
*dest_value = src_value * 44100 / GST_SECOND;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (*dest_format == track_format || *dest_format == sector_format) {
|
|
|
|
gint sector =
|
|
|
|
(src_value * 44100) / ((CD_FRAMESIZE_RAW >> 2) * GST_SECOND);
|
|
|
|
|
|
|
|
if (*dest_format == sector_format) {
|
|
|
|
*dest_value = sector;
|
|
|
|
} else {
|
|
|
|
*dest_value = cdda_sector_gettrack (src->d, sector) - 1;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
return FALSE;
|
|
|
|
break;
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GST_FORMAT_BYTES:
|
|
|
|
src_value >>= 2;
|
2003-05-24 10:35:12 +00:00
|
|
|
case GST_FORMAT_DEFAULT:
|
2003-01-02 08:21:29 +00:00
|
|
|
switch (*dest_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
case GST_FORMAT_BYTES:
|
|
|
|
*dest_value = src_value * 4;
|
|
|
|
break;
|
|
|
|
case GST_FORMAT_TIME:
|
|
|
|
*dest_value = src_value * GST_SECOND / 44100;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (*dest_format == track_format || *dest_format == sector_format) {
|
|
|
|
gint sector = src_value / (CD_FRAMESIZE_RAW >> 2);
|
|
|
|
|
|
|
|
if (*dest_format == track_format) {
|
|
|
|
*dest_value = cdda_sector_gettrack (src->d, sector) - 1;
|
|
|
|
} else {
|
|
|
|
*dest_value = sector;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
return FALSE;
|
|
|
|
break;
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
gint sector;
|
|
|
|
|
|
|
|
if (src_format == track_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
/* some sanity checks */
|
|
|
|
if (src_value < 0 || src_value > src->d->tracks)
|
|
|
|
return FALSE;
|
2003-01-02 08:21:29 +00:00
|
|
|
|
2004-03-15 19:32:25 +00:00
|
|
|
sector = cdda_track_firstsector (src->d, src_value + 1);
|
2004-03-14 22:34:30 +00:00
|
|
|
} else if (src_format == sector_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
sector = src_value;
|
2004-03-14 22:34:30 +00:00
|
|
|
} else
|
2004-03-15 19:32:25 +00:00
|
|
|
return FALSE;
|
2003-01-02 08:21:29 +00:00
|
|
|
|
|
|
|
switch (*dest_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
case GST_FORMAT_TIME:
|
|
|
|
*dest_value = ((CD_FRAMESIZE_RAW >> 2) * sector * GST_SECOND) / 44100;
|
|
|
|
break;
|
|
|
|
case GST_FORMAT_BYTES:
|
|
|
|
sector <<= 2;
|
|
|
|
case GST_FORMAT_DEFAULT:
|
|
|
|
*dest_value = (CD_FRAMESIZE_RAW >> 2) * sector;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (*dest_format == sector_format) {
|
|
|
|
*dest_value = sector;
|
|
|
|
} else if (*dest_format == track_format) {
|
|
|
|
/* if we go past the last sector, make sure to report the last track */
|
|
|
|
if (sector > src->last_sector)
|
|
|
|
*dest_value = cdda_sector_gettrack (src->d, src->last_sector);
|
|
|
|
else
|
|
|
|
*dest_value = cdda_sector_gettrack (src->d, sector) - 1;
|
|
|
|
} else
|
|
|
|
return FALSE;
|
|
|
|
break;
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
static const GstQueryType *
|
|
|
|
dvdnavsrc_get_query_types (GstPad * pad)
|
2003-01-02 08:21:29 +00:00
|
|
|
{
|
|
|
|
static const GstQueryType src_query_types[] = {
|
|
|
|
GST_QUERY_TOTAL,
|
|
|
|
GST_QUERY_POSITION,
|
|
|
|
0
|
|
|
|
};
|
2004-03-15 19:32:25 +00:00
|
|
|
|
2003-01-02 08:21:29 +00:00
|
|
|
return src_query_types;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
dvdnavsrc_query (GstPad * pad, GstQueryType type,
|
|
|
|
GstFormat * format, gint64 * value)
|
2003-01-02 08:21:29 +00:00
|
|
|
{
|
|
|
|
gboolean res = TRUE;
|
|
|
|
DVDNavSrc *src;
|
|
|
|
int titles, title;
|
|
|
|
int parts, part;
|
|
|
|
int angles, angle;
|
2003-01-08 07:49:16 +00:00
|
|
|
unsigned int pos, len;
|
2003-01-02 08:21:29 +00:00
|
|
|
|
|
|
|
src = DVDNAVSRC (gst_pad_get_parent (pad));
|
|
|
|
|
|
|
|
if (!GST_FLAG_IS_SET (src, DVDNAVSRC_OPEN))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case GST_QUERY_TOTAL:
|
2003-01-08 07:49:16 +00:00
|
|
|
if (*format == sector_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_get_position (src->dvdnav, &pos, &len) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = len;
|
2003-01-08 07:49:16 +00:00
|
|
|
} else if (*format == title_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_get_number_of_titles (src->dvdnav,
|
|
|
|
&titles) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = titles;
|
2003-01-02 08:21:29 +00:00
|
|
|
} else if (*format == chapter_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_get_number_of_titles (src->dvdnav,
|
|
|
|
&parts) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = parts;
|
2003-01-02 08:21:29 +00:00
|
|
|
} else if (*format == angle_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_get_angle_info (src->dvdnav, &angle,
|
|
|
|
&angles) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = angles;
|
2003-01-02 08:21:29 +00:00
|
|
|
} else {
|
2004-03-15 19:32:25 +00:00
|
|
|
res = FALSE;
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GST_QUERY_POSITION:
|
2003-01-08 07:49:16 +00:00
|
|
|
if (*format == sector_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_get_position (src->dvdnav, &pos, &len) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = pos;
|
2003-01-08 07:49:16 +00:00
|
|
|
} else if (*format == title_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_current_title_info (src->dvdnav, &title,
|
|
|
|
&part) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = title;
|
2003-01-02 08:21:29 +00:00
|
|
|
} else if (*format == chapter_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_current_title_info (src->dvdnav, &title,
|
|
|
|
&part) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = part;
|
2003-01-02 08:21:29 +00:00
|
|
|
} else if (*format == angle_format) {
|
2004-03-15 19:32:25 +00:00
|
|
|
if (dvdnav_get_angle_info (src->dvdnav, &angle,
|
|
|
|
&angles) != DVDNAV_STATUS_OK) {
|
|
|
|
res = FALSE;
|
|
|
|
}
|
|
|
|
*value = angle;
|
2003-01-02 08:21:29 +00:00
|
|
|
} else {
|
2004-03-15 19:32:25 +00:00
|
|
|
res = FALSE;
|
2003-01-02 08:21:29 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
res = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
static gboolean
|
2004-03-14 22:34:30 +00:00
|
|
|
plugin_init (GstPlugin * plugin)
|
2002-05-26 17:39:45 +00:00
|
|
|
{
|
2004-03-14 22:34:30 +00:00
|
|
|
if (!gst_element_register (plugin, "dvdnavsrc", GST_RANK_NONE,
|
2004-03-15 19:32:25 +00:00
|
|
|
GST_TYPE_DVDNAVSRC))
|
2003-11-01 15:16:06 +00:00
|
|
|
return FALSE;
|
2004-03-14 22:34:30 +00:00
|
|
|
|
2002-05-26 17:39:45 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2004-03-14 22:34:30 +00:00
|
|
|
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)
|