1 /* GStreamer

     2  *

     3  * Copyright (C) 2007 Rene Stadler <mail@renestadler.de>

     4  * Copyright (C) 2007 Sebastian Dröge <slomo@circular-chaos.org>

     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 GST_BOILERPLATE (GstGioBaseSink, gst_gio_base_sink, GstBaseSink,

    37     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 (GstPad * pad, GstQuery * query);

    49 

    50 static void

    51 gst_gio_base_sink_base_init (gpointer gclass)

    52 {

    53   GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);

    54 

    55   GST_DEBUG_CATEGORY_INIT (gst_gio_base_sink_debug, "gio_base_sink", 0,

    56       "GIO base sink");

    57 

    58   gst_element_class_add_pad_template (element_class,

    59       gst_static_pad_template_get (&sink_factory));

    60 }

    61 

    62 static void

    63 gst_gio_base_sink_class_init (GstGioBaseSinkClass * klass)

    64 {

    65   GObjectClass *gobject_class;

    66   GstElementClass *gstelement_class;

    67   GstBaseSinkClass *gstbasesink_class;

    68 

    69   gobject_class = (GObjectClass *) klass;

    70   gstelement_class = (GstElementClass *) klass;

    71   gstbasesink_class = (GstBaseSinkClass *) klass;

    72 

    73   gobject_class->finalize = gst_gio_base_sink_finalize;

    74 

    75   gstbasesink_class->start = GST_DEBUG_FUNCPTR (gst_gio_base_sink_start);

    76   gstbasesink_class->stop = GST_DEBUG_FUNCPTR (gst_gio_base_sink_stop);

    77   gstbasesink_class->unlock = GST_DEBUG_FUNCPTR (gst_gio_base_sink_unlock);

    78   gstbasesink_class->unlock_stop =

    79       GST_DEBUG_FUNCPTR (gst_gio_base_sink_unlock_stop);

    80   gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_gio_base_sink_event);

    81   gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_gio_base_sink_render);

    82 }

    83 

    84 static void

    85 gst_gio_base_sink_init (GstGioBaseSink * sink, GstGioBaseSinkClass * gclass)

    86 {

    87   gst_pad_set_query_function (GST_BASE_SINK_PAD (sink),

    88       GST_DEBUG_FUNCPTR (gst_gio_base_sink_query));

    89 

    90   gst_base_sink_set_sync (GST_BASE_SINK (sink), FALSE);

    91 

    92   sink->cancel = g_cancellable_new ();

    93 }

    94 

    95 static void

    96 gst_gio_base_sink_finalize (GObject * object)

    97 {

    98   GstGioBaseSink *sink = GST_GIO_BASE_SINK (object);

    99 

   100   if (sink->cancel) {

   101     g_object_unref (sink->cancel);

   102     sink->cancel = NULL;

   103   }

   104 

   105   if (sink->stream) {

   106     g_object_unref (sink->stream);

   107     sink->stream = NULL;

   108   }

   109 

   110   GST_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));

   111 }

   112 

   113 static gboolean

   114 gst_gio_base_sink_start (GstBaseSink * base_sink)

   115 {

   116   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);

   117 

   118   if (!G_IS_OUTPUT_STREAM (sink->stream)) {

   119     GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (NULL),

   120         ("No stream given yet"));

   121     return FALSE;

   122   }

   123 

   124   sink->position = 0;

   125 

   126   GST_DEBUG_OBJECT (sink, "started stream");

   127 

   128   return TRUE;

   129 }

   130 

   131 static gboolean

   132 gst_gio_base_sink_stop (GstBaseSink * base_sink)

   133 {

   134   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);

   135   gboolean success;

   136   GError *err = NULL;

   137 

   138   if (G_IS_OUTPUT_STREAM (sink->stream)) {

   139     GST_DEBUG_OBJECT (sink, "closing stream");

   140 

   141     /* FIXME: can block but unfortunately we can't use async operations

   142      * here because they require a running main loop */

   143     success = g_output_stream_close (sink->stream, sink->cancel, &err);

   144 

   145     if (!success && !gst_gio_error (sink, "g_output_stream_close", &err, NULL)) {

   146       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),

   147           ("g_ooutput_stream_close failed: %s", err->message));

   148       g_clear_error (&err);

   149     } else if (!success) {

   150       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),

   151           ("g_output_stream_close failed"));

   152     } else {

   153       GST_DEBUG_OBJECT (sink, "g_outut_stream_close succeeded");

   154     }

   155 

   156     g_object_unref (sink->stream);

   157     sink->stream = NULL;

   158   }

   159 

   160   return TRUE;

   161 }

   162 

   163 static gboolean

   164 gst_gio_base_sink_unlock (GstBaseSink * base_sink)

   165 {

   166   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);

   167 

   168   GST_LOG_OBJECT (sink, "triggering cancellation");

   169 

   170   g_cancellable_cancel (sink->cancel);

   171 

   172   return TRUE;

   173 }

   174 

   175 static gboolean

   176 gst_gio_base_sink_unlock_stop (GstBaseSink * base_sink)

   177 {

   178   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);

   179 

   180   GST_LOG_OBJECT (sink, "resetting cancellable");

   181 

   182   g_cancellable_reset (sink->cancel);

   183 

   184   return TRUE;

   185 }

   186 

   187 static gboolean

   188 gst_gio_base_sink_event (GstBaseSink * base_sink, GstEvent * event)

   189 {

   190   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);

   191   GstFlowReturn ret = GST_FLOW_OK;

   192 

   193   if (sink->stream == NULL)

   194     return TRUE;

   195 

   196   switch (GST_EVENT_TYPE (event)) {

   197     case GST_EVENT_NEWSEGMENT:

   198       if (G_IS_OUTPUT_STREAM (sink->stream)) {

   199         GstFormat format;

   200         gint64 offset;

   201 

   202         gst_event_parse_new_segment (event, NULL, NULL, &format, &offset, NULL,

   203             NULL);

   204 

   205         if (format != GST_FORMAT_BYTES) {

   206           GST_WARNING_OBJECT (sink, "ignored NEWSEGMENT event in %s format",

   207               gst_format_get_name (format));

   208           break;

   209         }

   210 

   211         if (GST_GIO_STREAM_IS_SEEKABLE (sink->stream)) {

   212           ret = gst_gio_seek (sink, G_SEEKABLE (sink->stream), offset,

   213               sink->cancel);

   214           if (ret == GST_FLOW_OK)

   215             sink->position = offset;

   216         } else {

   217           ret = GST_FLOW_NOT_SUPPORTED;

   218         }

   219       }

   220       break;

   221 

   222     case GST_EVENT_EOS:

   223     case GST_EVENT_FLUSH_START:

   224       if (G_IS_OUTPUT_STREAM (sink->stream)) {

   225         gboolean success;

   226         GError *err = NULL;

   227 

   228         success = g_output_stream_flush (sink->stream, sink->cancel, &err);

   229 

   230         if (!success && !gst_gio_error (sink, "g_output_stream_flush", &err,

   231                 &ret)) {

   232           GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),

   233               ("flush failed: %s", err->message));

   234           g_clear_error (&err);

   235         }

   236       }

   237       break;

   238 

   239     default:

   240       break;

   241   }

   242 

   243   return (ret == GST_FLOW_OK);

   244 }

   245 

   246 static GstFlowReturn

   247 gst_gio_base_sink_render (GstBaseSink * base_sink, GstBuffer * buffer)

   248 {

   249   GstGioBaseSink *sink = GST_GIO_BASE_SINK (base_sink);

   250   gssize written;

   251   gboolean success;

   252   GError *err = NULL;

   253 

   254   g_return_val_if_fail (G_IS_OUTPUT_STREAM (sink->stream), GST_FLOW_ERROR);

   255 

   256   GST_LOG_OBJECT (sink, "writing %u bytes to offset %" G_GUINT64_FORMAT,

   257       GST_BUFFER_SIZE (buffer), sink->position);

   258 

   259   written = g_output_stream_write (sink->stream,

   260       GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer), sink->cancel, &err);

   261 

   262   success = (written >= 0);

   263 

   264   if (G_UNLIKELY (success && written < GST_BUFFER_SIZE (buffer))) {

   265     /* FIXME: Can this happen?  Should we handle it gracefully?  gnomevfssink

   266      * doesn't... */

   267     GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),

   268         ("Could not write to stream: (short write, only %"

   269             G_GUINT64_FORMAT " bytes of %d bytes written)",

   270             written, GST_BUFFER_SIZE (buffer)));

   271     return GST_FLOW_ERROR;

   272   }

   273 

   274   if (success) {

   275     sink->position += written;

   276     return GST_FLOW_OK;

   277 

   278   } else {

   279     GstFlowReturn ret;

   280 

   281     if (!gst_gio_error (sink, "g_output_stream_write", &err, &ret)) {

   282       GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (NULL),

   283           ("Could not write to stream: %s", err->message));

   284       g_clear_error (&err);

   285     }

   286 

   287     return ret;

   288   }

   289 }

   290 

   291 static gboolean

   292 gst_gio_base_sink_query (GstPad * pad, GstQuery * query)

   293 {

   294   GstGioBaseSink *sink = GST_GIO_BASE_SINK (GST_PAD_PARENT (pad));

   295   GstFormat format;

   296 

   297   switch (GST_QUERY_TYPE (query)) {

   298     case GST_QUERY_POSITION:

   299       gst_query_parse_position (query, &format, NULL);

   300       switch (format) {

   301         case GST_FORMAT_BYTES:

   302         case GST_FORMAT_DEFAULT:

   303           gst_query_set_position (query, GST_FORMAT_BYTES, sink->position);

   304           return TRUE;

   305         default:

   306           return FALSE;

   307       }

   308     case GST_QUERY_FORMATS:

   309       gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES);

   310       return TRUE;

   311     default:

   312       return gst_pad_query_default (pad, query);

   313   }

   314 }

   315 

   316 void

   317 gst_gio_base_sink_set_stream (GstGioBaseSink * sink, GOutputStream * stream)

   318 {

   319   g_return_if_fail (G_IS_OUTPUT_STREAM (stream));

   320   g_return_if_fail ((GST_STATE (sink) != GST_STATE_PLAYING &&

   321           GST_STATE (sink) != GST_STATE_PAUSED));

   322 

   323   if (G_IS_OUTPUT_STREAM (sink->stream)) {

   324     gboolean success;

   325     GError *err = NULL;

   326 

   327     GST_DEBUG_OBJECT (sink, "closing old stream");

   328 

   329     /* FIXME: can block but unfortunately we can't use async operations

   330      * here because they require a running main loop */

   331     success = g_output_stream_close (sink->stream, sink->cancel, &err);

   332 

   333     if (!success && !gst_gio_error (sink, "g_output_stream_close", &err, NULL)) {

   334       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),

   335           ("g_output_stream_close failed: %s", err->message));

   336       g_clear_error (&err);

   337     } else if (!success) {

   338       GST_ELEMENT_WARNING (sink, RESOURCE, CLOSE, (NULL),

   339           ("g_output_stream_close failed"));

   340     } else {

   341       GST_DEBUG_OBJECT (sink, "g_output_stream_close succeeded");

   342     }

   343 

   344     g_object_unref (sink->stream);

   345     sink->stream = NULL;

   346   }

   347 

   348   sink->stream = stream;

   349 }