X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=plugins%2Felements%2Fgstfdsink.c;h=f4eb10073537ca0942ab96b1b9dda07da7b5578c;hb=748687fc30001b3bca0218ae909ee31f75f24e00;hp=4441d967fcf2177d007613d48218dcbaff9ecb77;hpb=dfa9bb808840468e49f51ccd9ba0d12d73e21f76;p=platform%2Fupstream%2Fgstreamer.git diff --git a/plugins/elements/gstfdsink.c b/plugins/elements/gstfdsink.c index 4441d96..f4eb100 100644 --- a/plugins/elements/gstfdsink.c +++ b/plugins/elements/gstfdsink.c @@ -16,8 +16,8 @@ * * 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. + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. */ /** @@ -29,8 +29,6 @@ * This element will synchronize on the clock before writing the data on the * socket. For file descriptors where this does not make sense (files, ...) the * #GstBaseSink:sync property can be used to disable synchronisation. - * - * Last reviewed on 2006-04-28 (0.10.6) */ #ifdef HAVE_CONFIG_H @@ -41,14 +39,6 @@ #include -#ifdef G_OS_WIN32 -#include /* lseek, open, close, read */ -#undef lseek -#define lseek _lseeki64 -#undef off_t -#define off_t guint64 -#endif - #include #ifdef HAVE_SYS_SOCKET_H #include @@ -68,6 +58,24 @@ #include #include "gstfdsink.h" +#include "gstelements_private.h" + +#ifdef G_OS_WIN32 +#include /* lseek, open, close, read */ +#undef lseek +#define lseek _lseeki64 +#undef off_t +#define off_t guint64 +#endif + +#ifdef __BIONIC__ /* Android */ +#undef lseek +#define lseek lseek64 +#undef fstat +#define fstat fstat64 +#undef off_t +#define off_t guint64 +#endif static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, @@ -106,9 +114,11 @@ static void gst_fd_sink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static void gst_fd_sink_dispose (GObject * obj); -static gboolean gst_fd_sink_query (GstPad * pad, GstQuery * query); +static gboolean gst_fd_sink_query (GstBaseSink * bsink, GstQuery * query); static GstFlowReturn gst_fd_sink_render (GstBaseSink * sink, GstBuffer * buffer); +static GstFlowReturn gst_fd_sink_render_list (GstBaseSink * bsink, + GstBufferList * buffer_list); static gboolean gst_fd_sink_start (GstBaseSink * basesink); static gboolean gst_fd_sink_stop (GstBaseSink * basesink); static gboolean gst_fd_sink_unlock (GstBaseSink * basesink); @@ -132,19 +142,20 @@ gst_fd_sink_class_init (GstFdSinkClass * klass) gobject_class->get_property = gst_fd_sink_get_property; gobject_class->dispose = gst_fd_sink_dispose; - gst_element_class_set_details_simple (gstelement_class, + gst_element_class_set_static_metadata (gstelement_class, "Filedescriptor Sink", "Sink/File", "Write data to a file descriptor", "Erik Walthinsen "); - gst_element_class_add_pad_template (gstelement_class, - gst_static_pad_template_get (&sinktemplate)); + gst_element_class_add_static_pad_template (gstelement_class, &sinktemplate); gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_fd_sink_render); + gstbasesink_class->render_list = GST_DEBUG_FUNCPTR (gst_fd_sink_render_list); gstbasesink_class->start = GST_DEBUG_FUNCPTR (gst_fd_sink_start); gstbasesink_class->stop = GST_DEBUG_FUNCPTR (gst_fd_sink_stop); gstbasesink_class->unlock = GST_DEBUG_FUNCPTR (gst_fd_sink_unlock); gstbasesink_class->unlock_stop = GST_DEBUG_FUNCPTR (gst_fd_sink_unlock_stop); gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_fd_sink_event); + gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_fd_sink_query); g_object_class_install_property (gobject_class, ARG_FD, g_param_spec_int ("fd", "fd", "An open file descriptor to write to", @@ -154,11 +165,6 @@ gst_fd_sink_class_init (GstFdSinkClass * klass) static void gst_fd_sink_init (GstFdSink * fdsink) { - GstPad *pad; - - pad = GST_BASE_SINK_PAD (fdsink); - gst_pad_set_query_function (pad, GST_DEBUG_FUNCPTR (gst_fd_sink_query)); - fdsink->fd = 1; fdsink->uri = g_strdup_printf ("fd://%d", fdsink->fd); fdsink->bytes_written = 0; @@ -179,139 +185,143 @@ gst_fd_sink_dispose (GObject * obj) } static gboolean -gst_fd_sink_query (GstPad * pad, GstQuery * query) +gst_fd_sink_query (GstBaseSink * bsink, GstQuery * query) { + gboolean res = FALSE; GstFdSink *fdsink; - GstFormat format; - fdsink = GST_FD_SINK (GST_PAD_PARENT (pad)); + fdsink = GST_FD_SINK (bsink); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: + { + GstFormat format; + gst_query_parse_position (query, &format, NULL); + switch (format) { case GST_FORMAT_DEFAULT: case GST_FORMAT_BYTES: gst_query_set_position (query, GST_FORMAT_BYTES, fdsink->current_pos); - return TRUE; + res = TRUE; + break; default: - return FALSE; + break; } - + break; + } case GST_QUERY_FORMATS: gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES); - return TRUE; - + res = TRUE; + break; case GST_QUERY_URI: gst_query_set_uri (query, fdsink->uri); - return TRUE; + res = TRUE; + break; + case GST_QUERY_SEEKING:{ + GstFormat format; + gst_query_parse_seeking (query, &format, NULL, NULL, NULL); + if (format == GST_FORMAT_BYTES || format == GST_FORMAT_DEFAULT) { + gst_query_set_seeking (query, GST_FORMAT_BYTES, fdsink->seekable, 0, + -1); + } else { + gst_query_set_seeking (query, format, FALSE, 0, -1); + } + res = TRUE; + break; + } default: - return gst_pad_query_default (pad, query); + res = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query); + break; + } + return res; } static GstFlowReturn -gst_fd_sink_render (GstBaseSink * sink, GstBuffer * buffer) +gst_fd_sink_render_buffers (GstFdSink * sink, GstBuffer ** buffers, + guint num_buffers, guint8 * mem_nums, guint total_mems) { - GstFdSink *fdsink; - guint8 *data, *ptr; - gsize size, left; - gint written; + GstFlowReturn ret; + guint64 skip = 0; -#ifndef HAVE_WIN32 - gint retval; -#endif + for (;;) { + guint64 bytes_written = 0; - fdsink = GST_FD_SINK (sink); + ret = gst_writev_buffers (GST_OBJECT_CAST (sink), sink->fd, sink->fdset, + buffers, num_buffers, mem_nums, total_mems, &bytes_written, skip); - g_return_val_if_fail (fdsink->fd >= 0, GST_FLOW_ERROR); + sink->bytes_written += bytes_written; + sink->current_pos += bytes_written; + skip += bytes_written; - data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ); + if (!sink->unlock) + break; - ptr = data; - left = size; + ret = gst_base_sink_wait_preroll (GST_BASE_SINK (sink)); + if (ret != GST_FLOW_OK) + return ret; + } -again: -#ifndef HAVE_WIN32 - do { - GST_DEBUG_OBJECT (fdsink, "going into select, have %" G_GSIZE_FORMAT - " bytes to write", size); - retval = gst_poll_wait (fdsink->fdset, GST_CLOCK_TIME_NONE); - } while (retval == -1 && (errno == EINTR || errno == EAGAIN)); + return ret; +} - if (retval == -1) { - if (errno == EBUSY) - goto stopped; - else - goto select_error; +static GstFlowReturn +gst_fd_sink_render_list (GstBaseSink * bsink, GstBufferList * buffer_list) +{ + GstFlowReturn flow; + GstBuffer **buffers; + GstFdSink *sink; + guint8 *mem_nums; + guint total_mems; + guint i, num_buffers; + + sink = GST_FD_SINK_CAST (bsink); + + num_buffers = gst_buffer_list_length (buffer_list); + if (num_buffers == 0) + goto no_data; + + /* extract buffers from list and count memories */ + buffers = g_newa (GstBuffer *, num_buffers); + mem_nums = g_newa (guint8, num_buffers); + for (i = 0, total_mems = 0; i < num_buffers; ++i) { + buffers[i] = gst_buffer_list_get (buffer_list, i); + mem_nums[i] = gst_buffer_n_memory (buffers[i]); + total_mems += mem_nums[i]; } -#endif - - GST_DEBUG_OBJECT (fdsink, "writing %" G_GSIZE_FORMAT " bytes to" - " file descriptor %d", size, fdsink->fd); - written = write (fdsink->fd, ptr, left); + flow = + gst_fd_sink_render_buffers (sink, buffers, num_buffers, mem_nums, + total_mems); - /* check for errors */ - if (G_UNLIKELY (written < 0)) { - /* try to write again on non-fatal errors */ - if (errno == EAGAIN || errno == EINTR) - goto again; + return flow; - /* else go to our error handler */ - goto write_error; +no_data: + { + GST_LOG_OBJECT (sink, "empty buffer list"); + return GST_FLOW_OK; } +} - /* all is fine when we get here */ - left -= written; - ptr += written; - fdsink->bytes_written += written; - fdsink->current_pos += written; - - GST_DEBUG_OBJECT (fdsink, "wrote %d bytes, %" G_GSIZE_FORMAT " left", written, - left); - - /* short write, select and try to write the remainder */ - if (G_UNLIKELY (left > 0)) - goto again; +static GstFlowReturn +gst_fd_sink_render (GstBaseSink * bsink, GstBuffer * buffer) +{ + GstFlowReturn flow; + GstFdSink *sink; + guint8 n_mem; - gst_buffer_unmap (buffer, data, size); + sink = GST_FD_SINK_CAST (bsink); - return GST_FLOW_OK; + n_mem = gst_buffer_n_memory (buffer); -#ifndef HAVE_WIN32 -select_error: - { - GST_ELEMENT_ERROR (fdsink, RESOURCE, READ, (NULL), - ("select on file descriptor: %s.", g_strerror (errno))); - GST_DEBUG_OBJECT (fdsink, "Error during select"); - gst_buffer_unmap (buffer, data, size); - return GST_FLOW_ERROR; - } -stopped: - { - GST_DEBUG_OBJECT (fdsink, "Select stopped"); - gst_buffer_unmap (buffer, data, size); - return GST_FLOW_WRONG_STATE; - } -#endif + if (n_mem > 0) + flow = gst_fd_sink_render_buffers (sink, &buffer, 1, &n_mem, n_mem); + else + flow = GST_FLOW_OK; -write_error: - { - switch (errno) { - case ENOSPC: - GST_ELEMENT_ERROR (fdsink, RESOURCE, NO_SPACE_LEFT, (NULL), (NULL)); - break; - default:{ - GST_ELEMENT_ERROR (fdsink, RESOURCE, WRITE, (NULL), - ("Error while writing to file descriptor %d: %s", - fdsink->fd, g_strerror (errno))); - } - } - gst_buffer_unmap (buffer, data, size); - return GST_FLOW_ERROR; - } + return flow; } static gboolean @@ -378,6 +388,9 @@ gst_fd_sink_start (GstBaseSink * basesink) fdsink->bytes_written = 0; fdsink->current_pos = 0; + fdsink->seekable = gst_fd_sink_do_seek (fdsink, 0); + GST_INFO_OBJECT (fdsink, "seeking supported: %d", fdsink->seekable); + return TRUE; /* ERRORS */ @@ -409,6 +422,7 @@ gst_fd_sink_unlock (GstBaseSink * basesink) GST_LOG_OBJECT (fdsink, "Flushing"); GST_OBJECT_LOCK (fdsink); + fdsink->unlock = TRUE; gst_poll_set_flushing (fdsink->fdset, TRUE); GST_OBJECT_UNLOCK (fdsink); @@ -422,6 +436,7 @@ gst_fd_sink_unlock_stop (GstBaseSink * basesink) GST_LOG_OBJECT (fdsink, "No longer flushing"); GST_OBJECT_LOCK (fdsink); + fdsink->unlock = FALSE; gst_poll_set_flushing (fdsink->fdset, FALSE); GST_OBJECT_UNLOCK (fdsink); @@ -571,13 +586,14 @@ gst_fd_sink_event (GstBaseSink * sink, GstEvent * event) break; } - return TRUE; + return GST_BASE_SINK_CLASS (parent_class)->event (sink, event); seek_failed: { GST_ELEMENT_ERROR (fdsink, RESOURCE, SEEK, (NULL), ("Error while seeking on file descriptor %d: %s", fdsink->fd, g_strerror (errno))); + gst_event_unref (event); return FALSE; } @@ -591,10 +607,10 @@ gst_fd_sink_uri_get_type (GType type) return GST_URI_SINK; } -static gchar ** +static const gchar *const * gst_fd_sink_uri_get_protocols (GType type) { - static gchar *protocols[] = { (char *) "fd", NULL }; + static const gchar *protocols[] = { "fd", NULL }; return protocols; }