[rygel-gst-0-10-media-engine] cleanup

[Murray Cumming <murrayc src gnome org>]

commit 23b53436d8d64c16ff4bce5e0eea6f003d2a71cd
Author: Murray Cumming <murrayc murrayc com>
Date:   Thu Dec 20 15:08:30 2012 +0100

    cleanup

 src/rygel-gst-sink.c |  419 +++++++++++++++-----------------------------------
 1 files changed, 126 insertions(+), 293 deletions(-)
---
diff --git a/src/rygel-gst-sink.c b/src/rygel-gst-sink.c
index b411050..bc375d8 100644
--- a/src/rygel-gst-sink.c
+++ b/src/rygel-gst-sink.c
@@ -28,14 +28,6 @@
 
 G_DEFINE_TYPE (RygelGstSink, rygel_gst_sink, GST_TYPE_BASE_SINK)
 
-
-#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
-#define _gst_buffer_unref0(var) ((var == NULL) ? NULL : (var = (gst_buffer_unref (var), NULL)))
-typedef struct _Block1Data Block1Data;
-#define _gst_object_unref0(var) ((var == NULL) ? NULL : (var = (gst_object_unref (var), NULL)))
-#define _gst_caps_unref0(var) ((var == NULL) ? NULL : (var = (gst_caps_unref (var), NULL)))
-
-
 struct _RygelGstSinkPrivate {
   gint priority;
   gint64 chunks_buffered;
@@ -48,358 +40,219 @@ struct _RygelGstSinkPrivate {
   gboolean frozen;
 };
 
-struct _Block1Data {
+typedef struct _CallbackData CallbackData;
+
+struct _CallbackData {
   int _ref_count_;
   RygelGstSink * self;
   GstBuffer* buffer;
 };
 
-
-
 #define RYGEL_GST_SINK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RYGEL_TYPE_GST_SINK, RygelGstSinkPrivate))
 
 #define RYGEL_GST_SINK_NAME "http-gst-sink"
 #define RYGEL_GST_SINK_PAD_NAME "sink"
 #define RYGEL_GST_SINK_MAX_BUFFERED_CHUNKS ((guint) 32)
 #define RYGEL_GST_SINK_MIN_BUFFERED_CHUNKS ((guint) 4)
-RygelGstSink* rygel_gst_sink_new (RygelDataSource* source, RygelHTTPSeek* offsets);
-RygelGstSink* rygel_gst_sink_construct (GType object_type, RygelDataSource* source, RygelHTTPSeek* offsets);
+
 static void rygel_gst_sink_on_cancelled (RygelGstSink* self);
-static void _rygel_gst_sink_on_cancelled_g_cancellable_cancelled (GCancellable* _sender, gpointer self);
-void rygel_gst_sink_freeze (RygelGstSink* self);
-void rygel_gst_sink_thaw (RygelGstSink* self);
+static void on_cancelled (GCancellable* _sender, gpointer self);
 static GstFlowReturn rygel_gst_sink_real_render (GstBaseSink* base, GstBuffer* buffer);
-static Block1Data* block1_data_ref (Block1Data* _data1_);
-static void block1_data_unref (void * _userdata_);
-static gboolean __lambda2_ (Block1Data* _data1_);
 gboolean rygel_gst_sink_push_data (RygelGstSink* self, GstBuffer* buffer);
-static gboolean ___lambda2__gsource_func (gpointer self);
+static gboolean on_idle_push_data (gpointer self);
 static void rygel_gst_sink_finalize (GObject* obj);
-static void _vala_clear_GMutex (GMutex * mutex);
-static void _vala_clear_GRecMutex (GRecMutex * mutex);
-static void _vala_clear_GRWLock (GRWLock * mutex);
-static void _vala_clear_GCond (GCond * mutex);
-
+static void clear_gmutex (GMutex * mutex);
+static void clear_gcond (GCond * mutex);
 
-static gpointer _g_object_ref0 (gpointer self) {
-  return self ? g_object_ref (self) : NULL;
-}
-
-
-static void _rygel_gst_sink_on_cancelled_g_cancellable_cancelled (GCancellable* _sender, gpointer self) {
+static void
+on_cancelled (GCancellable* _sender, gpointer self) {
   rygel_gst_sink_on_cancelled (self);
 }
 
+RygelGstSink*
+rygel_gst_sink_construct (GType object_type, RygelDataSource* source, RygelHTTPSeek* offsets) {
+  RygelGstSink *self = RYGEL_GST_SINK (g_object_new (object_type, NULL));
 
-RygelGstSink* rygel_gst_sink_construct (GType object_type, RygelDataSource* source, RygelHTTPSeek* offsets) {
-  RygelGstSink * self = NULL;
-  gint64 _tmp0_;
-  RygelDataSource* _tmp1_;
-  RygelHTTPSeek* _tmp2_;
-  RygelHTTPSeek* _tmp3_;
-  GCancellable* _tmp4_;
-  RygelHTTPSeek* _tmp5_;
-  GCancellable* _tmp12_;
-  g_return_val_if_fail (source != NULL, NULL);
-  self = (RygelGstSink*) g_object_new (object_type, NULL);
   self->priv->chunks_buffered = (gint64) 0;
   self->priv->bytes_sent = (gint64) 0;
-  _tmp0_ = G_MAXINT64;
-  self->priv->max_bytes = _tmp0_;
-  _tmp1_ = source;
-  self->priv->source = _tmp1_;
-  _tmp2_ = offsets;
-  _tmp3_ = _g_object_ref0 (_tmp2_);
-  _g_object_unref0 (self->priv->offsets);
-  self->priv->offsets = _tmp3_;
-  _tmp4_ = g_cancellable_new ();
-  _g_object_unref0 (self->cancellable);
-  self->cancellable = _tmp4_;
-  gst_base_sink_set_sync ((GstBaseSink*) self, FALSE);
-  gst_object_set_name ((GstObject*) self, RYGEL_GST_SINK_NAME);
+  self->priv->max_bytes = G_MAXINT64;
+  self->priv->source = source;
+  self->priv->offsets = g_object_ref (offsets);
+
+  self->cancellable = g_cancellable_new ();
+
+  gst_base_sink_set_sync (GST_BASE_SINK (self), FALSE);
+  gst_object_set_name (GST_OBJECT (self), RYGEL_GST_SINK_NAME);
   self->priv->frozen = FALSE;
-  _tmp5_ = self->priv->offsets;
-  if (_tmp5_ != NULL) {
-    RygelHTTPSeek* _tmp6_;
-    RygelHTTPSeekType _tmp7_;
-    RygelHTTPSeekType _tmp8_;
-    _tmp6_ = self->priv->offsets;
-    _tmp7_ = rygel_http_seek_get_seek_type (_tmp6_);
-    _tmp8_ = _tmp7_;
-    if (_tmp8_ == RYGEL_HTTP_SEEK_TYPE_BYTE) {
-      RygelHTTPSeek* _tmp9_;
-      gint64 _tmp10_;
-      gint64 _tmp11_;
-      _tmp9_ = self->priv->offsets;
-      _tmp10_ = rygel_http_seek_get_length (_tmp9_);
-      _tmp11_ = _tmp10_;
-      self->priv->max_bytes = _tmp11_;
+
+  if (self->priv->offsets) {
+    if (rygel_http_seek_get_seek_type (self->priv->offsets) == RYGEL_HTTP_SEEK_TYPE_BYTE) {
+      self->priv->max_bytes = rygel_http_seek_get_length (self->priv->offsets);
     }
   }
-  _tmp12_ = self->cancellable;
-  g_signal_connect_object (_tmp12_, "cancelled", (GCallback) _rygel_gst_sink_on_cancelled_g_cancellable_cancelled, self, 0);
+
+  g_signal_connect_object (self->cancellable, "cancelled", (GCallback) on_cancelled, self, 0);
   return self;
 }
 
-
-RygelGstSink* rygel_gst_sink_new (RygelDataSource* source, RygelHTTPSeek* offsets) {
+RygelGstSink*
+rygel_gst_sink_new (RygelDataSource* source, RygelHTTPSeek* offsets) {
   return rygel_gst_sink_construct (RYGEL_TYPE_GST_SINK, source, offsets);
 }
 
 
-void rygel_gst_sink_freeze (RygelGstSink* self) {
-  gboolean _tmp0_;
-  g_return_if_fail (self != NULL);
-  _tmp0_ = self->priv->frozen;
-  if (_tmp0_) {
+void
+rygel_gst_sink_freeze (RygelGstSink* self) {
+  g_return_if_fail (self);
+
+  if (self->priv->frozen) {
     return;
   }
+
   g_mutex_lock (&self->priv->buffer_mutex);
   self->priv->frozen = TRUE;
   g_mutex_unlock (&self->priv->buffer_mutex);
 }
 
+void
+rygel_gst_sink_thaw (RygelGstSink* self) {
+  g_return_if_fail (self);
 
-void rygel_gst_sink_thaw (RygelGstSink* self) {
-  gboolean _tmp0_;
-  g_return_if_fail (self != NULL);
-  _tmp0_ = self->priv->frozen;
-  if (!_tmp0_) {
+  if (!self->priv->frozen) {
     return;
   }
+
   g_mutex_lock (&self->priv->buffer_mutex);
   self->priv->frozen = FALSE;
   g_cond_broadcast (&self->priv->buffer_condition);
   g_mutex_unlock (&self->priv->buffer_mutex);
 }
 
+static gboolean on_idle_push_data (gpointer user_data) {
+  CallbackData* data = (CallbackData*)user_data;
 
-static gpointer _gst_buffer_ref0 (gpointer self) {
-  return self ? gst_buffer_ref (self) : NULL;
+  return rygel_gst_sink_push_data (data->self, data->buffer);
 }
 
-
-static Block1Data* block1_data_ref (Block1Data* _data1_) {
-  g_atomic_int_inc (&_data1_->_ref_count_);
-  return _data1_;
+static CallbackData*
+callback_data_ref (CallbackData* callback_data) {
+  g_atomic_int_inc (&callback_data->_ref_count_);
+  return callback_data;
 }
 
-
-static void block1_data_unref (void * _userdata_) {
-  Block1Data* _data1_;
-  _data1_ = (Block1Data*) _userdata_;
-  if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
-    RygelGstSink * self;
-    self = _data1_->self;
-    _gst_buffer_unref0 (_data1_->buffer);
-    _gst_object_unref0 (self);
-    g_slice_free (Block1Data, _data1_);
+static void
+callback_data_unref (void * user_data) {
+  CallbackData* callback_data = (CallbackData*) user_data;
+  if (g_atomic_int_dec_and_test (&callback_data->_ref_count_)) {
+    RygelGstSink * self = callback_data->self;
+    gst_buffer_unref (callback_data->buffer);
+    gst_object_unref (self);
+    g_slice_free (CallbackData, callback_data);
   }
 }
 
-
-static gboolean __lambda2_ (Block1Data* _data1_) {
-  RygelGstSink * self;
-  gboolean result = FALSE;
-  GstBuffer* _tmp0_;
-  gboolean _tmp1_ = FALSE;
-  self = _data1_->self;
-  _tmp0_ = _data1_->buffer;
-  _tmp1_ = rygel_gst_sink_push_data (self, _tmp0_);
-  result = _tmp1_;
-  return result;
-}
-
-
-static gboolean ___lambda2__gsource_func (gpointer self) {
-  gboolean result;
-  result = __lambda2_ (self);
-  return result;
-}
-
-
 static GstFlowReturn rygel_gst_sink_real_render (GstBaseSink* base, GstBuffer* buffer) {
-  RygelGstSink * self;
-  GstFlowReturn result = 0;
-  Block1Data* _data1_;
-  GstBuffer* _tmp0_;
-  GstBuffer* _tmp1_;
-  GCancellable* _tmp8_;
-  gboolean _tmp9_ = FALSE;
-  gint _tmp10_;
-  self = (RygelGstSink*) base;
-  g_return_val_if_fail (buffer != NULL, 0);
-  _data1_ = g_slice_new0 (Block1Data);
-  _data1_->_ref_count_ = 1;
-  _data1_->self = gst_object_ref (self);
-  _tmp0_ = buffer;
-  _tmp1_ = _gst_buffer_ref0 (_tmp0_);
-  _gst_buffer_unref0 (_data1_->buffer);
-  _data1_->buffer = _tmp1_;
+  RygelGstSink *self = RYGEL_GST_SINK (base);
+  CallbackData* callback_data;
+
   g_mutex_lock (&self->priv->buffer_mutex);
-  while (TRUE) {
-    gboolean _tmp2_ = FALSE;
-    GCancellable* _tmp3_;
-    gboolean _tmp4_ = FALSE;
-    gboolean _tmp6_;
-    GMutex _tmp7_;
-    _tmp3_ = self->cancellable;
-    _tmp4_ = g_cancellable_is_cancelled (_tmp3_);
-    if (!_tmp4_) {
-      gboolean _tmp5_;
-      _tmp5_ = self->priv->frozen;
-      _tmp2_ = _tmp5_;
-    } else {
-      _tmp2_ = FALSE;
-    }
-    _tmp6_ = _tmp2_;
-    if (!_tmp6_) {
-      break;
-    }
-    _tmp7_ = self->priv->buffer_mutex;
-    g_cond_wait (&self->priv->buffer_condition, &_tmp7_);
+  while (!g_cancellable_is_cancelled (self->cancellable) &&
+    self->priv->frozen) {
+    /* Client is either not reading (Paused) or not fast enough */
+    g_cond_wait (&self->priv->buffer_condition, &self->priv->buffer_mutex);
   }
   g_mutex_unlock (&self->priv->buffer_mutex);
-  _tmp8_ = self->cancellable;
-  _tmp9_ = g_cancellable_is_cancelled (_tmp8_);
-  if (_tmp9_) {
-    result = GST_FLOW_OK;
-    block1_data_unref (_data1_);
-    _data1_ = NULL;
-    return result;
+
+  if(g_cancellable_is_cancelled (self->cancellable)) {
+    return GST_FLOW_OK;
   }
-  _tmp10_ = self->priv->priority;
-  g_idle_add_full (_tmp10_, ___lambda2__gsource_func, block1_data_ref (_data1_), block1_data_unref);
-  result = GST_FLOW_OK;
-  block1_data_unref (_data1_);
-  _data1_ = NULL;
-  return result;
+
+  /* Use a ref-counted object to pass both this sink and the buffer
+   * to the idle callback. */
+  callback_data = g_slice_new0 (CallbackData);
+  callback_data->_ref_count_ = 1;
+  callback_data->self = gst_object_ref (self);
+  callback_data->buffer = gst_object_ref (buffer);
+  g_idle_add_full (self->priv->priority, on_idle_push_data, callback_data_ref (callback_data), callback_data_unref);
+
+  return GST_FLOW_OK;
 }
 
+/* Runs in application thread */
+gboolean
+rygel_gst_sink_push_data (RygelGstSink* self, GstBuffer* buffer) {
 
-gboolean rygel_gst_sink_push_data (RygelGstSink* self, GstBuffer* buffer) {
-  gboolean result = FALSE;
-  gint64 _tmp0_;
-  gint64 _tmp1_;
-  gint64 left;
-  gboolean _tmp2_ = FALSE;
-  GCancellable* _tmp3_;
-  gboolean _tmp4_ = FALSE;
-  gboolean _tmp6_;
-  GstBuffer* _tmp7_;
-  guint _tmp8_;
-  gint64 _tmp9_;
-  gint64 _tmp10_ = 0LL;
-  gint64 to_send;
-  RygelDataSource* _tmp11_;
-  GstBuffer* _tmp12_;
-  guint8* _tmp13_;
-  gint _tmp13__length1;
-  gint64 _tmp14_;
-  gint64 _tmp15_;
-  gint64 _tmp16_;
-  gint64 _tmp17_;
-  g_return_val_if_fail (self != NULL, FALSE);
-  g_return_val_if_fail (buffer != NULL, FALSE);
-  _tmp0_ = self->priv->max_bytes;
-  _tmp1_ = self->priv->bytes_sent;
-  left = _tmp0_ - _tmp1_;
-  _tmp3_ = self->cancellable;
-  _tmp4_ = g_cancellable_is_cancelled (_tmp3_);
-  if (_tmp4_) {
-    _tmp2_ = TRUE;
-  } else {
-    gint64 _tmp5_;
-    _tmp5_ = left;
-    _tmp2_ = _tmp5_ <= ((gint64) 0);
-  }
-  _tmp6_ = _tmp2_;
-  if (_tmp6_) {
-    result = FALSE;
-    return result;
+  gint64 left = self->priv->max_bytes - self->priv->bytes_sent;
+
+  if(g_cancellable_is_cancelled (self->cancellable) ||
+    left <= 0) {
+    return FALSE;
   }
-  _tmp7_ = buffer;
-  _tmp8_ = _tmp7_->size;
-  _tmp9_ = left;
-  _tmp10_ = MIN ((gint64) _tmp8_, _tmp9_);
-  to_send = _tmp10_;
-  _tmp11_ = self->priv->source;
-  _tmp12_ = buffer;
-  _tmp13_ = _tmp12_->data;
-  _tmp13__length1 = (gint) _tmp12_->size;
-  _tmp14_ = to_send;
-  g_signal_emit_by_name (_tmp11_, "data-available", _tmp13_ + 0, _tmp14_ - 0);
-  _tmp15_ = self->priv->chunks_buffered;
-  self->priv->chunks_buffered = _tmp15_ + 1;
-  _tmp16_ = self->priv->bytes_sent;
-  _tmp17_ = to_send;
-  self->priv->bytes_sent = _tmp16_ + _tmp17_;
-  result = FALSE;
-  return result;
-}
 
+  guint bufsize = buffer->size;
+  gint64 to_send = MIN ((gint64) bufsize, left);
+  
+  g_signal_emit_by_name (self->priv->source, "data-available", buffer->data, to_send);
+  self->priv->chunks_buffered++;
+  self->priv->bytes_sent += to_send;
+
+  return FALSE;
+}
 
-static void rygel_gst_sink_on_cancelled (RygelGstSink* self) {
+static void
+rygel_gst_sink_on_cancelled (RygelGstSink* self) {
   g_return_if_fail (self != NULL);
   g_mutex_lock (&self->priv->buffer_mutex);
   g_cond_broadcast (&self->priv->buffer_condition);
   g_mutex_unlock (&self->priv->buffer_mutex);
 }
 
-
-static gpointer _gst_caps_ref0 (gpointer self) {
-  return self ? gst_caps_ref (self) : NULL;
-}
-
-
-static void rygel_gst_sink_class_init (RygelGstSinkClass * klass) {
-  GstCaps* _tmp0_;
+static void
+rygel_gst_sink_class_init (RygelGstSinkClass * klass) {
   GstCaps* caps;
-  GstCaps* _tmp1_;
-  GstCaps* _tmp2_;
-  GstPadTemplate* _tmp3_;
   GstPadTemplate* template;
-  GstPadTemplate* _tmp4_;
+
   rygel_gst_sink_parent_class = g_type_class_peek_parent (klass);
   g_type_class_add_private (klass, sizeof (RygelGstSinkPrivate));
+
   GST_BASE_SINK_CLASS (klass)->render = rygel_gst_sink_real_render;
   G_OBJECT_CLASS (klass)->finalize = rygel_gst_sink_finalize;
-  _tmp0_ = gst_caps_new_any ();
-  caps = _tmp0_;
-  _tmp1_ = caps;
-  _tmp2_ = _gst_caps_ref0 (_tmp1_);
-  _tmp3_ = gst_pad_template_new (RYGEL_GST_SINK_PAD_NAME, GST_PAD_SINK, GST_PAD_ALWAYS, _tmp2_);
-  gst_object_ref_sink (_tmp3_);
-  template = _tmp3_;
-  _tmp4_ = template;
-  gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), _tmp4_);
-  _gst_object_unref0 (template);
-  _gst_caps_unref0 (caps);
+
+  caps = gst_caps_new_any ();
+  template =  gst_pad_template_new (RYGEL_GST_SINK_PAD_NAME, 
+    GST_PAD_SINK, GST_PAD_ALWAYS, caps);
+  gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), template);
+  gst_object_unref (template);
+  gst_caps_unref (caps);
 }
 
+static void
+rygel_gst_sink_init (RygelGstSink * self) {
+  GMutex mutex = {0};
+  GCond cond = {0};
 
-static void rygel_gst_sink_init (RygelGstSink * self) {
-  GMutex _tmp0_ = {0};
-  GCond _tmp1_ = {0};
   self->priv = RYGEL_GST_SINK_GET_PRIVATE (self);
-  g_mutex_init (&_tmp0_);
-  self->priv->buffer_mutex = _tmp0_;
-  g_cond_init (&_tmp1_);
-  self->priv->buffer_condition = _tmp1_;
+
+  g_mutex_init (&mutex);
+  self->priv->buffer_mutex = mutex;
+  g_cond_init (&cond);
+  self->priv->buffer_condition = cond;
 }
 
+static void
+rygel_gst_sink_finalize (GObject* obj) {
+  RygelGstSink * self = RYGEL_GST_SINK (obj);
+
+  g_object_unref (self->cancellable);
+  clear_gmutex (&self->priv->buffer_mutex);
+  clear_gcond (&self->priv->buffer_condition);
+  g_object_unref (self->priv->offsets);
 
-static void rygel_gst_sink_finalize (GObject* obj) {
-  RygelGstSink * self;
-  self = RYGEL_GST_SINK (obj);
-  _g_object_unref0 (self->cancellable);
-  _vala_clear_GMutex (&self->priv->buffer_mutex);
-  _vala_clear_GCond (&self->priv->buffer_condition);
-  _g_object_unref0 (self->priv->offsets);
   G_OBJECT_CLASS (rygel_gst_sink_parent_class)->finalize (obj);
 }
 
-static void _vala_clear_GMutex (GMutex * mutex) {
+static void
+clear_gmutex (GMutex * mutex) {
   GMutex zero_mutex = { 0 };
   if (memcmp (mutex, &zero_mutex, sizeof (GMutex))) {
     g_mutex_clear (mutex);
@@ -407,26 +260,8 @@ static void _vala_clear_GMutex (GMutex * mutex) {
   }
 }
 
-
-static void _vala_clear_GRecMutex (GRecMutex * mutex) {
-  GRecMutex zero_mutex = { 0 };
-  if (memcmp (mutex, &zero_mutex, sizeof (GRecMutex))) {
-    g_rec_mutex_clear (mutex);
-    memset (mutex, 0, sizeof (GRecMutex));
-  }
-}
-
-
-static void _vala_clear_GRWLock (GRWLock * mutex) {
-  GRWLock zero_mutex = { 0 };
-  if (memcmp (mutex, &zero_mutex, sizeof (GRWLock))) {
-    g_rw_lock_clear (mutex);
-    memset (mutex, 0, sizeof (GRWLock));
-  }
-}
-
-
-static void _vala_clear_GCond (GCond * mutex) {
+static void
+clear_gcond (GCond * mutex) {
   GCond zero_mutex = { 0 };
   if (memcmp (mutex, &zero_mutex, sizeof (GCond))) {
     g_cond_clear (mutex);
@@ -434,5 +269,3 @@ static void _vala_clear_GCond (GCond * mutex) {
   }
 }
 
-
-