static gboolean
gst_curl_base_sink_start (GstBaseSink * bsink)
{
GstCurlBaseSink *sink;
sink = GST_CURL_BASE_SINK (bsink);
/* reset flags */
sink->transfer_cond->data_sent = FALSE;
sink->transfer_cond->data_available = FALSE;
sink->transfer_cond->wait_for_response = FALSE;
sink->transfer_thread_close = FALSE;
sink->new_file = TRUE;
sink->flow_ret = GST_FLOW_OK;
if ((sink->fdset = gst_poll_new (TRUE)) == NULL) {
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_READ_WRITE,
("gst_poll_new failed: %s", g_strerror (errno)), (NULL));
return FALSE;
}
gst_poll_fd_init (&sink->fd);
return TRUE;
}
static FsMsnPollFD *
add_pollfd_locked (FsMsnConnection *self, int fd, PollFdCallback callback,
gboolean read, gboolean write, gboolean server)
{
FsMsnPollFD *pollfd = g_slice_new0 (FsMsnPollFD);
gst_poll_fd_init (&pollfd->pollfd);
pollfd->pollfd.fd = fd;
pollfd->server = server;
pollfd->want_read = read;
pollfd->want_write = write;
pollfd->status = FS_MSN_STATUS_AUTH;
gst_poll_add_fd (self->poll, &pollfd->pollfd);
gst_poll_fd_ctl_read (self->poll, &pollfd->pollfd, read);
gst_poll_fd_ctl_write (self->poll, &pollfd->pollfd, write);
pollfd->callback = callback;
GST_DEBUG ("ADD_POLLFD %p (%p) - error %d, close %d, read %d-%d, write %d-%d",
self->pollfds, pollfd,
gst_poll_fd_has_error (self->poll, &pollfd->pollfd),
gst_poll_fd_has_closed (self->poll, &pollfd->pollfd),
pollfd->want_read,
gst_poll_fd_can_read (self->poll, &pollfd->pollfd),
pollfd->want_write,
gst_poll_fd_can_write (self->poll, &pollfd->pollfd));
g_ptr_array_add (self->pollfds, pollfd);
gst_poll_restart (self->poll);
return pollfd;
}
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 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;
}
static void
gst_kms_sink_init (GstKMSSink * sink)
{
sink->fd = -1;
sink->conn_id = -1;
sink->plane_id = -1;
gst_poll_fd_init (&sink->pollfd);
sink->poll = gst_poll_new (TRUE);
gst_video_info_init (&sink->vinfo);
}
static GstPluginLoader *
plugin_loader_new (GstRegistry * registry)
{
GstPluginLoader *l = g_slice_new0 (GstPluginLoader);
if (registry)
l->registry = gst_object_ref (registry);
l->fdset = gst_poll_new (FALSE);
gst_poll_fd_init (&l->fd_w);
gst_poll_fd_init (&l->fd_r);
l->tx_buf_size = BUF_INIT_SIZE;
l->tx_buf = g_malloc (BUF_INIT_SIZE);
l->next_tag = 0;
l->rx_buf_size = BUF_INIT_SIZE;
l->rx_buf = g_malloc (BUF_INIT_SIZE);
return l;
}
static gboolean
gst_vaapi_window_wayland_create (GstVaapiWindow * window,
guint * width, guint * height)
{
GstVaapiWindowWaylandPrivate *const priv =
GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window);
GstVaapiDisplayWaylandPrivate *const priv_display =
GST_VAAPI_DISPLAY_WAYLAND_GET_PRIVATE (GST_VAAPI_OBJECT_DISPLAY (window));
GST_DEBUG ("create window, size %ux%u", *width, *height);
g_return_val_if_fail (priv_display->compositor != NULL, FALSE);
g_return_val_if_fail (priv_display->shell != NULL, FALSE);
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
priv->event_queue = wl_display_create_queue (priv_display->wl_display);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!priv->event_queue)
return FALSE;
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
priv->surface = wl_compositor_create_surface (priv_display->compositor);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!priv->surface)
return FALSE;
wl_proxy_set_queue ((struct wl_proxy *) priv->surface, priv->event_queue);
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
priv->shell_surface =
wl_shell_get_shell_surface (priv_display->shell, priv->surface);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!priv->shell_surface)
return FALSE;
wl_proxy_set_queue ((struct wl_proxy *) priv->shell_surface,
priv->event_queue);
wl_shell_surface_add_listener (priv->shell_surface,
&shell_surface_listener, priv);
wl_shell_surface_set_toplevel (priv->shell_surface);
priv->poll = gst_poll_new (TRUE);
gst_poll_fd_init (&priv->pollfd);
if (priv->fullscreen_on_show)
gst_vaapi_window_wayland_set_fullscreen (window, TRUE);
priv->surface_format = GST_VIDEO_FORMAT_ENCODED;
priv->use_vpp = GST_VAAPI_DISPLAY_HAS_VPP (GST_VAAPI_OBJECT_DISPLAY (window));
priv->is_shown = TRUE;
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_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 gboolean
gst_dvbsrc_start (GstBaseSrc * bsrc)
{
GstDvbSrc *src = GST_DVBSRC (bsrc);
gst_dvbsrc_open_frontend (src, TRUE);
if (!gst_dvbsrc_tune (src)) {
GST_ERROR_OBJECT (src, "Not able to lock on to the dvb channel");
close (src->fd_frontend);
return FALSE;
}
if (!gst_dvbsrc_frontend_status (src)) {
/* unset filters also */
gst_dvbsrc_unset_pes_filters (src);
close (src->fd_frontend);
return FALSE;
}
if (!gst_dvbsrc_open_dvr (src)) {
GST_ERROR_OBJECT (src, "Not able to open dvr_device");
/* unset filters also */
gst_dvbsrc_unset_pes_filters (src);
close (src->fd_frontend);
return FALSE;
}
if (!(src->poll = gst_poll_new (TRUE))) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL),
("could not create an fdset: %s (%d)", g_strerror (errno), errno));
/* unset filters also */
gst_dvbsrc_unset_pes_filters (src);
close (src->fd_frontend);
return FALSE;
} else {
gst_poll_fd_init (&src->poll_fd_dvr);
src->poll_fd_dvr.fd = src->fd_dvr;
gst_poll_add_fd (src->poll, &src->poll_fd_dvr);
gst_poll_fd_ctl_read (src->poll, &src->poll_fd_dvr, TRUE);
}
return TRUE;
}
static gboolean
gst_kms_sink_stop (GstBaseSink * bsink)
{
GstKMSSink *self;
self = GST_KMS_SINK (bsink);
gst_buffer_replace (&self->last_buffer, NULL);
gst_caps_replace (&self->allowed_caps, NULL);
gst_object_replace ((GstObject **) & self->pool, NULL);
gst_object_replace ((GstObject **) & self->allocator, NULL);
gst_poll_remove_fd (self->poll, &self->pollfd);
gst_poll_restart (self->poll);
gst_poll_fd_init (&self->pollfd);
if (self->fd >= 0) {
drmClose (self->fd);
self->fd = -1;
}
return TRUE;
}
/* This function gets called by libcurl after the socket() call but before
* the connect() call. */
static int
gst_curl_base_sink_transfer_socket_cb (void *clientp, curl_socket_t curlfd,
curlsocktype G_GNUC_UNUSED purpose)
{
GstCurlBaseSink *sink;
gboolean ret = TRUE;
sink = (GstCurlBaseSink *) clientp;
g_assert (sink);
if (curlfd < 0) {
/* signal an unrecoverable error to the library which will close the socket
and return CURLE_COULDNT_CONNECT
*/
return 1;
}
gst_poll_fd_init (&sink->fd);
sink->fd.fd = curlfd;
ret = ret && gst_poll_add_fd (sink->fdset, &sink->fd);
ret = ret && gst_poll_fd_ctl_write (sink->fdset, &sink->fd, TRUE);
ret = ret && gst_poll_fd_ctl_read (sink->fdset, &sink->fd, TRUE);
GST_DEBUG ("fd: %d", sink->fd.fd);
GST_OBJECT_LOCK (sink);
gst_curl_base_sink_setup_dscp_unlocked (sink);
GST_OBJECT_UNLOCK (sink);
/* success */
if (ret) {
return 0;
} else {
return 1;
}
}
static gboolean
gst_mfx_window_wayland_create (GstMfxWindow * window,
guint * width, guint * height)
{
GstMfxWindowWaylandPrivate *const priv =
GST_MFX_WINDOW_WAYLAND_GET_PRIVATE (window);
GstMfxDisplayWaylandPrivate *const priv_display =
GST_MFX_DISPLAY_WAYLAND_GET_PRIVATE (GST_MFX_WINDOW_DISPLAY (window));
struct wl_display *const wl_display =
GST_MFX_DISPLAY_HANDLE (GST_MFX_WINDOW_DISPLAY (window));
GError *err = NULL;
GST_DEBUG ("create window, size %ux%u", *width, *height);
g_return_val_if_fail (priv_display->compositor != NULL, FALSE);
g_return_val_if_fail (priv_display->shell != NULL, FALSE);
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
priv->event_queue = wl_display_create_queue (wl_display);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
if (!priv->event_queue)
return FALSE;
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
priv->surface = wl_compositor_create_surface (priv_display->compositor);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
if (!priv->surface)
return FALSE;
wl_proxy_set_queue ((struct wl_proxy *) priv->surface, priv->event_queue);
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
priv->shell_surface =
wl_shell_get_shell_surface (priv_display->shell, priv->surface);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
if (!priv->shell_surface)
return FALSE;
wl_proxy_set_queue ((struct wl_proxy *) priv->shell_surface,
priv->event_queue);
wl_shell_surface_add_listener (priv->shell_surface,
&shell_surface_listener, window);
wl_shell_surface_set_toplevel (priv->shell_surface);
#ifdef USE_WESTON_4_0
if (priv_display->viewporter) {
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
priv->wp_viewport =
wp_viewporter_get_viewport (priv_display->viewporter, priv->surface);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
}
#else
if (priv_display->scaler) {
GST_MFX_DISPLAY_LOCK (GST_MFX_WINDOW_DISPLAY (window));
priv->viewport =
wl_scaler_get_viewport (priv_display->scaler, priv->surface);
GST_MFX_DISPLAY_UNLOCK (GST_MFX_WINDOW_DISPLAY (window));
}
#endif
priv->poll = gst_poll_new (TRUE);
gst_poll_fd_init (&priv->pollfd);
if (priv->fullscreen_on_show)
gst_mfx_window_wayland_set_fullscreen (window, TRUE);
#ifdef USE_EGL
if (gst_mfx_display_has_opengl (GST_MFX_WINDOW_DISPLAY (window))) {
priv->egl_window = wl_egl_window_create (priv->surface, *width, *height);
if (!priv->egl_window)
return FALSE;
GST_MFX_WINDOW_ID (window) = GPOINTER_TO_INT(priv->egl_window);
}
#endif
priv->thread = g_thread_try_new ("wayland-thread",
gst_mfx_window_wayland_thread_run,
window,
&err);
if (err)
return FALSE;
priv->is_shown = TRUE;
return TRUE;
}
static gpointer
pollthread_func (gpointer data)
{
GstShmSink *self = GST_SHM_SINK (data);
GList *item;
GstClockTime timeout = GST_CLOCK_TIME_NONE;
int rv = 0;
while (!self->stop) {
do {
rv = gst_poll_wait (self->poll, timeout);
} while (rv < 0 && errno == EINTR);
if (rv < 0) {
GST_ELEMENT_ERROR (self, RESOURCE, READ,
("Failed waiting on fd activity"),
("gst_poll_wait returned %d, errno: %d", rv, errno));
return NULL;
}
timeout = GST_CLOCK_TIME_NONE;
if (self->stop)
return NULL;
if (gst_poll_fd_has_closed (self->poll, &self->serverpollfd)) {
GST_ELEMENT_ERROR (self, RESOURCE, READ, ("Failed read from shmsink"),
("Control socket has closed"));
return NULL;
}
if (gst_poll_fd_has_error (self->poll, &self->serverpollfd)) {
GST_ELEMENT_ERROR (self, RESOURCE, READ, ("Failed to read from shmsink"),
("Control socket has error"));
return NULL;
}
if (gst_poll_fd_can_read (self->poll, &self->serverpollfd)) {
ShmClient *client;
struct GstShmClient *gclient;
GST_OBJECT_LOCK (self);
client = sp_writer_accept_client (self->pipe);
GST_OBJECT_UNLOCK (self);
if (!client) {
GST_ELEMENT_ERROR (self, RESOURCE, READ,
("Failed to read from shmsink"),
("Control socket returns wrong data"));
return NULL;
}
gclient = g_slice_new (struct GstShmClient);
gclient->client = client;
gst_poll_fd_init (&gclient->pollfd);
gclient->pollfd.fd = sp_writer_get_client_fd (client);
gst_poll_add_fd (self->poll, &gclient->pollfd);
gst_poll_fd_ctl_read (self->poll, &gclient->pollfd, TRUE);
self->clients = g_list_prepend (self->clients, gclient);
g_signal_emit (self, signals[SIGNAL_CLIENT_CONNECTED], 0,
gclient->pollfd.fd);
/* we need to call gst_poll_wait before calling gst_poll_* status
functions on that new descriptor, so restart the loop, so _wait
will have been called on all elements of self->poll, whether
they have just been added or not. */
timeout = 0;
continue;
}
again:
for (item = self->clients; item; item = item->next) {
struct GstShmClient *gclient = item->data;
if (gst_poll_fd_has_closed (self->poll, &gclient->pollfd)) {
GST_WARNING_OBJECT (self, "One client is gone, closing");
goto close_client;
}
if (gst_poll_fd_has_error (self->poll, &gclient->pollfd)) {
GST_WARNING_OBJECT (self, "One client fd has error, closing");
goto close_client;
}
if (gst_poll_fd_can_read (self->poll, &gclient->pollfd)) {
int rv;
gpointer tag = NULL;
GST_OBJECT_LOCK (self);
rv = sp_writer_recv (self->pipe, gclient->client, &tag);
GST_OBJECT_UNLOCK (self);
if (rv < 0) {
GST_WARNING_OBJECT (self, "One client has read error,"
" closing (retval: %d errno: %d)", rv, errno);
goto close_client;
}
g_assert (rv == 0 || tag == NULL);
if (rv == 0)
gst_buffer_unref (tag);
}
continue;
close_client:
{
GSList *list = NULL;
GST_OBJECT_LOCK (self);
sp_writer_close_client (self->pipe, gclient->client,
(sp_buffer_free_callback) free_buffer_locked, (void **) &list);
GST_OBJECT_UNLOCK (self);
g_slist_free_full (list, (GDestroyNotify) gst_buffer_unref);
}
gst_poll_remove_fd (self->poll, &gclient->pollfd);
self->clients = g_list_remove (self->clients, gclient);
g_signal_emit (self, signals[SIGNAL_CLIENT_DISCONNECTED], 0,
gclient->pollfd.fd);
g_slice_free (struct GstShmClient, gclient);
goto again;
}
g_cond_broadcast (&self->cond);
}
/**
* gst_v4l2_buffer_pool_new:
* @obj: the v4l2 object owning the pool
*
* Construct a new buffer pool.
*
* Returns: the new pool, use gst_object_unref() to free resources
*/
GstBufferPool *
gst_v4l2_buffer_pool_new (GstV4l2Object * obj, GstCaps * caps)
{
GstV4l2BufferPool *pool;
GstStructure *config;
gchar *name, *parent_name;
gint fd;
fd = v4l2_dup (obj->video_fd);
if (fd < 0)
goto dup_failed;
/* setting a significant unique name */
parent_name = gst_object_get_name (GST_OBJECT (obj->element));
name = g_strconcat (parent_name, ":", "pool:",
V4L2_TYPE_IS_OUTPUT (obj->type) ? "sink" : "src", NULL);
g_free (parent_name);
pool = (GstV4l2BufferPool *) g_object_new (GST_TYPE_V4L2_BUFFER_POOL,
"name", name, NULL);
g_free (name);
gst_poll_fd_init (&pool->pollfd);
pool->pollfd.fd = fd;
gst_poll_add_fd (pool->poll, &pool->pollfd);
if (V4L2_TYPE_IS_OUTPUT (obj->type))
gst_poll_fd_ctl_write (pool->poll, &pool->pollfd, TRUE);
else
gst_poll_fd_ctl_read (pool->poll, &pool->pollfd, TRUE);
pool->video_fd = fd;
pool->obj = obj;
pool->can_poll_device = TRUE;
pool->vallocator =
gst_v4l2_allocator_new (GST_OBJECT (pool), obj->video_fd, &obj->format);
if (pool->vallocator == NULL)
goto allocator_failed;
gst_object_ref (obj->element);
config = gst_buffer_pool_get_config (GST_BUFFER_POOL_CAST (pool));
gst_buffer_pool_config_set_params (config, caps, obj->info.size, 0, 0);
/* This will simply set a default config, but will not configure the pool
* because min and max are not valid */
gst_buffer_pool_set_config (GST_BUFFER_POOL_CAST (pool), config);
return GST_BUFFER_POOL (pool);
/* ERRORS */
dup_failed:
{
GST_ERROR ("failed to dup fd %d (%s)", errno, g_strerror (errno));
return NULL;
}
allocator_failed:
{
GST_ERROR_OBJECT (pool, "Failed to create V4L2 allocator");
return NULL;
}
}
static gpointer
pollthread_func (gpointer data)
{
GstShmSink *self = GST_SHM_SINK (data);
GList *item;
while (!self->stop) {
if (gst_poll_wait (self->poll, GST_CLOCK_TIME_NONE) < 0)
return NULL;
if (self->stop)
return NULL;
if (gst_poll_fd_has_closed (self->poll, &self->serverpollfd)) {
GST_ELEMENT_ERROR (self, RESOURCE, READ, ("Failed read from shmsink"),
("Control socket has closed"));
return NULL;
}
if (gst_poll_fd_has_error (self->poll, &self->serverpollfd)) {
GST_ELEMENT_ERROR (self, RESOURCE, READ, ("Failed to read from shmsink"),
("Control socket has error"));
return NULL;
}
if (gst_poll_fd_can_read (self->poll, &self->serverpollfd)) {
ShmClient *client;
struct GstShmClient *gclient;
GST_OBJECT_LOCK (self);
client = sp_writer_accept_client (self->pipe);
GST_OBJECT_UNLOCK (self);
if (!client) {
GST_ELEMENT_ERROR (self, RESOURCE, READ,
("Failed to read from shmsink"),
("Control socket returns wrong data"));
return NULL;
}
gclient = g_slice_new (struct GstShmClient);
gclient->client = client;
gst_poll_fd_init (&gclient->pollfd);
gclient->pollfd.fd = sp_writer_get_client_fd (client);
gst_poll_add_fd (self->poll, &gclient->pollfd);
gst_poll_fd_ctl_read (self->poll, &gclient->pollfd, TRUE);
self->clients = g_list_prepend (self->clients, gclient);
g_signal_emit (self, signals[SIGNAL_CLIENT_CONNECTED], 0,
gclient->pollfd.fd);
}
again:
for (item = self->clients; item; item = item->next) {
struct GstShmClient *gclient = item->data;
if (gst_poll_fd_has_closed (self->poll, &gclient->pollfd)) {
GST_WARNING_OBJECT (self, "One client is gone, closing");
goto close_client;
}
if (gst_poll_fd_has_error (self->poll, &gclient->pollfd)) {
GST_WARNING_OBJECT (self, "One client fd has error, closing");
goto close_client;
}
if (gst_poll_fd_can_read (self->poll, &gclient->pollfd)) {
int rv;
GST_OBJECT_LOCK (self);
rv = sp_writer_recv (self->pipe, gclient->client);
GST_OBJECT_UNLOCK (self);
if (rv < 0) {
GST_WARNING_OBJECT (self, "One client has read error,"
" closing (retval: %d errno: %d)", rv, errno);
goto close_client;
}
}
continue;
close_client:
GST_OBJECT_LOCK (self);
sp_writer_close_client (self->pipe, gclient->client);
GST_OBJECT_UNLOCK (self);
gst_poll_remove_fd (self->poll, &gclient->pollfd);
self->clients = g_list_remove (self->clients, gclient);
g_signal_emit (self, signals[SIGNAL_CLIENT_DISCONNECTED], 0,
gclient->pollfd.fd);
g_slice_free (struct GstShmClient, gclient);
goto again;
}
g_cond_broadcast (self->cond);
}
static void
gst_shm_src_init (GstShmSrc * self, GstShmSrcClass * g_class)
{
self->poll = gst_poll_new (TRUE);
gst_poll_fd_init (&self->pollfd);
}
