/** * gst_net_time_provider_new: * @clock: a #GstClock to export over the network * @address: an address to bind on as a dotted quad (xxx.xxx.xxx.xxx), or NULL * to bind to all addresses * @port: a port to bind on, or 0 to let the kernel choose * * Allows network clients to get the current time of @clock. * * Returns: the new #GstNetTimeProvider, or NULL on error */ GstNetTimeProvider * gst_net_time_provider_new (GstClock * clock, const gchar * address, gint port) { GstNetTimeProvider *ret; g_return_val_if_fail (clock && GST_IS_CLOCK (clock), NULL); g_return_val_if_fail (port >= 0 && port <= G_MAXUINT16, NULL); ret = g_object_new (GST_TYPE_NET_TIME_PROVIDER, "clock", clock, "address", address, "port", port, NULL); if ((ret->priv->fdset = gst_poll_new (TRUE)) == NULL) goto no_fdset; if (!gst_net_time_provider_start (ret)) goto failed_start; /* all systems go, cap'n */ return ret; no_fdset: { GST_ERROR_OBJECT (ret, "could not create an fdset: %s (%d)", g_strerror (errno), errno); gst_object_unref (ret); return NULL; } failed_start: { /* already printed a nice error */ gst_object_unref (ret); return NULL; } }
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 gboolean gst_fd_sink_start (GstBaseSink * basesink) { GstFdSink *fdsink; GstPollFD fd = GST_POLL_FD_INIT; fdsink = GST_FD_SINK (basesink); if (!gst_fd_sink_check_fd (fdsink, fdsink->fd, NULL)) return FALSE; if ((fdsink->fdset = gst_poll_new (TRUE)) == NULL) goto socket_pair; fd.fd = fdsink->fd; gst_poll_add_fd (fdsink->fdset, &fd); gst_poll_fd_ctl_write (fdsink->fdset, &fd, TRUE); fdsink->bytes_written = 0; fdsink->current_pos = 0; fdsink->seekable = gst_fd_sink_do_seek (fdsink, 0); GST_INFO_OBJECT (fdsink, "seeking supported: %d", fdsink->seekable); return TRUE; /* ERRORS */ socket_pair: { GST_ELEMENT_ERROR (fdsink, RESOURCE, OPEN_READ_WRITE, (NULL), GST_ERROR_SYSTEM); return FALSE; } }
static void gst_v4l2_buffer_pool_init (GstV4l2BufferPool * pool) { pool->poll = gst_poll_new (TRUE); pool->can_poll_device = TRUE; g_cond_init (&pool->empty_cond); pool->empty = TRUE; }
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_wl_display_init (GstWlDisplay * self) { self->shm_formats = g_array_new (FALSE, FALSE, sizeof (uint32_t)); self->dmabuf_formats = g_array_new (FALSE, FALSE, sizeof (uint32_t)); self->wl_fd_poll = gst_poll_new (TRUE); self->buffers = g_hash_table_new (g_direct_hash, g_direct_equal); g_mutex_init (&self->buffers_mutex); }
static void gst_avdtp_src_init (GstAvdtpSrc * avdtpsrc) { avdtpsrc->poll = gst_poll_new (TRUE); gst_base_src_set_format (GST_BASE_SRC (avdtpsrc), GST_FORMAT_TIME); gst_base_src_set_live (GST_BASE_SRC (avdtpsrc), TRUE); gst_base_src_set_do_timestamp (GST_BASE_SRC (avdtpsrc), TRUE); }
/** * gst_net_client_clock_new: * @name: a name for the clock * @remote_address: the address of the remote clock provider * @remote_port: the port of the remote clock provider * @base_time: initial time of the clock * * Create a new #GstNetClientClock that will report the time * provided by the #GstNetClockProvider on @remote_address and * @remote_port. * * Returns: a new #GstClock that receives a time from the remote * clock. */ GstClock * gst_net_client_clock_new (gchar * name, const gchar * remote_address, gint remote_port, GstClockTime base_time) { GstNetClientClock *ret; GstClockTime internal; g_return_val_if_fail (remote_address != NULL, NULL); g_return_val_if_fail (remote_port > 0, NULL); g_return_val_if_fail (remote_port <= G_MAXUINT16, NULL); g_return_val_if_fail (base_time != GST_CLOCK_TIME_NONE, NULL); ret = g_object_new (GST_TYPE_NET_CLIENT_CLOCK, "address", remote_address, "port", remote_port, NULL); /* gst_clock_get_time() values are guaranteed to be increasing. because no one * has called get_time on this clock yet we are free to adjust to any value * without worrying about worrying about MAX() issues with the clock's * internal time. */ /* update our internal time so get_time() give something around base_time. assume that the rate is 1 in the beginning. */ internal = gst_clock_get_internal_time (GST_CLOCK (ret)); gst_clock_set_calibration (GST_CLOCK (ret), internal, base_time, 1, 1); { GstClockTime now = gst_clock_get_time (GST_CLOCK (ret)); if (now < base_time || now > base_time + GST_SECOND) g_warning ("unable to set the base time, expect sync problems!"); } if ((ret->priv->fdset = gst_poll_new (TRUE)) == NULL) goto no_fdset; if (!gst_net_client_clock_start (ret)) goto failed_start; /* all systems go, cap'n */ return (GstClock *) ret; no_fdset: { GST_ERROR_OBJECT (ret, "could not create an fdset: %s (%d)", g_strerror (errno), errno); gst_object_unref (ret); return NULL; } failed_start: { /* already printed a nice error */ gst_object_unref (ret); return NULL; } }
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 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_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; }
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 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_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_shm_src_start (GstBaseSrc * bsrc) { GstShmSrc *self = GST_SHM_SRC (bsrc); GstShmPipe *gstpipe = g_slice_new0 (GstShmPipe); gstpipe->use_count = 1; gstpipe->src = gst_object_ref (self); if (!self->socket_path) { GST_ELEMENT_ERROR (bsrc, RESOURCE, NOT_FOUND, ("No path specified for socket."), (NULL)); return FALSE; } GST_DEBUG ("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 (bsrc, 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; self->poll = gst_poll_new (TRUE); 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_fd_src_start (GstBaseSrc * bsrc) { GstFdSrc *src = GST_FD_SRC (bsrc); src->curoffset = 0; if ((src->fdset = gst_poll_new (TRUE)) == NULL) goto socket_pair; gst_fd_src_update_fd (src); return TRUE; /* ERRORS */ socket_pair: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), GST_ERROR_SYSTEM); return FALSE; } }
/* set up server */ static gboolean gst_tcp_server_src_start (GstBaseSrc * bsrc) { int ret; GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); /* reset caps_received flag */ src->caps_received = FALSE; /* create the server listener socket */ if ((src->server_sock_fd.fd = socket (AF_INET, SOCK_STREAM, 0)) == -1) goto socket_error; GST_DEBUG_OBJECT (src, "opened receiving server socket with fd %d", src->server_sock_fd.fd); /* make address reusable */ ret = 1; if (setsockopt (src->server_sock_fd.fd, SOL_SOCKET, SO_REUSEADDR, &ret, sizeof (int)) < 0) goto sock_opt; /* name the socket */ memset (&src->server_sin, 0, sizeof (src->server_sin)); src->server_sin.sin_family = AF_INET; /* network socket */ src->server_sin.sin_port = htons (src->server_port); /* on port */ if (src->host) { gchar *host; if (!(host = gst_tcp_host_to_ip (GST_ELEMENT (src), src->host))) goto host_error; src->server_sin.sin_addr.s_addr = inet_addr (host); g_free (host); } else src->server_sin.sin_addr.s_addr = htonl (INADDR_ANY); /* bind it */ GST_DEBUG_OBJECT (src, "binding server socket to address"); if ((ret = bind (src->server_sock_fd.fd, (struct sockaddr *) &src->server_sin, sizeof (src->server_sin))) < 0) goto bind_error; GST_DEBUG_OBJECT (src, "listening on server socket %d with queue of %d", src->server_sock_fd.fd, TCP_BACKLOG); if (listen (src->server_sock_fd.fd, TCP_BACKLOG) == -1) goto listen_error; /* create an fdset to keep track of our file descriptors */ if ((src->fdset = gst_poll_new (TRUE)) == NULL) goto socket_pair; gst_poll_add_fd (src->fdset, &src->server_sock_fd); GST_DEBUG_OBJECT (src, "received client"); GST_OBJECT_FLAG_SET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; /* ERRORS */ socket_error: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), GST_ERROR_SYSTEM); return FALSE; } sock_opt: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("Could not setsockopt: %s", g_strerror (errno))); gst_tcp_socket_close (&src->server_sock_fd); return FALSE; } host_error: { gst_tcp_socket_close (&src->server_sock_fd); return FALSE; } bind_error: { gst_tcp_socket_close (&src->server_sock_fd); switch (errno) { default: GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("bind failed: %s", g_strerror (errno))); break; } return FALSE; } listen_error: { gst_tcp_socket_close (&src->server_sock_fd); GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Could not listen on server socket: %s", g_strerror (errno))); return FALSE; } socket_pair: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), GST_ERROR_SYSTEM); gst_tcp_socket_close (&src->server_sock_fd); return FALSE; } }
static void gst_wl_display_init (GstWlDisplay * self) { self->formats = g_array_new (FALSE, FALSE, sizeof (uint32_t)); self->wl_fd_poll = gst_poll_new (TRUE); }
static void gst_shm_src_init (GstShmSrc * self, GstShmSrcClass * g_class) { self->poll = gst_poll_new (TRUE); gst_poll_fd_init (&self->pollfd); }
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 void dvb_base_bin_init (DvbBaseBin * dvbbasebin) { DvbBaseBinStream *stream; GstPad *ghost, *pad; int i; dvbbasebin->dvbsrc = gst_element_factory_make ("dvbsrc", NULL); dvbbasebin->buffer_queue = gst_element_factory_make ("queue", NULL); dvbbasebin->tsparse = gst_element_factory_make ("tsparse", NULL); g_object_set (dvbbasebin->buffer_queue, "max-size-buffers", 0, "max-size-bytes", 0, "max-size-time", (guint64) 0, NULL); gst_bin_add_many (GST_BIN (dvbbasebin), dvbbasebin->dvbsrc, dvbbasebin->buffer_queue, dvbbasebin->tsparse, NULL); gst_element_link_many (dvbbasebin->dvbsrc, dvbbasebin->buffer_queue, dvbbasebin->tsparse, NULL); /* Proxy dvbsrc signals */ g_signal_connect (dvbbasebin->dvbsrc, "tuning-start", G_CALLBACK (tuning_start_signal_cb), dvbbasebin); g_signal_connect (dvbbasebin->dvbsrc, "tuning-done", G_CALLBACK (tuning_done_signal_cb), dvbbasebin); g_signal_connect (dvbbasebin->dvbsrc, "tuning-fail", G_CALLBACK (tuning_fail_signal_cb), dvbbasebin); /* Expose tsparse source pad */ if (dvbbasebin->tsparse != NULL) { pad = gst_element_get_static_pad (dvbbasebin->tsparse, "src"); ghost = gst_ghost_pad_new ("src", pad); gst_object_unref (pad); } else { ghost = gst_ghost_pad_new_no_target ("src", GST_PAD_SRC); } gst_element_add_pad (GST_ELEMENT (dvbbasebin), ghost); dvbbasebin->programs = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, dvb_base_bin_program_destroy); dvbbasebin->streams = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); dvbbasebin->pmtlist = NULL; dvbbasebin->pmtlist_changed = FALSE; dvbbasebin->disposed = FALSE; dvb_base_bin_reset (dvbbasebin); /* add PAT, CAT, NIT, SDT, EIT, TDT to pids filter for dvbsrc */ i = 0; while (initial_pids[i] >= 0) { stream = dvb_base_bin_add_stream (dvbbasebin, (guint16) initial_pids[i]); dvb_base_bin_ref_stream (stream); i++; } dvb_base_bin_rebuild_filter (dvbbasebin); g_rec_mutex_init (&dvbbasebin->lock); dvbbasebin->task = gst_task_new ((GstTaskFunction) dvb_base_bin_task, dvbbasebin, NULL); gst_task_set_lock (dvbbasebin->task, &dvbbasebin->lock); dvbbasebin->poll = gst_poll_new (TRUE); }