static void gst_net_time_provider_finalize (GObject * object) { GstNetTimeProvider *self = GST_NET_TIME_PROVIDER (object); if (self->thread) { gst_net_time_provider_stop (self); g_assert (self->thread == NULL); } if (self->priv->fdset) { gst_poll_free (self->priv->fdset); self->priv->fdset = NULL; } g_free (self->address); self->address = NULL; if (self->clock) gst_object_unref (self->clock); self->clock = NULL; #ifdef G_OS_WIN32 WSACleanup (); #endif G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gst_vaapi_window_wayland_destroy (GstVaapiWindow * window) { GstVaapiWindowWaylandPrivate *const priv = GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window); /* Wait for the last frame to complete redraw */ gst_vaapi_window_wayland_sync (window); if (priv->last_frame) { frame_state_free (priv->last_frame); priv->last_frame = NULL; } if (priv->shell_surface) { wl_shell_surface_destroy (priv->shell_surface); priv->shell_surface = NULL; } if (priv->surface) { wl_surface_destroy (priv->surface); priv->surface = NULL; } if (priv->event_queue) { wl_event_queue_destroy (priv->event_queue); priv->event_queue = NULL; } gst_vaapi_filter_replace (&priv->filter, NULL); gst_vaapi_video_pool_replace (&priv->surface_pool, NULL); gst_poll_free (priv->poll); }
static void gst_curl_base_sink_finalize (GObject * gobject) { GstCurlBaseSink *this = GST_CURL_BASE_SINK (gobject); GST_DEBUG ("finalizing curlsink"); if (this->transfer_thread != NULL) { g_thread_join (this->transfer_thread); } gst_curl_base_sink_transfer_cleanup (this); g_cond_clear (&this->transfer_cond->cond); g_free (this->transfer_cond); g_free (this->transfer_buf); g_free (this->url); g_free (this->user); g_free (this->passwd); g_free (this->file_name); if (this->fdset != NULL) { gst_poll_free (this->fdset); this->fdset = NULL; } G_OBJECT_CLASS (parent_class)->finalize (gobject); }
static void gst_bus_dispose (GObject * object) { GstBus *bus = GST_BUS (object); if (bus->priv->queue) { GstMessage *message; g_mutex_lock (&bus->priv->queue_lock); do { message = gst_atomic_queue_pop (bus->priv->queue); if (message) gst_message_unref (message); } while (message != NULL); gst_atomic_queue_unref (bus->priv->queue); bus->priv->queue = NULL; g_mutex_unlock (&bus->priv->queue_lock); g_mutex_clear (&bus->priv->queue_lock); if (bus->priv->poll) gst_poll_free (bus->priv->poll); bus->priv->poll = NULL; } G_OBJECT_CLASS (parent_class)->dispose (object); }
static gboolean gst_shm_sink_stop (GstBaseSink * bsink) { GstShmSink *self = GST_SHM_SINK (bsink); self->stop = TRUE; gst_poll_set_flushing (self->poll, TRUE); if (self->allocator) gst_object_unref (self->allocator); self->allocator = NULL; g_thread_join (self->pollthread); self->pollthread = NULL; GST_DEBUG_OBJECT (self, "Stopping"); while (self->clients) { struct GstShmClient *client = self->clients->data; self->clients = g_list_remove (self->clients, client); sp_writer_close_client (self->pipe, client->client, (sp_buffer_free_callback) gst_buffer_unref, NULL); g_signal_emit (self, signals[SIGNAL_CLIENT_DISCONNECTED], 0, client->pollfd.fd); g_slice_free (struct GstShmClient, client); } gst_poll_free (self->poll); self->poll = NULL; sp_writer_close (self->pipe, NULL, NULL); self->pipe = NULL; return TRUE; }
static void gst_net_client_clock_finalize (GObject * object) { GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object); if (self->thread) { gst_net_client_clock_stop (self); g_assert (self->thread == NULL); } if (self->priv->fdset) { gst_poll_free (self->priv->fdset); self->priv->fdset = NULL; } g_free (self->address); self->address = NULL; g_free (self->servaddr); self->servaddr = NULL; #ifdef G_OS_WIN32 WSACleanup (); #endif G_OBJECT_CLASS (parent_class)->finalize (object); }
static gboolean gst_shm_sink_start (GstBaseSink * bsink) { GstShmSink *self = GST_SHM_SINK (bsink); GError *err = NULL; self->stop = FALSE; if (!self->socket_path) { GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ_WRITE, ("Could not open socket."), (NULL)); return FALSE; } GST_DEBUG_OBJECT (self, "Creating new socket at %s" " with shared memory of %d bytes", self->socket_path, self->size); self->pipe = sp_writer_create (self->socket_path, self->size, self->perms); if (!self->pipe) { GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ_WRITE, ("Could not open socket."), (NULL)); return FALSE; } sp_set_data (self->pipe, self); g_free (self->socket_path); self->socket_path = g_strdup (sp_writer_get_path (self->pipe)); GST_DEBUG ("Created socket at %s", self->socket_path); self->poll = gst_poll_new (TRUE); gst_poll_fd_init (&self->serverpollfd); self->serverpollfd.fd = sp_get_fd (self->pipe); gst_poll_add_fd (self->poll, &self->serverpollfd); gst_poll_fd_ctl_read (self->poll, &self->serverpollfd, TRUE); self->pollthread = g_thread_try_new ("gst-shmsink-poll-thread", pollthread_func, self, &err); if (!self->pollthread) goto thread_error; self->allocator = gst_shm_sink_allocator_new (self); return TRUE; thread_error: sp_writer_close (self->pipe, NULL, NULL); self->pipe = NULL; gst_poll_free (self->poll); GST_ELEMENT_ERROR (self, CORE, THREAD, ("Could not start thread"), ("%s", err->message)); g_error_free (err); return FALSE; }
static void gst_shm_src_finalize (GObject * object) { GstShmSrc *self = GST_SHM_SRC (object); gst_poll_free (self->poll); G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gst_wl_display_finalize (GObject * gobject) { GstWlDisplay *self = GST_WL_DISPLAY (gobject); gst_poll_set_flushing (self->wl_fd_poll, TRUE); if (self->thread) g_thread_join (self->thread); /* to avoid buffers being unregistered from another thread * at the same time, take their ownership */ g_mutex_lock (&self->buffers_mutex); self->shutting_down = TRUE; g_hash_table_foreach (self->buffers, (GHFunc) g_object_ref, NULL); g_mutex_unlock (&self->buffers_mutex); g_hash_table_foreach (self->buffers, (GHFunc) gst_wl_buffer_force_release_and_unref, NULL); g_hash_table_remove_all (self->buffers); g_array_unref (self->shm_formats); g_array_unref (self->dmabuf_formats); gst_poll_free (self->wl_fd_poll); g_hash_table_unref (self->buffers); g_mutex_clear (&self->buffers_mutex); if (self->viewporter) wp_viewporter_destroy (self->viewporter); if (self->shm) wl_shm_destroy (self->shm); if (self->dmabuf) zwp_linux_dmabuf_v1_destroy (self->dmabuf); if (self->shell) wl_shell_destroy (self->shell); if (self->compositor) wl_compositor_destroy (self->compositor); if (self->subcompositor) wl_subcompositor_destroy (self->subcompositor); if (self->registry) wl_registry_destroy (self->registry); if (self->queue) wl_event_queue_destroy (self->queue); if (self->own_display) { wl_display_flush (self->display); wl_display_disconnect (self->display); } G_OBJECT_CLASS (gst_wl_display_parent_class)->finalize (gobject); }
static void gst_avdtp_src_finalize (GObject * object) { GstAvdtpSrc *avdtpsrc = GST_AVDTP_SRC (object); gst_poll_free (avdtpsrc->poll); gst_avdtp_connection_reset (&avdtpsrc->conn); G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gst_kms_sink_finalize (GObject * object) { GstKMSSink *sink; sink = GST_KMS_SINK (object); g_clear_pointer (&sink->devname, g_free); gst_poll_free (sink->poll); G_OBJECT_CLASS (parent_class)->finalize (object); }
static gboolean gst_fd_sink_stop (GstBaseSink * basesink) { GstFdSink *fdsink = GST_FD_SINK (basesink); if (fdsink->fdset) { gst_poll_free (fdsink->fdset); fdsink->fdset = NULL; } return TRUE; }
static gboolean gst_fd_src_stop (GstBaseSrc * bsrc) { GstFdSrc *src = GST_FD_SRC (bsrc); if (src->fdset) { gst_poll_free (src->fdset); src->fdset = NULL; } return TRUE; }
static gboolean gst_dvbsrc_stop (GstBaseSrc * bsrc) { GstDvbSrc *src = GST_DVBSRC (bsrc); gst_dvbsrc_close_devices (src); if (src->poll) { gst_poll_free (src->poll); src->poll = NULL; } return TRUE; }
static gboolean gst_curl_base_sink_stop (GstBaseSink * bsink) { GstCurlBaseSink *sink = GST_CURL_BASE_SINK (bsink); gst_curl_base_sink_transfer_thread_close (sink); if (sink->fdset != NULL) { gst_poll_free (sink->fdset); sink->fdset = NULL; } return TRUE; }
static gboolean plugin_loader_free (GstPluginLoader * loader) { GList *cur; gboolean got_plugin_details; fsync (loader->fd_w.fd); if (loader->child_running) { put_packet (loader, PACKET_EXIT, 0, NULL, 0); /* Swap packets with the child until it exits cleanly */ while (!loader->rx_done) { if (exchange_packets (loader) || loader->rx_done) continue; if (!plugin_loader_replay_pending (loader)) break; put_packet (loader, PACKET_EXIT, 0, NULL, 0); } plugin_loader_cleanup_child (loader); } else { close (loader->fd_w.fd); close (loader->fd_r.fd); } gst_poll_free (loader->fdset); g_free (loader->rx_buf); g_free (loader->tx_buf); if (loader->registry) gst_object_unref (loader->registry); got_plugin_details = loader->got_plugin_details; /* Free any pending plugin entries */ cur = loader->pending_plugins; while (cur) { PendingPluginEntry *entry = (PendingPluginEntry *) (cur->data); g_free (entry->filename); g_slice_free (PendingPluginEntry, entry); cur = g_list_delete_link (cur, cur); } g_slice_free (GstPluginLoader, loader); return got_plugin_details; }
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; }
static gboolean gst_shm_src_stop (GstBaseSrc * bsrc) { GstShmSrc *self = GST_SHM_SRC (bsrc); GST_DEBUG_OBJECT (self, "Stopping %p", self); if (self->pipe) { gst_shm_pipe_dec (self->pipe); self->pipe = NULL; } gst_poll_free (self->poll); self->poll = NULL; return TRUE; }
gint main (gint argc, gchar * argv[]) { GThread *threads[MAX_THREADS]; gint num_threads; gint t; gst_init (&argc, &argv); fdlock = g_mutex_new (); timer = g_timer_new (); if (argc != 2) { g_print ("usage: %s <num_threads>\n", argv[0]); exit (-1); } num_threads = atoi (argv[1]); set = gst_poll_new (TRUE); for (t = 0; t < num_threads; t++) { GError *error = NULL; #if !GLIB_CHECK_VERSION (2, 31, 0) threads[t] = g_thread_create (run_test, GINT_TO_POINTER (t), TRUE, &error); #else threads[t] = g_thread_try_new ("pollstresstest", run_test, GINT_TO_POINTER (t), &error); #endif if (error) { printf ("ERROR: g_thread_create() %s\n", error->message); exit (-1); } } printf ("main(): Created %d threads.\n", t); for (t = 0; t < num_threads; t++) { g_thread_join (threads[t]); } gst_poll_free (set); return 0; }
static void gst_shout2send_finalize (GstShout2send * shout2send) { g_free (shout2send->ip); g_free (shout2send->password); g_free (shout2send->username); g_free (shout2send->streamname); g_free (shout2send->description); g_free (shout2send->genre); g_free (shout2send->mount); g_free (shout2send->url); gst_tag_list_unref (shout2send->tags); gst_poll_free (shout2send->timer); G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (shout2send)); }
static void gst_buffer_pool_finalize (GObject * object) { GstBufferPool *pool; GstBufferPoolPrivate *priv; pool = GST_BUFFER_POOL_CAST (object); priv = pool->priv; GST_DEBUG_OBJECT (pool, "finalize"); gst_buffer_pool_set_active (pool, FALSE); gst_atomic_queue_unref (priv->queue); gst_poll_free (priv->poll); gst_structure_free (priv->config); g_rec_mutex_clear (&priv->rec_lock); if (priv->allocator) gst_object_unref (priv->allocator); G_OBJECT_CLASS (gst_buffer_pool_parent_class)->finalize (object); }
static void gst_v4l2_buffer_pool_finalize (GObject * object) { GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (object); if (pool->video_fd >= 0) v4l2_close (pool->video_fd); gst_poll_free (pool->poll); /* FIXME Is this required to keep around ? * This can't be done in dispose method because we must not set pointer * to NULL as it is part of the v4l2object and dispose could be called * multiple times */ gst_object_unref (pool->obj->element); g_cond_clear (&pool->empty_cond); /* FIXME have we done enough here ? */ G_OBJECT_CLASS (parent_class)->finalize (object); }
static void gst_wl_display_finalize (GObject * gobject) { GstWlDisplay *self = GST_WL_DISPLAY (gobject); gst_poll_set_flushing (self->wl_fd_poll, TRUE); if (self->thread) g_thread_join (self->thread); g_array_unref (self->formats); gst_poll_free (self->wl_fd_poll); if (self->shm) wl_shm_destroy (self->shm); if (self->shell) wl_shell_destroy (self->shell); if (self->compositor) wl_compositor_destroy (self->compositor); if (self->subcompositor) wl_subcompositor_destroy (self->subcompositor); if (self->registry) wl_registry_destroy (self->registry); if (self->queue) wl_event_queue_destroy (self->queue); if (self->own_display) { wl_display_flush (self->display); wl_display_disconnect (self->display); } G_OBJECT_CLASS (gst_wl_display_parent_class)->finalize (gobject); }
static void dvb_base_bin_dispose (GObject * object) { DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (object); if (!dvbbasebin->disposed) { /* remove mpegtsparse BEFORE dvbsrc, since the mpegtsparse::pad-removed * signal handler uses dvbsrc */ dvb_base_bin_reset (dvbbasebin); if (dvbbasebin->tsparse != NULL) gst_bin_remove (GST_BIN (dvbbasebin), dvbbasebin->tsparse); gst_bin_remove (GST_BIN (dvbbasebin), dvbbasebin->dvbsrc); gst_bin_remove (GST_BIN (dvbbasebin), dvbbasebin->buffer_queue); g_free (dvbbasebin->program_numbers); gst_poll_free (dvbbasebin->poll); gst_object_unref (dvbbasebin->task); g_rec_mutex_clear (&dvbbasebin->lock); dvbbasebin->disposed = TRUE; } if (G_OBJECT_CLASS (parent_class)->dispose) G_OBJECT_CLASS (parent_class)->dispose (object); }
static void fs_msn_connection_finalize (GObject *object) { FsMsnConnection *self = FS_MSN_CONNECTION (object); gint i; g_free (self->local_recipient_id); g_free (self->remote_recipient_id); gst_poll_free (self->poll); for (i = 0; i < self->pollfds->len; i++) { FsMsnPollFD *p = g_ptr_array_index(self->pollfds, i); close (p->pollfd.fd); g_slice_free (FsMsnPollFD, p); } g_ptr_array_free (self->pollfds, TRUE); g_rec_mutex_clear (&self->mutex); G_OBJECT_CLASS (fs_msn_connection_parent_class)->finalize (object); }
static void gst_mfx_window_wayland_destroy (GstMfxWindow * window) { GstMfxWindowWaylandPrivate *const priv = GST_MFX_WINDOW_WAYLAND_GET_PRIVATE (window); struct wl_display *const display = GST_MFX_DISPLAY_HANDLE (GST_MFX_WINDOW_DISPLAY (window)); /* Make sure that the last wl_buffer's callback could be called */ GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window)); if (priv->surface) { wl_surface_attach (priv->surface, NULL, 0, 0); wl_surface_commit (priv->surface); wl_display_flush (display); } GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window)); gst_poll_set_flushing (priv->poll, TRUE); if (priv->event_queue) { wl_display_roundtrip_queue (display, priv->event_queue); } if (priv->thread) { g_thread_join (priv->thread); priv->thread = NULL; } #ifdef USE_WESTON_4_0 if (priv->wp_viewport) { wp_viewport_destroy (priv->wp_viewport); priv->wp_viewport = NULL; } #else if (priv->viewport) { wl_viewport_destroy (priv->viewport); priv->viewport = NULL; } #endif if (priv->shell_surface) { wl_shell_surface_destroy (priv->shell_surface); priv->shell_surface = NULL; } if (priv->surface) { wl_surface_destroy (priv->surface); priv->surface = NULL; } if (priv->event_queue) { wl_event_queue_destroy (priv->event_queue); priv->event_queue = NULL; } #ifdef USE_EGL if (priv->egl_window) { wl_egl_window_destroy (priv->egl_window); priv->egl_window = NULL; } #endif gst_poll_free (priv->poll); }