static gboolean gst_tcp_server_src_stop (GstBaseSrc * bsrc) { GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); gst_poll_free (src->fdset); src->fdset = NULL; gst_tcp_socket_close (&src->server_sock_fd); gst_tcp_socket_close (&src->client_sock_fd); GST_OBJECT_FLAG_UNSET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; }
/** * gst_object_ref_sink: * @object: a #GstObject to sink * * Increase the reference count of @object, and possibly remove the floating * reference, if @object has a floating reference. * * In other words, if the object is floating, then this call "assumes ownership" * of the floating reference, converting it to a normal reference by clearing * the floating flag while leaving the reference count unchanged. If the object * is not floating, then this call adds a new normal reference increasing the * reference count by one. * * MT safe. This function grabs and releases @object lock. * * Since: 0.10.24 */ void gst_object_ref_sink (gpointer object) { g_return_if_fail (GST_IS_OBJECT (object)); GST_OBJECT_LOCK (object); if (G_LIKELY (GST_OBJECT_IS_FLOATING (object))) { GST_CAT_TRACE_OBJECT (GST_CAT_REFCOUNTING, object, "unsetting floating flag"); GST_OBJECT_FLAG_UNSET (object, GST_OBJECT_FLOATING); GST_OBJECT_UNLOCK (object); } else { GST_OBJECT_UNLOCK (object); gst_object_ref (object); } }
/** * gst_pipeline_auto_clock: * @pipeline: a [GstPipeline]() * * Let _pipeline_ select a clock automatically. This is the default * behaviour. * * Use this function if you previous forced a fixed clock with * [gst_pipeline_use_clock]() and want to restore the default * pipeline clock selection algorithm. * * MT safe. */ void gst_pipeline_auto_clock (GstPipeline * pipeline) { GstClock **clock_p; g_return_if_fail (pipeline != NULL); g_return_if_fail (GST_IS_PIPELINE (pipeline)); GST_OBJECT_LOCK (pipeline); GST_OBJECT_FLAG_UNSET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK); clock_p = &pipeline->fixed_clock; gst_object_replace ((GstObject **) clock_p, NULL); GST_OBJECT_UNLOCK (pipeline); GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using automatic clock"); }
static void gnl_object_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GnlObject *gnlobject = (GnlObject *) object; g_return_if_fail (GNL_IS_OBJECT (object)); switch (prop_id) { case PROP_START: gnlobject->start = g_value_get_uint64 (value); update_values (gnlobject); break; case PROP_DURATION: gnlobject->duration = g_value_get_int64 (value); update_values (gnlobject); break; case PROP_MEDIA_START: gnlobject->media_start = g_value_get_uint64 (value); break; case PROP_MEDIA_DURATION: gnlobject->media_duration = g_value_get_int64 (value); update_values (gnlobject); break; case PROP_PRIORITY: gnlobject->priority = g_value_get_uint (value); break; case PROP_ACTIVE: gnlobject->active = g_value_get_boolean (value); break; case PROP_CAPS: gnl_object_set_caps (gnlobject, gst_value_get_caps (value)); break; case PROP_EXPANDABLE: if (g_value_get_boolean (value)) GST_OBJECT_FLAG_SET (gnlobject, GNL_OBJECT_EXPANDABLE); else GST_OBJECT_FLAG_UNSET (gnlobject, GNL_OBJECT_EXPANDABLE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void nle_object_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { NleObject *nleobject = (NleObject *) object; g_return_if_fail (NLE_IS_OBJECT (object)); GST_OBJECT_LOCK (object); switch (prop_id) { case PROP_START: SET_PENDING_VALUE (start, "start", uint64, G_GUINT64_FORMAT); break; case PROP_DURATION: SET_PENDING_VALUE (duration, "duration", int64, G_GINT64_FORMAT); break; case PROP_INPOINT: SET_PENDING_VALUE (inpoint, "inpoint", uint64, G_GUINT64_FORMAT); break; case PROP_PRIORITY: SET_PENDING_VALUE (priority, "priority", uint, G_GUINT32_FORMAT); break; case PROP_ACTIVE: SET_PENDING_VALUE (active, "active", boolean, G_GUINT32_FORMAT); break; case PROP_IS_LIVE: nleobject->is_live = g_value_get_boolean (value); break; case PROP_CAPS: nle_object_set_caps (nleobject, gst_value_get_caps (value)); break; case PROP_EXPANDABLE: if (g_value_get_boolean (value)) GST_OBJECT_FLAG_SET (nleobject, NLE_OBJECT_EXPANDABLE); else GST_OBJECT_FLAG_UNSET (nleobject, NLE_OBJECT_EXPANDABLE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } GST_OBJECT_UNLOCK (object); }
EXPORT_C #endif gboolean gst_object_set_parent (GstObject * object, GstObject * parent) { g_return_val_if_fail (GST_IS_OBJECT (object), FALSE); g_return_val_if_fail (GST_IS_OBJECT (parent), FALSE); g_return_val_if_fail (object != parent, FALSE); GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object, "set parent (ref and sink)"); GST_OBJECT_LOCK (object); if (G_UNLIKELY (object->parent != NULL)) goto had_parent; /* sink object, we don't call our own function because we don't * need to release/acquire the lock needlessly or touch the refcount * in the floating case. */ object->parent = parent; if (G_LIKELY (GST_OBJECT_IS_FLOATING (object))) { GST_CAT_LOG_OBJECT (GST_CAT_REFCOUNTING, object, "unsetting floating flag"); GST_OBJECT_FLAG_UNSET (object, GST_OBJECT_FLOATING); GST_OBJECT_UNLOCK (object); } else { GST_OBJECT_UNLOCK (object); gst_object_ref (object); } g_signal_emit (object, gst_object_signals[PARENT_SET], 0, parent); return TRUE; /* ERROR handling */ had_parent: { GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object, "set parent failed, object already had a parent"); GST_OBJECT_UNLOCK (object); return FALSE; } }
static void gst_sctp_base_sink_destroy_socket (GstSCTPBaseSink * self) { GError *err = NULL; if (!GST_OBJECT_FLAG_IS_SET (self, GST_SCTP_BASE_SINK_OPEN)) return; if (self->priv->socket != NULL) { GST_DEBUG_OBJECT (self, "closing socket"); if (!g_socket_close (self->priv->socket, &err)) { GST_ERROR_OBJECT (self, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_clear_object (&self->priv->socket); } GST_OBJECT_FLAG_UNSET (self, GST_SCTP_BASE_SINK_OPEN); }
EXPORT_C #endif void gst_object_sink (gpointer object) { g_return_if_fail (GST_IS_OBJECT (object)); GST_CAT_LOG_OBJECT (GST_CAT_REFCOUNTING, object, "sink"); GST_OBJECT_LOCK (object); if (G_LIKELY (GST_OBJECT_IS_FLOATING (object))) { GST_CAT_LOG_OBJECT (GST_CAT_REFCOUNTING, object, "clear floating flag"); GST_OBJECT_FLAG_UNSET (object, GST_OBJECT_FLOATING); GST_OBJECT_UNLOCK (object); gst_object_unref (object); } else { GST_OBJECT_UNLOCK (object); } }
/** * gst_bus_set_flushing: * @bus: a #GstBus * @flushing: whether or not to flush the bus * * If @flushing, flush out and unref any messages queued in the bus. Releases * references to the message origin objects. Will flush future messages until * gst_bus_set_flushing() sets @flushing to #FALSE. * * MT safe. */ void gst_bus_set_flushing (GstBus * bus, gboolean flushing) { GstMessage *message; GST_OBJECT_LOCK (bus); if (flushing) { GST_OBJECT_FLAG_SET (bus, GST_BUS_FLUSHING); GST_DEBUG_OBJECT (bus, "set bus flushing"); while ((message = gst_bus_pop (bus))) gst_message_unref (message); } else { GST_DEBUG_OBJECT (bus, "unset bus flushing"); GST_OBJECT_FLAG_UNSET (bus, GST_BUS_FLUSHING); } GST_OBJECT_UNLOCK (bus); }
static void on_notify_caps (GstPad * pad, GParamSpec * pspec, GstElement * pay) { GstCaps *caps; g_object_get (pad, "caps", &caps, NULL); GST_DEBUG ("notify %" GST_PTR_FORMAT, caps); if (caps) { if (!GST_OBJECT_FLAG_IS_SET (pay, FLAG_HAVE_CAPS)) { g_signal_emit_by_name (pay, "pad-added", pad); g_signal_emit_by_name (pay, "no-more-pads", NULL); GST_OBJECT_FLAG_SET (pay, FLAG_HAVE_CAPS); } gst_caps_unref (caps); } else { if (GST_OBJECT_FLAG_IS_SET (pay, FLAG_HAVE_CAPS)) { g_signal_emit_by_name (pay, "pad-removed", pad); GST_OBJECT_FLAG_UNSET (pay, FLAG_HAVE_CAPS); } } }
static gboolean gst_tcp_mix_src_stop (GstTCPMixSrc * src, GstTCPMixSrcPad * pad) { GError *err = NULL; GList *item; GST_OBJECT_LOCK (src); GST_DEBUG_OBJECT (src, "Closing client sockets"); for (item = GST_ELEMENT_PADS (src); item; item = g_list_next (item)) { GstPad *p = GST_PAD (item->data); if (GST_PAD_IS_SRC (p)) { gst_tcp_mix_src_pad_reset (GST_TCP_MIX_SRC_PAD (p)); } } GST_OBJECT_UNLOCK (src); if (src->server_socket) { GST_DEBUG_OBJECT (src, "Closing server socket"); if (!g_socket_close (src->server_socket, &err)) { GST_ERROR_OBJECT (src, "Failed to close socket: %s", err->message); g_clear_error (&err); } g_object_unref (src->server_socket); src->server_socket = NULL; gst_tcp_mix_src_stop_acceptor (src); g_atomic_int_set (&src->bound_port, 0); g_object_notify (G_OBJECT (src), "bound-port"); } GST_OBJECT_FLAG_UNSET (src, GST_TCP_MIX_SRC_OPEN); return TRUE; }
static void dxr3videosink_close (Dxr3VideoSink * sink) { g_return_if_fail (GST_OBJECT_FLAG_IS_SET (sink, DXR3VIDEOSINK_OPEN)); if (close (sink->video_fd) != 0) { GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE, (_("Could not close video device \"%s\"."), sink->video_filename), GST_ERROR_SYSTEM); return; } if (close (sink->control_fd) != 0) { GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE, (_("Could not close control device \"%s\"."), sink->control_filename), GST_ERROR_SYSTEM); return; } GST_OBJECT_FLAG_UNSET (sink, DXR3VIDEOSINK_OPEN); free (sink->video_filename); sink->video_filename = NULL; }
/* We have to save the whole set of indexes into a single file so it doesn't make sense to commit only a single writer. i suggest: gst_index_commit (index, -1); */ static void gst_file_index_commit (GstIndex * _index, gint _writer_id) { GstFileIndex *index = GST_FILE_INDEX (_index); xmlDocPtr doc; xmlNodePtr writers; GError *err = NULL; gchar *path; GIOChannel *tocfile; g_return_if_fail (index->location); g_return_if_fail (!index->is_loaded); GST_OBJECT_FLAG_UNSET (index, GST_INDEX_WRITABLE); doc = xmlNewDoc ((xmlChar *) "1.0"); doc->xmlRootNode = xmlNewDocNode (doc, NULL, (xmlChar *) "gstfileindex", NULL); xmlSetProp (doc->xmlRootNode, (xmlChar *) "version", (xmlChar *) "1"); writers = xmlNewChild (doc->xmlRootNode, NULL, (xmlChar *) "writers", NULL); g_hash_table_foreach (index->id_index, (GHFunc) _file_index_id_save_xml, writers); if (mkdir (index->location, 0777) && errno != EEXIST) { GST_ERROR_OBJECT (index, "mkdir %s: %s", index->location, g_strerror (errno)); return; } path = g_strdup_printf ("%s/gstindex.xml", index->location); tocfile = g_io_channel_new_file (path, "w", &err); g_free (path); if (err) { GST_ERROR_OBJECT (index, "%s", err->message); return; } g_io_channel_set_encoding (tocfile, NULL, &err); if (err) { GST_ERROR_OBJECT (index, "%s", err->message); return; } { xmlChar *xmlmem; int xmlsize; xmlDocDumpMemory (doc, &xmlmem, &xmlsize); g_io_channel_write_chars (tocfile, (gchar *) xmlmem, xmlsize, NULL, &err); if (err) { GST_ERROR_OBJECT (index, "%s", err->message); return; } xmlFreeDoc (doc); free (xmlmem); } g_io_channel_shutdown (tocfile, TRUE, &err); if (err) { GST_ERROR_OBJECT (index, "%s", err->message); return; } g_io_channel_unref (tocfile); g_hash_table_foreach (index->id_index, (GHFunc) _file_index_id_save_entries, index->location); }
static void gst_file_index_load (GstFileIndex * index) { xmlDocPtr doc; xmlNodePtr root, part; xmlChar *val; g_assert (index->location); g_return_if_fail (!index->is_loaded); { gchar *path = g_strdup_printf ("%s/gstindex.xml", index->location); GError *err = NULL; gchar *buf; gsize len; g_file_get_contents (path, &buf, &len, &err); g_free (path); if (err) { GST_ERROR_OBJECT (index, "%s", err->message); return; } doc = xmlParseMemory (buf, len); g_free (buf); } //xmlDocFormatDump (stderr, doc, TRUE); root = doc->xmlRootNode; if (strcmp ((char *) root->name, "gstfileindex") != 0) { GST_ERROR_OBJECT (index, "root node isn't a gstfileindex"); return; } val = xmlGetProp (root, (xmlChar *) "version"); if (!val || atoi ((char *) val) != 1) { GST_ERROR_OBJECT (index, "version != 1"); return; } free (val); for (part = root->children; part; part = part->next) { if (strcmp ((char *) part->name, "writers") == 0) { xmlNodePtr writer; for (writer = part->children; writer; writer = writer->next) { xmlChar *datafile = xmlGetProp (writer, (xmlChar *) "datafile"); gchar *path = g_strdup_printf ("%s/%s", index->location, datafile); int fd; GstFileIndexId *id_index; xmlNodePtr wpart; xmlChar *entries_str; gpointer array_data; free (datafile); fd = open (path, O_RDONLY); g_free (path); if (fd < 0) { GST_ERROR_OBJECT (index, "Can't open '%s': %s", path, g_strerror (errno)); continue; } id_index = g_slice_new0 (GstFileIndexId); id_index->id_desc = (char *) xmlGetProp (writer, (xmlChar *) "id"); for (wpart = writer->children; wpart; wpart = wpart->next) { if (strcmp ((char *) wpart->name, "formats") == 0) { xmlChar *count_str = xmlGetProp (wpart, (xmlChar *) "count"); gint fx = 0; xmlNodePtr format; id_index->nformats = atoi ((char *) count_str); free (count_str); id_index->format = g_new (GstFormat, id_index->nformats); for (format = wpart->children; format; format = format->next) { xmlChar *nick = xmlGetProp (format, (xmlChar *) "nick"); GstFormat fmt = gst_format_get_by_nick ((gchar *) nick); if (fmt == GST_FORMAT_UNDEFINED) GST_ERROR_OBJECT (index, "format '%s' undefined", nick); g_assert (fx < id_index->nformats); id_index->format[fx++] = fmt; free (nick); } } else GST_INFO_OBJECT (index, "unknown wpart '%s'", wpart->name); } g_assert (id_index->nformats > 0); _fc_alloc_array (id_index); g_assert (id_index->array->data == NULL); /* little bit risky */ entries_str = xmlGetProp (writer, (xmlChar *) "entries"); id_index->array->len = atoi ((char *) entries_str); free (entries_str); array_data = mmap (NULL, ARRAY_TOTAL_SIZE (id_index), PROT_READ, MAP_SHARED, fd, 0); close (fd); if (array_data == MAP_FAILED) { GST_ERROR_OBJECT (index, "mmap %s failed: %s", path, g_strerror (errno)); continue; } id_index->array->data = array_data; index->unresolved = g_slist_prepend (index->unresolved, id_index); } } else GST_INFO_OBJECT (index, "unknown part '%s'", part->name); } xmlFreeDoc (doc); GST_OBJECT_FLAG_UNSET (index, GST_INDEX_WRITABLE); index->is_loaded = TRUE; GST_LOG_OBJECT (index, "index %s loaded OK", index->location); }