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");
}
}
