ext/gio/gstgiobasesink.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2007 Rene Stadler <mail@renestadler.de>
   4  * Copyright (C) 2007-2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include "gstgiobasesink.h"
  27
  28 GST_DEBUG_CATEGORY_STATIC (gst_gio_base_sink_debug);
  29 #define GST_CAT_DEFAULT gst_gio_base_sink_debug
  30
  31 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
  32     GST_PAD_SINK,
  33     GST_PAD_ALWAYS,
  34     GST_STATIC_CAPS_ANY);
  35
  36 #define gst_gio_base_sink_parent_class parent_class
  37 G_DEFINE_TYPE (GstGioBaseSink, gst_gio_base_sink, GST_TYPE_BASE_SINK);
  38
  39 static void gst_gio_base_sink_finalize (GObject * object);
  40 static gboolean gst_gio_base_sink_start (GstBaseSink * base_sink);
  41 static gboolean gst_gio_base_sink_stop (GstBaseSink * base_sink);
  42 static gboolean gst_gio_base_sink_unlock (GstBaseSink * base_sink);
  43 static gboolean gst_gio_base_sink_unlock_stop (GstBaseSink * base_sink);
  44 static gboolean gst_gio_base_sink_event (GstBaseSink * base_sink,
  45     GstEvent * event);
  46 static GstFlowReturn gst_gio_base_sink_render (GstBaseSink * base_sink,
  47     GstBuffer * buffer);
  48 static gboolean gst_gio_base_sink_query (GstBaseSink * bsink, GstQuery * query);
  49
  50 static void
  51 gst_gio_base_sink_class_init (GstGioBaseSinkClass * klass)
  52 {
  53   GObjectClass *gobject_class = (GObjectClass *) klass;
  54   GstElementClass *gstelement_class = (GstElementClass *) klass;
  55   GstBaseSinkClass *gstbasesink_class = (GstBaseSinkClass *) klass;
  56
  57   GST_DEBUG_CATEGORY_INIT (gst_gio_base_sink_debug, "gio_base_sink", 0,
  58       "GIO base sink");
  59
  60   gobject_class->finalize = gst_gio_base_sink_finalize;
  61
  62   gst_element_class_add_pad_template (gstelement_class,
  63       gst_static_pad_template_get (&sink_factory));
  64
  65   gstbasesink_class->start = GST_DEBUG_FUNCPTR (gst_gio_base_sink_start);
  66   gstbasesink_class->stop = GST_DEBUG_FUNCPTR (gst_gio_base_sink_stop);
  67   gstbasesink_class->unlock = GST_DEBUG_FUNCPTR (gst_gio_base_sink_unlock);
  68   gstbasesink_class->unlock_stop =
  69       GST_DEBUG_FUNCPTR (gst_gio_base_sink_unlock_stop);
  70   gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_gio_base_sink_query);
  71   gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_gio_base_sink_event);
  72   gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_gio_base_sink_render);
  73 }
  74
  75 static void
  76 gst_gio_base_sink_init (GstGioBaseSink * sink)
  77 {
  78   gst_base_sink_set_sync (GST_BASE_SINK (sink), FALSE);
  79
  80   sink->cancel = g_cancellable_new ();
  81 }
  82
  83 static void
  84 gst_gio_base_sink_finalize (GObject * object)
  85 {
  86   GstGioBaseSink *sink = GST_GIO_BASE_SINK (object);
  87
  88   if (sink->cancel) {
  89     g_object_unref (sink->cancel);
  90     sink->cancel = NULL;
  91   }
  92
  93   if (sink->stream) {
  94     g_object_unref (sink->stream);
  95     sink->stream = NULL;
  96   }
  97
  98   GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
  99 }
 100
 101 static gboolean
 102 gst_gio_base_sink_start (GstBaseSink * base_sink)
 103 {
 104   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
 105   GstGioBaseSinkClass *gbsink_class = GST_GIO_BASE_SINK_GET_CLASS (sink);
 106
 107   sink->position = 0;
 108
 109   /* FIXME: This will likely block */
 110   sink->stream = gbsink_class->get_stream (sink);
 111   if (G_UNLIKELY (!G_IS_OUTPUT_STREAM (sink->stream))) {
 112     GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (NULL),
 113         ("No output stream provided by subclass"));
 114     return FALSE;
 115   } else if (G_UNLIKELY (g_output_stream_is_closed (sink->stream))) {
 116     GST_ELEMENT_ERROR (sink, LIBRARY, FAILED, (NULL),
 117         ("Output stream is already closed"));
 118     return FALSE;
 119   }
 120
 121   GST_DEBUG_OBJECT (sink, "started sink");
 122
 123   return TRUE;
 124 }
 125
 126 static gboolean
 127 gst_gio_base_sink_stop (GstBaseSink * base_sink)
 128 {
 129   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
 130   GstGioBaseSinkClass *klass = GST_GIO_BASE_SINK_GET_CLASS (sink);
 131   gboolean success;
 132   GError *err = NULL;
 133
 134   if (klass->close_on_stop && G_IS_OUTPUT_STREAM (sink->stream)) {
 135     GST_DEBUG_OBJECT (sink, "closing stream");
 136
 137     /* FIXME: can block but unfortunately we can't use async operations
 138      * here because they require a running main loop */
 139     success = g_output_stream_close (sink->stream, sink->cancel, &err);
 140
 141     if (!success && !gst_gio_error (sink, "g_output_stream_close", &err, NULL)) {
 142       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),
 143           ("gio_output_stream_close failed: %s", err->message));
 144       g_clear_error (&err);
 145     } else if (!success) {
 146       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),
 147           ("g_output_stream_close failed"));
 148     } else {
 149       GST_DEBUG_OBJECT (sink, "g_outut_stream_close succeeded");
 150     }
 151
 152     g_object_unref (sink->stream);
 153     sink->stream = NULL;
 154   } else {
 155     success = g_output_stream_flush (sink->stream, sink->cancel, &err);
 156
 157     if (!success && !gst_gio_error (sink, "g_output_stream_flush", &err, NULL)) {
 158       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),
 159           ("gio_output_stream_flush failed: %s", err->message));
 160       g_clear_error (&err);
 161     } else if (!success) {
 162       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),
 163           ("g_output_stream_flush failed"));
 164     } else {
 165       GST_DEBUG_OBJECT (sink, "g_outut_stream_flush succeeded");
 166     }
 167
 168     g_object_unref (sink->stream);
 169     sink->stream = NULL;
 170   }
 171
 172   return TRUE;
 173 }
 174
 175 static gboolean
 176 gst_gio_base_sink_unlock (GstBaseSink * base_sink)
 177 {
 178   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
 179
 180   GST_LOG_OBJECT (sink, "triggering cancellation");
 181
 182   g_cancellable_cancel (sink->cancel);
 183
 184   return TRUE;
 185 }
 186
 187 static gboolean
 188 gst_gio_base_sink_unlock_stop (GstBaseSink * base_sink)
 189 {
 190   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
 191
 192   GST_LOG_OBJECT (sink, "resetting cancellable");
 193
 194   g_cancellable_reset (sink->cancel);
 195
 196   return TRUE;
 197 }
 198
 199 static gboolean
 200 gst_gio_base_sink_event (GstBaseSink * base_sink, GstEvent * event)
 201 {
 202   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
 203   GstFlowReturn ret = GST_FLOW_OK;
 204
 205   if (sink->stream == NULL)
 206     return TRUE;
 207
 208   switch (GST_EVENT_TYPE (event)) {
 209     case GST_EVENT_SEGMENT:
 210       if (G_IS_OUTPUT_STREAM (sink->stream)) {
 211         const GstSegment *segment;
 212
 213         gst_event_parse_segment (event, &segment);
 214
 215         if (segment->format != GST_FORMAT_BYTES) {
 216           GST_WARNING_OBJECT (sink, "ignored SEGMENT event in %s format",
 217               gst_format_get_name (segment->format));
 218           break;
 219         }
 220
 221         if (GST_GIO_STREAM_IS_SEEKABLE (sink->stream)) {
 222           ret = gst_gio_seek (sink, G_SEEKABLE (sink->stream), segment->start,
 223               sink->cancel);
 224           if (ret == GST_FLOW_OK)
 225             sink->position = segment->start;
 226         } else {
 227           ret = GST_FLOW_NOT_SUPPORTED;
 228         }
 229       }
 230       break;
 231
 232     case GST_EVENT_EOS:
 233     case GST_EVENT_FLUSH_START:
 234       if (G_IS_OUTPUT_STREAM (sink->stream)) {
 235         gboolean success;
 236         GError *err = NULL;
 237
 238         success = g_output_stream_flush (sink->stream, sink->cancel, &err);
 239
 240         if (!success && !gst_gio_error (sink, "g_output_stream_flush", &err,
 241                 &ret)) {
 242           GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),
 243               ("flush failed: %s", err->message));
 244           g_clear_error (&err);
 245         }
 246       }
 247       break;
 248
 249     default:
 250       break;
 251   }
 252   if (ret == GST_FLOW_OK)
 253     return GST_BASE_SINK_CLASS (parent_class)->event (base_sink, event);
 254   else {
 255     gst_event_unref (event);
 256     return FALSE;
 257   }
 258 }
 259
 260 static GstFlowReturn
 261 gst_gio_base_sink_render (GstBaseSink * base_sink, GstBuffer * buffer)
 262 {
 263   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);
 264   gssize written;
 265   guint8 *data;
 266   gsize size;
 267   gboolean success;
 268   GError *err = NULL;
 269
 270   g_return_val_if_fail (G_IS_OUTPUT_STREAM (sink->stream), GST_FLOW_ERROR);
 271
 272   data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
 273
 274   GST_LOG_OBJECT (sink,
 275       "writing %" G_GSIZE_FORMAT " bytes to offset %" G_GUINT64_FORMAT, size,
 276       sink->position);
 277
 278   written =
 279       g_output_stream_write (sink->stream, data, size, sink->cancel, &err);
 280   gst_buffer_unmap (buffer, data, size);
 281
 282   success = (written >= 0);
 283
 284   if (G_UNLIKELY (success && written < size)) {
 285     /* FIXME: Can this happen?  Should we handle it gracefully?  gnomevfssink
 286      * doesn't... */
 287     GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),
 288         ("Could not write to stream: (short write, only %"
 289             G_GSSIZE_FORMAT " bytes of %" G_GSIZE_FORMAT " bytes written)",
 290             written, size));
 291     return GST_FLOW_ERROR;
 292   }
 293
 294   if (success) {
 295     sink->position += written;
 296     return GST_FLOW_OK;
 297
 298   } else {
 299     GstFlowReturn ret;
 300
 301     if (!gst_gio_error (sink, "g_output_stream_write", &err, &ret)) {
 302       if (GST_GIO_ERROR_MATCHES (err, NO_SPACE)) {
 303         GST_ELEMENT_ERROR (sink, RESOURCE, NO_SPACE_LEFT, (NULL),
 304             ("Could not write to stream: %s", err->message));
 305       } else {
 306         GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),
 307             ("Could not write to stream: %s", err->message));
 308       }
 309       g_clear_error (&err);
 310     }
 311
 312     return ret;
 313   }
 314 }
 315
 316 static gboolean
 317 gst_gio_base_sink_query (GstBaseSink * bsink, GstQuery * query)
 318 {
 319   GstGioBaseSink *sink = GST_GIO_BASE_SINK (bsink);
 320   GstFormat format;
 321
 322   switch (GST_QUERY_TYPE (query)) {
 323     case GST_QUERY_POSITION:
 324       gst_query_parse_position (query, &format, NULL);
 325       switch (format) {
 326         case GST_FORMAT_BYTES:
 327         case GST_FORMAT_DEFAULT:
 328           gst_query_set_position (query, GST_FORMAT_BYTES, sink->position);
 329           return TRUE;
 330         default:
 331           return FALSE;
 332       }
 333     case GST_QUERY_FORMATS:
 334       gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES);
 335       return TRUE;
 336     case GST_QUERY_URI:
 337       if (GST_IS_URI_HANDLER (sink)) {
 338         gchar *uri;
 339
 340         uri = gst_uri_handler_get_uri (GST_URI_HANDLER (sink));
 341         gst_query_set_uri (query, uri);
 342         g_free (uri);
 343         return TRUE;
 344       }
 345       return FALSE;
 346     default:
 347       return GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
 348   }
 349 }