static gboolean gst_v4l2_buffer_pool_start (GstBufferPool * bpool) { GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); GstV4l2Object *obj = pool->obj; pool->obj = obj; pool->buffers = g_new0 (GstBuffer *, pool->num_buffers); pool->num_allocated = 0; /* now, allocate the buffers: */ if (!GST_BUFFER_POOL_CLASS (parent_class)->start (bpool)) goto start_failed; /* we can start capturing now, we wait for the playback case until we queued * the first buffer */ if (obj->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) if (!start_streaming (pool)) goto start_failed; gst_poll_set_flushing (obj->poll, FALSE); return TRUE; /* ERRORS */ start_failed: { GST_ERROR_OBJECT (pool, "failed to start streaming"); return FALSE; } }
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 gboolean gst_dvbsrc_unlock_stop (GstBaseSrc * bsrc) { GstDvbSrc *src = GST_DVBSRC (bsrc); gst_poll_set_flushing (src->poll, FALSE); return TRUE; }
static gboolean gst_avdtp_src_start (GstBaseSrc * bsrc) { GstAvdtpSrc *avdtpsrc = GST_AVDTP_SRC (bsrc); /* None of this can go into prepare() since we need to set up the * connection to figure out what format the device is going to send us. */ if (!gst_avdtp_connection_acquire (&avdtpsrc->conn, FALSE)) { GST_ERROR_OBJECT (avdtpsrc, "Failed to acquire connection"); return FALSE; } if (!gst_avdtp_connection_get_properties (&avdtpsrc->conn)) { GST_ERROR_OBJECT (avdtpsrc, "Failed to get transport properties"); goto fail; } if (!gst_avdtp_connection_conf_recv_stream_fd (&avdtpsrc->conn)) { GST_ERROR_OBJECT (avdtpsrc, "Failed to configure stream fd"); goto fail; } GST_DEBUG_OBJECT (avdtpsrc, "Setting block size to link MTU (%d)", avdtpsrc->conn.data.link_mtu); gst_base_src_set_blocksize (GST_BASE_SRC (avdtpsrc), avdtpsrc->conn.data.link_mtu); avdtpsrc->dev_caps = gst_avdtp_connection_get_caps (&avdtpsrc->conn); if (!avdtpsrc->dev_caps) { GST_ERROR_OBJECT (avdtpsrc, "Failed to get device caps"); goto fail; } gst_poll_fd_init (&avdtpsrc->pfd); avdtpsrc->pfd.fd = g_io_channel_unix_get_fd (avdtpsrc->conn.stream); gst_poll_add_fd (avdtpsrc->poll, &avdtpsrc->pfd); gst_poll_fd_ctl_read (avdtpsrc->poll, &avdtpsrc->pfd, TRUE); gst_poll_set_flushing (avdtpsrc->poll, FALSE); g_atomic_int_set (&avdtpsrc->unlocked, FALSE); /* The life time of the connection is shorter than the src object, so we * don't need to worry about memory management */ gst_avdtp_connection_notify_volume (&avdtpsrc->conn, G_OBJECT (avdtpsrc), "transport-volume"); gst_avdtp_src_start_avrcp (avdtpsrc); return TRUE; fail: gst_avdtp_connection_release (&avdtpsrc->conn); return FALSE; }
/* will be called only between calls to start() and stop() */ static gboolean gst_tcp_server_src_unlock (GstBaseSrc * bsrc) { GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); gst_poll_set_flushing (src->fdset, TRUE); return TRUE; }
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 gboolean gst_vaapi_window_wayland_unblock_cancel (GstVaapiWindow * window) { GstVaapiWindowWaylandPrivate *const priv = GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window); gst_poll_set_flushing (priv->poll, FALSE); return TRUE; }
static gboolean gst_shm_src_unlock_stop (GstBaseSrc * bsrc) { GstShmSrc *self = GST_SHM_SRC (bsrc); self->unlocked = FALSE; gst_poll_set_flushing (self->poll, FALSE); return TRUE; }
static GstStateChangeReturn dvb_base_bin_change_state (GstElement * element, GstStateChange transition) { DvbBaseBin *dvbbasebin; GstStateChangeReturn ret; dvbbasebin = GST_DVB_BASE_BIN (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: if (dvbbasebin->tsparse == NULL) { GST_ELEMENT_ERROR (dvbbasebin, CORE, MISSING_PLUGIN, (NULL), ("No 'tsparse' element, check your GStreamer installation.")); return GST_STATE_CHANGE_FAILURE; } break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: gst_poll_set_flushing (dvbbasebin->poll, FALSE); g_rec_mutex_lock (&dvbbasebin->lock); gst_task_start (dvbbasebin->task); g_rec_mutex_unlock (&dvbbasebin->lock); break; case GST_STATE_CHANGE_PAUSED_TO_READY: gst_poll_set_flushing (dvbbasebin->poll, TRUE); g_rec_mutex_lock (&dvbbasebin->lock); gst_task_stop (dvbbasebin->task); g_rec_mutex_unlock (&dvbbasebin->lock); dvb_base_bin_reset (dvbbasebin); break; default: break; } return ret; }
static gboolean gst_avdtp_src_unlock (GstBaseSrc * bsrc) { GstAvdtpSrc *avdtpsrc = GST_AVDTP_SRC (bsrc); g_atomic_int_set (&avdtpsrc->unlocked, TRUE); gst_poll_set_flushing (avdtpsrc->poll, TRUE); return TRUE; }
static gboolean gst_curl_base_sink_unlock_stop (GstBaseSink * bsink) { GstCurlBaseSink *sink; sink = GST_CURL_BASE_SINK (bsink); GST_LOG_OBJECT (sink, "No longer flushing"); gst_poll_set_flushing (sink->fdset, FALSE); return TRUE; }
static gboolean gst_shout2send_unlock_stop (GstBaseSink * basesink) { GstShout2send *sink; sink = GST_SHOUT2SEND (basesink); GST_DEBUG_OBJECT (basesink, "unlock_stop"); gst_poll_set_flushing (sink->timer, FALSE); return TRUE; }
static gpointer delayed_flush (gpointer data) { GstPoll *set = data; THREAD_START (); g_usleep (500000); gst_poll_set_flushing (set, TRUE); return NULL; }
static gboolean gst_shm_src_unlock (GstBaseSrc * bsrc) { GstShmSrc *self = GST_SHM_SRC (bsrc); self->unlocked = TRUE; if (self->poll) gst_poll_set_flushing (self->poll, TRUE); return TRUE; }
static gboolean gst_fd_sink_unlock_stop (GstBaseSink * basesink) { GstFdSink *fdsink = GST_FD_SINK (basesink); GST_LOG_OBJECT (fdsink, "No longer flushing"); GST_OBJECT_LOCK (fdsink); gst_poll_set_flushing (fdsink->fdset, FALSE); GST_OBJECT_UNLOCK (fdsink); return TRUE; }
static gboolean gst_fd_src_unlock_stop (GstBaseSrc * bsrc) { GstFdSrc *src = GST_FD_SRC (bsrc); GST_LOG_OBJECT (src, "No longer flushing"); GST_OBJECT_LOCK (src); gst_poll_set_flushing (src->fdset, FALSE); GST_OBJECT_UNLOCK (src); return TRUE; }
static void fs_msn_connection_init (FsMsnConnection *self) { /* member init */ self->poll_timeout = GST_CLOCK_TIME_NONE; self->poll = gst_poll_new (TRUE); gst_poll_set_flushing (self->poll, FALSE); self->pollfds = g_ptr_array_new (); g_rec_mutex_init (&self->mutex); }
static gboolean gst_v4l2_buffer_pool_stop (GstBufferPool * bpool) { gboolean ret; GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); GstV4l2Object *obj = pool->obj; guint n; GST_DEBUG_OBJECT (pool, "stopping pool"); gst_poll_set_flushing (obj->poll, TRUE); if (pool->streaming) { switch (obj->mode) { case GST_V4L2_IO_RW: break; case GST_V4L2_IO_MMAP: case GST_V4L2_IO_USERPTR: /* we actually need to sync on all queued buffers but not * on the non-queued ones */ GST_DEBUG_OBJECT (pool, "STREAMOFF"); if (v4l2_ioctl (pool->video_fd, VIDIOC_STREAMOFF, &obj->type) < 0) goto stop_failed; break; default: g_assert_not_reached (); break; } pool->streaming = FALSE; } /* first free the buffers in the queue */ ret = GST_BUFFER_POOL_CLASS (parent_class)->stop (bpool); /* then free the remaining buffers */ for (n = 0; n < pool->num_queued; n++) { gst_v4l2_buffer_pool_free_buffer (bpool, pool->buffers[n]); } pool->num_queued = 0; g_free (pool->buffers); pool->buffers = NULL; return ret; /* ERRORS */ stop_failed: { GST_ERROR_OBJECT (pool, "error with STREAMOFF %d (%s)", errno, g_strerror (errno)); return FALSE; } }
static gboolean gst_fd_sink_unlock (GstBaseSink * basesink) { GstFdSink *fdsink = GST_FD_SINK (basesink); GST_LOG_OBJECT (fdsink, "Flushing"); GST_OBJECT_LOCK (fdsink); fdsink->unlock = TRUE; gst_poll_set_flushing (fdsink->fdset, TRUE); GST_OBJECT_UNLOCK (fdsink); return TRUE; }
static void gst_net_client_clock_stop (GstNetClientClock * self) { gst_poll_set_flushing (self->priv->fdset, TRUE); g_thread_join (self->thread); self->thread = NULL; if (self->priv->sock.fd != -1) { gst_poll_remove_fd (self->priv->fdset, &self->priv->sock); close (self->priv->sock.fd); self->priv->sock.fd = -1; } }
static void gst_net_time_provider_stop (GstNetTimeProvider * self) { gst_poll_set_flushing (self->priv->fdset, TRUE); g_thread_join (self->thread); self->thread = NULL; if (self->priv->sock.fd != -1) { gst_poll_remove_fd (self->priv->fdset, &self->priv->sock); close (self->priv->sock.fd); self->priv->sock.fd = -1; } }
static gboolean gst_avdtp_src_unlock_stop (GstBaseSrc * bsrc) { GstAvdtpSrc *avdtpsrc = GST_AVDTP_SRC (bsrc); g_atomic_int_set (&avdtpsrc->unlocked, FALSE); gst_poll_set_flushing (avdtpsrc->poll, FALSE); /* Flush out any stale data that might be buffered */ gst_avdtp_connection_conf_recv_stream_fd (&avdtpsrc->conn); return TRUE; }
static void gst_shm_src_stop_reading (GstShmSrc * self) { GST_DEBUG_OBJECT (self, "Stopping %p", self); if (self->pipe) { gst_shm_pipe_dec (self->pipe); self->pipe = NULL; } gst_poll_remove_fd (self->poll, &self->pollfd); gst_poll_fd_init (&self->pollfd); gst_poll_set_flushing (self->poll, TRUE); }
static gboolean gst_avdtp_src_stop (GstBaseSrc * bsrc) { GstAvdtpSrc *avdtpsrc = GST_AVDTP_SRC (bsrc); gst_poll_remove_fd (avdtpsrc->poll, &avdtpsrc->pfd); gst_poll_set_flushing (avdtpsrc->poll, TRUE); gst_avdtp_connection_release (&avdtpsrc->conn); if (avdtpsrc->dev_caps) { gst_caps_unref (avdtpsrc->dev_caps); avdtpsrc->dev_caps = NULL; } return TRUE; }
static void gst_v4l2_buffer_pool_flush_start (GstBufferPool * bpool) { GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); GST_DEBUG_OBJECT (pool, "start flushing"); gst_poll_set_flushing (pool->poll, TRUE); GST_OBJECT_LOCK (pool); pool->empty = FALSE; g_cond_broadcast (&pool->empty_cond); GST_OBJECT_UNLOCK (pool); if (pool->other_pool) gst_buffer_pool_set_flushing (pool->other_pool, TRUE); }
static void fs_msn_connection_dispose (GObject *object) { FsMsnConnection *self = FS_MSN_CONNECTION (object); FS_MSN_CONNECTION_LOCK(self); if (self->polling_thread) { gst_poll_set_flushing (self->poll, TRUE); g_thread_join (self->polling_thread); self->polling_thread = NULL; } FS_MSN_CONNECTION_UNLOCK(self); G_OBJECT_CLASS (fs_msn_connection_parent_class)->dispose (object); }
static gboolean gst_shm_src_start_reading (GstShmSrc * self) { GstShmPipe *gstpipe; if (!self->socket_path) { GST_ELEMENT_ERROR (self, RESOURCE, NOT_FOUND, ("No path specified for socket."), (NULL)); return FALSE; } gstpipe = g_slice_new0 (GstShmPipe); gstpipe->use_count = 1; gstpipe->src = gst_object_ref (self); GST_DEBUG_OBJECT (self, "Opening socket %s", self->socket_path); GST_OBJECT_LOCK (self); gstpipe->pipe = sp_client_open (self->socket_path); GST_OBJECT_UNLOCK (self); if (!gstpipe->pipe) { GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ_WRITE, ("Could not open socket %s: %d %s", self->socket_path, errno, strerror (errno)), (NULL)); gst_shm_pipe_dec (gstpipe); return FALSE; } self->pipe = gstpipe; gst_poll_set_flushing (self->poll, FALSE); gst_poll_fd_init (&self->pollfd); self->pollfd.fd = sp_get_fd (self->pipe->pipe); gst_poll_add_fd (self->poll, &self->pollfd); gst_poll_fd_ctl_read (self->poll, &self->pollfd, TRUE); return TRUE; }
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 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); }
static void gst_v4l2_buffer_pool_flush_stop (GstBufferPool * bpool) { GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool); GstV4l2Object *obj = pool->obj; gint i; GST_DEBUG_OBJECT (pool, "stop flushing"); /* If we haven't started streaming yet, simply call streamon */ if (!pool->streaming) goto streamon; if (pool->other_pool) gst_buffer_pool_set_flushing (pool->other_pool, FALSE); if (!gst_v4l2_buffer_pool_streamoff (pool)) goto stop_failed; gst_v4l2_allocator_flush (pool->vallocator); /* Reset our state */ switch (obj->mode) { case GST_V4L2_IO_RW: break; case GST_V4L2_IO_MMAP: case GST_V4L2_IO_USERPTR: case GST_V4L2_IO_DMABUF: case GST_V4L2_IO_DMABUF_IMPORT: { gsize num_allocated; num_allocated = gst_v4l2_allocator_num_allocated (pool->vallocator); for (i = 0; i < num_allocated; i++) { /* Re-enqueue buffers */ if (pool->buffers[i]) { GstBufferPool *bpool = (GstBufferPool *) pool; GstBuffer *buffer = pool->buffers[i]; pool->buffers[i] = NULL; /* Remove qdata, this will unmap any map data in * userptr/dmabuf-import */ gst_mini_object_set_qdata (GST_MINI_OBJECT (buffer), GST_V4L2_IMPORT_QUARK, NULL, NULL); if (V4L2_TYPE_IS_OUTPUT (obj->type)) gst_buffer_unref (buffer); else gst_v4l2_buffer_pool_release_buffer (bpool, buffer); g_atomic_int_add (&pool->num_queued, -1); } } break; } default: g_assert_not_reached (); break; } streamon: /* Start streaming on capture device only */ if (!V4L2_TYPE_IS_OUTPUT (obj->type)) gst_v4l2_buffer_pool_streamon (pool); gst_poll_set_flushing (pool->poll, FALSE); return; /* ERRORS */ stop_failed: { GST_ERROR_OBJECT (pool, "device refused to flush"); } }