/* GStreamer * Copyright (C) <2008> Edward Hervey * * 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. */ /** * SECTION:element-hdv1394src * * Read MPEG-TS data from firewire port. * * * Example launch line * |[ * gst-launch hdv1394src ! queue ! decodebin name=d ! queue ! xvimagesink d. ! queue ! alsasink * ]| captures from the firewire port and plays the streams. * |[ * gst-launch hdv1394src ! queue ! filesink location=mydump.ts * ]| capture to a disk file * */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include "gsthdv1394src.h" #include "gst1394probe.h" #define CONTROL_STOP 'S' /* stop the select call */ #define CONTROL_SOCKETS(src) src->control_sock #define WRITE_SOCKET(src) src->control_sock[1] #define READ_SOCKET(src) src->control_sock[0] #define SEND_COMMAND(src, command) \ G_STMT_START { \ int _res; unsigned char c; c = command; \ _res = write (WRITE_SOCKET(src), &c, 1); \ } G_STMT_END #define READ_COMMAND(src, command, res) \ G_STMT_START { \ res = read(READ_SOCKET(src), &command, 1); \ } G_STMT_END GST_DEBUG_CATEGORY_STATIC (hdv1394src_debug); #define GST_CAT_DEFAULT (hdv1394src_debug) #define DEFAULT_PORT -1 #define DEFAULT_CHANNEL 63 #define DEFAULT_USE_AVC TRUE #define DEFAULT_GUID 0 enum { PROP_0, PROP_PORT, PROP_CHANNEL, PROP_USE_AVC, PROP_GUID, PROP_DEVICE_NAME }; static const GstElementDetails gst_hdv1394src_details = GST_ELEMENT_DETAILS ("Firewire (1394) HDV video source", "Source/Video", "Source for MPEG-TS video data from firewire port", "Edward Hervey "); static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("video/mpegts,systemstream=(boolean)true,packetsize=(int)188") ); static void gst_hdv1394src_uri_handler_init (gpointer g_iface, gpointer iface_data); static void gst_hdv1394src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_hdv1394src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void gst_hdv1394src_dispose (GObject * object); static gboolean gst_hdv1394src_start (GstBaseSrc * bsrc); static gboolean gst_hdv1394src_stop (GstBaseSrc * bsrc); static gboolean gst_hdv1394src_unlock (GstBaseSrc * bsrc); static GstFlowReturn gst_hdv1394src_create (GstPushSrc * psrc, GstBuffer ** buf); static void gst_hdv1394src_update_device_name (GstHDV1394Src * src); static void _do_init (GType type) { static const GInterfaceInfo urihandler_info = { gst_hdv1394src_uri_handler_init, NULL, NULL, }; g_type_add_interface_static (type, GST_TYPE_URI_HANDLER, &urihandler_info); gst_1394_type_add_property_probe_interface (type); GST_DEBUG_CATEGORY_INIT (hdv1394src_debug, "hdv1394src", 0, "MPEG-TS firewire source"); } GST_BOILERPLATE_FULL (GstHDV1394Src, gst_hdv1394src, GstPushSrc, GST_TYPE_PUSH_SRC, _do_init); static void gst_hdv1394src_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 (&src_factory)); gst_element_class_set_details (element_class, &gst_hdv1394src_details); } static void gst_hdv1394src_class_init (GstHDV1394SrcClass * klass) { GObjectClass *gobject_class; GstBaseSrcClass *gstbasesrc_class; GstPushSrcClass *gstpushsrc_class; gobject_class = (GObjectClass *) klass; gstbasesrc_class = (GstBaseSrcClass *) klass; gstpushsrc_class = (GstPushSrcClass *) klass; gobject_class->set_property = gst_hdv1394src_set_property; gobject_class->get_property = gst_hdv1394src_get_property; gobject_class->dispose = gst_hdv1394src_dispose; g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_PORT, g_param_spec_int ("port", "Port", "Port number (-1 automatic)", -1, 16, DEFAULT_PORT, G_PARAM_READWRITE)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_CHANNEL, g_param_spec_int ("channel", "Channel", "Channel number for listening", 0, 64, DEFAULT_CHANNEL, G_PARAM_READWRITE)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_USE_AVC, g_param_spec_boolean ("use-avc", "Use AV/C", "Use AV/C VTR control", DEFAULT_USE_AVC, G_PARAM_READWRITE)); g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_GUID, g_param_spec_uint64 ("guid", "GUID", "select one of multiple DV devices by its GUID. use a hexadecimal " "like 0xhhhhhhhhhhhhhhhh. (0 = no guid)", 0, G_MAXUINT64, DEFAULT_GUID, G_PARAM_READWRITE)); /** * GstHDV1394Src:device-name * * Descriptive name of the currently opened device * * Since: 0.10.7 **/ g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DEVICE_NAME, g_param_spec_string ("device-name", "device name", "user-friendly name of the device", "Default", G_PARAM_READABLE)); gstbasesrc_class->negotiate = NULL; gstbasesrc_class->start = gst_hdv1394src_start; gstbasesrc_class->stop = gst_hdv1394src_stop; gstbasesrc_class->unlock = gst_hdv1394src_unlock; gstpushsrc_class->create = gst_hdv1394src_create; } static void gst_hdv1394src_init (GstHDV1394Src * dv1394src, GstHDV1394SrcClass * klass) { GstPad *srcpad = GST_BASE_SRC_PAD (dv1394src); gst_base_src_set_live (GST_BASE_SRC (dv1394src), TRUE); gst_pad_use_fixed_caps (srcpad); dv1394src->port = DEFAULT_PORT; dv1394src->channel = DEFAULT_CHANNEL; dv1394src->use_avc = DEFAULT_USE_AVC; dv1394src->guid = DEFAULT_GUID; dv1394src->uri = g_strdup_printf ("hdv://%d", dv1394src->port); dv1394src->device_name = g_strdup_printf ("Default"); READ_SOCKET (dv1394src) = -1; WRITE_SOCKET (dv1394src) = -1; dv1394src->frame_sequence = 0; } static void gst_hdv1394src_dispose (GObject * object) { GstHDV1394Src *src = GST_HDV1394SRC (object); g_free (src->uri); src->uri = NULL; g_free (src->device_name); src->device_name = NULL; G_OBJECT_CLASS (parent_class)->dispose (object); } static void gst_hdv1394src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstHDV1394Src *filter = GST_HDV1394SRC (object); switch (prop_id) { case PROP_PORT: filter->port = g_value_get_int (value); g_free (filter->uri); filter->uri = g_strdup_printf ("hdv://%d", filter->port); break; case PROP_CHANNEL: filter->channel = g_value_get_int (value); break; case PROP_USE_AVC: filter->use_avc = g_value_get_boolean (value); break; case PROP_GUID: filter->guid = g_value_get_uint64 (value); gst_hdv1394src_update_device_name (filter); break; default: break; } } static void gst_hdv1394src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstHDV1394Src *filter = GST_HDV1394SRC (object); switch (prop_id) { case PROP_PORT: g_value_set_int (value, filter->port); break; case PROP_CHANNEL: g_value_set_int (value, filter->channel); break; case PROP_USE_AVC: g_value_set_boolean (value, filter->use_avc); break; case PROP_GUID: g_value_set_uint64 (value, filter->guid); break; case PROP_DEVICE_NAME: g_value_set_string (value, filter->device_name); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static GstHDV1394Src * gst_hdv1394src_from_raw1394handle (raw1394handle_t handle) { iec61883_mpeg2_t mpeg2 = (iec61883_mpeg2_t) raw1394_get_userdata (handle); return GST_HDV1394SRC (iec61883_mpeg2_get_callback_data (mpeg2)); } /* Within one loop iteration (which may call _receive() many times), it seems * as though '*data' will always be different. * * We can therefore assume that any '*data' given to us will stay allocated until * the next loop iteration. */ static int gst_hdv1394src_iec61883_receive (unsigned char *data, int len, unsigned int dropped, void *cbdata) { GstHDV1394Src *dv1394src = GST_HDV1394SRC (cbdata); GST_LOG ("data:%p, len:%d, dropped:%d", data, len, dropped); /* error out if we don't have enough room ! */ if (G_UNLIKELY (dv1394src->outoffset > (2048 * 188 - len))) return -1; if (G_LIKELY (len == IEC61883_MPEG2_TSP_SIZE)) { memcpy ((guint8 *) dv1394src->outdata + dv1394src->outoffset, data, len); dv1394src->outoffset += len; } dv1394src->frame_sequence++; return 0; } /* * When an ieee1394 bus reset happens, usually a device has been removed * or added. We send a message on the message bus with the node count * and whether the capture device used in this element connected, disconnected * or was unchanged * Message structure: * nodecount - integer with number of nodes on bus * current-device-change - integer (1 if device connected, 0 if no change to * current device status, -1 if device disconnected) */ static int gst_hdv1394src_bus_reset (raw1394handle_t handle, unsigned int generation) { GstHDV1394Src *src; gint nodecount; GstMessage *message; GstStructure *structure; gint current_device_change; gint i; src = gst_hdv1394src_from_raw1394handle (handle); GST_INFO_OBJECT (src, "have bus reset"); /* update generation - told to do so by docs */ raw1394_update_generation (handle, generation); nodecount = raw1394_get_nodecount (handle); /* allocate memory for portinfo */ /* current_device_change is -1 if camera disconnected, 0 if other device * connected or 1 if camera has now connected */ current_device_change = -1; for (i = 0; i < nodecount; i++) { if (src->guid == rom1394_get_guid (handle, i)) { /* Camera is with us */ GST_DEBUG ("Camera is with us"); if (!src->connected) { current_device_change = 1; src->connected = TRUE; } else current_device_change = 0; } } if (src->connected && current_device_change == -1) { GST_DEBUG ("Camera has disconnected"); src->connected = FALSE; } else if (!src->connected && current_device_change == -1) { GST_DEBUG ("Camera is still not with us"); current_device_change = 0; } structure = gst_structure_new ("ieee1394-bus-reset", "nodecount", G_TYPE_INT, nodecount, "current-device-change", G_TYPE_INT, current_device_change, NULL); message = gst_message_new_element (GST_OBJECT (src), structure); gst_element_post_message (GST_ELEMENT (src), message); return 0; } static GstFlowReturn gst_hdv1394src_create (GstPushSrc * psrc, GstBuffer ** buf) { GstHDV1394Src *dv1394src = GST_HDV1394SRC (psrc); GstCaps *caps; struct pollfd pollfds[2]; pollfds[0].fd = raw1394_get_fd (dv1394src->handle); pollfds[0].events = POLLIN | POLLERR | POLLHUP | POLLPRI; pollfds[1].fd = READ_SOCKET (dv1394src); pollfds[1].events = POLLIN | POLLERR | POLLHUP | POLLPRI; /* allocate a 2048 samples buffer */ dv1394src->outdata = g_malloc (2048 * 188); dv1394src->outoffset = 0; GST_DEBUG ("Create..."); while (TRUE) { int res = poll (pollfds, 2, -1); GST_LOG ("res:%d", res); if (G_UNLIKELY (res < 0)) { if (errno == EAGAIN || errno == EINTR) continue; else goto error_while_polling; } if (G_UNLIKELY (pollfds[1].revents)) { char command; if (pollfds[1].revents & POLLIN) READ_COMMAND (dv1394src, command, res); goto told_to_stop; } else if (G_LIKELY (pollfds[0].revents & POLLIN)) { int pt; pt = dv1394src->frame_sequence; /* shouldn't block in theory */ GST_LOG ("Iterating ! (%d)", dv1394src->frame_sequence); raw1394_loop_iterate (dv1394src->handle); GST_LOG ("After iteration : %d (diff:%d)", dv1394src->frame_sequence, dv1394src->frame_sequence - pt); if (dv1394src->outoffset) break; } } g_assert (dv1394src->outoffset); GST_LOG ("We have some frames (%d bytes)", dv1394src->outoffset); /* Create the buffer */ *buf = gst_buffer_new (); GST_BUFFER_DATA (*buf) = dv1394src->outdata; GST_BUFFER_MALLOCDATA (*buf) = dv1394src->outdata; GST_BUFFER_SIZE (*buf) = dv1394src->outoffset; dv1394src->outdata = NULL; dv1394src->outoffset = 0; caps = gst_pad_get_caps (GST_BASE_SRC_PAD (psrc)); gst_buffer_set_caps (*buf, caps); gst_caps_unref (caps); return GST_FLOW_OK; error_while_polling: { GST_ELEMENT_ERROR (dv1394src, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM); return GST_FLOW_UNEXPECTED; } told_to_stop: { GST_DEBUG_OBJECT (dv1394src, "told to stop, shutting down"); return GST_FLOW_WRONG_STATE; } } static int gst_hdv1394src_discover_avc_node (GstHDV1394Src * src) { int node = -1; int i, j = 0; int m = src->num_ports; if (src->port >= 0) { /* search on explicit port */ j = src->port; m = j + 1; } /* loop over all our ports */ for (; j < m && node == -1; j++) { raw1394handle_t handle; struct raw1394_portinfo pinf[16]; /* open the port */ handle = raw1394_new_handle (); if (!handle) { GST_WARNING ("raw1394 - failed to get handle: %s.\n", strerror (errno)); continue; } if (raw1394_get_port_info (handle, pinf, 16) < 0) { GST_WARNING ("raw1394 - failed to get port info: %s.\n", strerror (errno)); goto next; } /* tell raw1394 which host adapter to use */ if (raw1394_set_port (handle, j) < 0) { GST_WARNING ("raw1394 - failed to set set port: %s.\n", strerror (errno)); goto next; } /* now loop over all the nodes */ for (i = 0; i < raw1394_get_nodecount (handle); i++) { /* are we looking for an explicit GUID ? */ if (src->guid != 0) { if (src->guid == rom1394_get_guid (handle, i)) { node = i; src->port = j; g_free (src->uri); src->uri = g_strdup_printf ("dv://%d", src->port); break; } } else { rom1394_directory rom_dir; /* select first AV/C Tape Recorder Player node */ if (rom1394_get_directory (handle, i, &rom_dir) < 0) { GST_WARNING ("error reading config rom directory for node %d\n", i); continue; } if ((rom1394_get_node_type (&rom_dir) == ROM1394_NODE_TYPE_AVC) && avc1394_check_subunit_type (handle, i, AVC1394_SUBUNIT_TYPE_VCR)) { node = i; src->port = j; src->guid = rom1394_get_guid (handle, i); g_free (src->uri); src->uri = g_strdup_printf ("dv://%d", src->port); g_free (src->device_name); src->device_name = g_strdup (rom_dir.label); break; } rom1394_free_directory (&rom_dir); } } next: raw1394_destroy_handle (handle); } return node; } static gboolean gst_hdv1394src_start (GstBaseSrc * bsrc) { GstHDV1394Src *src = GST_HDV1394SRC (bsrc); int control_sock[2]; src->connected = FALSE; if (socketpair (PF_UNIX, SOCK_STREAM, 0, control_sock) < 0) goto socket_pair; READ_SOCKET (src) = control_sock[0]; WRITE_SOCKET (src) = control_sock[1]; fcntl (READ_SOCKET (src), F_SETFL, O_NONBLOCK); fcntl (WRITE_SOCKET (src), F_SETFL, O_NONBLOCK); src->handle = raw1394_new_handle (); if (!src->handle) { if (errno == EACCES) goto permission_denied; else if (errno == ENOENT) goto not_found; else goto no_handle; } src->num_ports = raw1394_get_port_info (src->handle, src->pinfo, 16); if (src->num_ports == 0) goto no_ports; if (src->use_avc || src->port == -1) src->avc_node = gst_hdv1394src_discover_avc_node (src); /* lets destroy handle and create one on port this is more reliable than setting port on the existing handle */ raw1394_destroy_handle (src->handle); src->handle = raw1394_new_handle_on_port (src->port); if (!src->handle) goto cannot_set_port; raw1394_set_userdata (src->handle, src); raw1394_set_bus_reset_handler (src->handle, gst_hdv1394src_bus_reset); if ((src->iec61883mpeg2 = iec61883_mpeg2_recv_init (src->handle, gst_hdv1394src_iec61883_receive, src)) == NULL) goto cannot_initialise_dv; #if 0 raw1394_set_iso_handler (src->handle, src->channel, gst_hdv1394src_iso_receive); #endif GST_DEBUG_OBJECT (src, "successfully opened up 1394 connection"); src->connected = TRUE; if (iec61883_mpeg2_recv_start (src->iec61883mpeg2, src->channel) != 0) goto cannot_start; #if 0 if (raw1394_start_iso_rcv (src->handle, src->channel) < 0) goto cannot_start; #endif if (src->use_avc) { raw1394handle_t avc_handle = raw1394_new_handle_on_port (src->port); GST_LOG ("We have an avc_handle"); /* start the VCR */ if (avc_handle) { if (!avc1394_vcr_is_recording (avc_handle, src->avc_node) && avc1394_vcr_is_playing (avc_handle, src->avc_node) != AVC1394_VCR_OPERAND_PLAY_FORWARD) { GST_LOG ("Calling avc1394_vcr_play()"); avc1394_vcr_play (avc_handle, src->avc_node); } raw1394_destroy_handle (avc_handle); } else { GST_WARNING_OBJECT (src, "Starting VCR via avc1394 failed: %s", g_strerror (errno)); } } return TRUE; socket_pair: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), GST_ERROR_SYSTEM); return FALSE; } permission_denied: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), GST_ERROR_SYSTEM); return FALSE; } not_found: { GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), GST_ERROR_SYSTEM); return FALSE; } no_handle: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("can't get raw1394 handle (%s)", g_strerror (errno))); return FALSE; } no_ports: { raw1394_destroy_handle (src->handle); src->handle = NULL; GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), ("no ports available for raw1394")); return FALSE; } cannot_set_port: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("can't set 1394 port %d", src->port)); return FALSE; } cannot_start: { raw1394_destroy_handle (src->handle); src->handle = NULL; iec61883_mpeg2_close (src->iec61883mpeg2); src->iec61883mpeg2 = NULL; GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("can't start 1394 iso receive")); return FALSE; } cannot_initialise_dv: { raw1394_destroy_handle (src->handle); src->handle = NULL; GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("can't initialise iec61883 hdv")); return FALSE; } } static gboolean gst_hdv1394src_stop (GstBaseSrc * bsrc) { GstHDV1394Src *src = GST_HDV1394SRC (bsrc); close (READ_SOCKET (src)); close (WRITE_SOCKET (src)); READ_SOCKET (src) = -1; WRITE_SOCKET (src) = -1; iec61883_mpeg2_close (src->iec61883mpeg2); #if 0 raw1394_stop_iso_rcv (src->handle, src->channel); #endif if (src->use_avc) { raw1394handle_t avc_handle = raw1394_new_handle_on_port (src->port); /* pause and stop the VCR */ if (avc_handle) { if (!avc1394_vcr_is_recording (avc_handle, src->avc_node) && (avc1394_vcr_is_playing (avc_handle, src->avc_node) != AVC1394_VCR_OPERAND_PLAY_FORWARD_PAUSE)) avc1394_vcr_pause (avc_handle, src->avc_node); avc1394_vcr_stop (avc_handle, src->avc_node); raw1394_destroy_handle (avc_handle); } else { GST_WARNING_OBJECT (src, "Starting VCR via avc1394 failed: %s", g_strerror (errno)); } } raw1394_destroy_handle (src->handle); return TRUE; } static gboolean gst_hdv1394src_unlock (GstBaseSrc * bsrc) { GstHDV1394Src *src = GST_HDV1394SRC (bsrc); SEND_COMMAND (src, CONTROL_STOP); return TRUE; } static void gst_hdv1394src_update_device_name (GstHDV1394Src * src) { raw1394handle_t handle; gint portcount, port, nodecount, node; rom1394_directory directory; g_free (src->device_name); src->device_name = NULL; GST_LOG_OBJECT (src, "updating device name for current GUID"); handle = raw1394_new_handle (); if (handle == NULL) goto gethandle_failed; portcount = raw1394_get_port_info (handle, NULL, 0); for (port = 0; port < portcount; port++) { if (raw1394_set_port (handle, port) >= 0) { nodecount = raw1394_get_nodecount (handle); for (node = 0; node < nodecount; node++) { if (src->guid == rom1394_get_guid (handle, node)) { if (rom1394_get_directory (handle, node, &directory) >= 0) { g_free (src->device_name); src->device_name = g_strdup (directory.label); rom1394_free_directory (&directory); goto done; } else { GST_WARNING ("error reading rom directory for node %d", node); } } } } } src->device_name = g_strdup ("Unknown"); /* FIXME: translate? */ done: raw1394_destroy_handle (handle); return; /* ERRORS */ gethandle_failed: { GST_WARNING ("failed to get raw1394 handle: %s", g_strerror (errno)); src->device_name = g_strdup ("Unknown"); /* FIXME: translate? */ return; } } /*** GSTURIHANDLER INTERFACE *************************************************/ static guint gst_hdv1394src_uri_get_type (void) { return GST_URI_SRC; } static gchar ** gst_hdv1394src_uri_get_protocols (void) { static gchar *protocols[] = { "hdv", NULL }; return protocols; } static const gchar * gst_hdv1394src_uri_get_uri (GstURIHandler * handler) { GstHDV1394Src *gst_hdv1394src = GST_HDV1394SRC (handler); return gst_hdv1394src->uri; } static gboolean gst_hdv1394src_uri_set_uri (GstURIHandler * handler, const gchar * uri) { gchar *protocol, *location; gboolean ret = TRUE; GstHDV1394Src *gst_hdv1394src = GST_HDV1394SRC (handler); protocol = gst_uri_get_protocol (uri); if (strcmp (protocol, "hdv") != 0) { g_free (protocol); return FALSE; } g_free (protocol); location = gst_uri_get_location (uri); if (location && *location != '\0') gst_hdv1394src->port = strtol (location, NULL, 10); else gst_hdv1394src->port = DEFAULT_PORT; g_free (location); g_free (gst_hdv1394src->uri); gst_hdv1394src->uri = g_strdup_printf ("hdv://%d", gst_hdv1394src->port); return ret; } static void gst_hdv1394src_uri_handler_init (gpointer g_iface, gpointer iface_data) { GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface; iface->get_type = gst_hdv1394src_uri_get_type; iface->get_protocols = gst_hdv1394src_uri_get_protocols; iface->get_uri = gst_hdv1394src_uri_get_uri; iface->set_uri = gst_hdv1394src_uri_set_uri; }