static GstPad * gst_funnel_request_new_pad (GstElement * element, GstPadTemplate * templ, const gchar * name, const GstCaps * caps) { GstPad *sinkpad; GST_DEBUG_OBJECT (element, "requesting pad"); sinkpad = GST_PAD_CAST (g_object_new (GST_TYPE_FUNNEL_PAD, "name", name, "direction", templ->direction, "template", templ, NULL)); gst_pad_set_chain_function (sinkpad, GST_DEBUG_FUNCPTR (gst_funnel_sink_chain)); gst_pad_set_chain_list_function (sinkpad, GST_DEBUG_FUNCPTR (gst_funnel_sink_chain_list)); gst_pad_set_event_function (sinkpad, GST_DEBUG_FUNCPTR (gst_funnel_sink_event)); GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_CAPS); GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_ALLOCATION); gst_pad_set_active (sinkpad, TRUE); gst_element_add_pad (element, sinkpad); GST_DEBUG_OBJECT (element, "requested pad %s:%s", GST_DEBUG_PAD_NAME (sinkpad)); return sinkpad; }
static void gst_flutsindex_init (GstFluTSIndex * index) { index->writers = g_hash_table_new (NULL, NULL); index->last_id = 0; index->id = -1; GST_OBJECT_FLAG_SET (index, GST_FLUTSINDEX_WRITABLE); GST_OBJECT_FLAG_SET (index, GST_FLUTSINDEX_READABLE); }
static void gst_timestampoverlay_init (GstTimeStampOverlay *timestampoverlay) { GST_OBJECT_FLAG_SET (timestampoverlay, GST_ELEMENT_FLAG_REQUIRE_CLOCK); timestampoverlay->latency = GST_CLOCK_TIME_NONE; timestampoverlay->realtime_clock = g_object_new (GST_TYPE_SYSTEM_CLOCK, "clock-type", GST_CLOCK_TYPE_REALTIME, NULL); GST_OBJECT_FLAG_SET (timestampoverlay->realtime_clock, GST_CLOCK_FLAG_CAN_SET_MASTER); }
static void gst_pad_template_init (GstPadTemplate * templ) { /* GstPadTemplate objects are usually leaked */ GST_OBJECT_FLAG_SET (templ, GST_OBJECT_FLAG_MAY_BE_LEAKED); GST_PAD_TEMPLATE_GTYPE (templ) = G_TYPE_NONE; }
static void gst_rdt_manager_init (GstRDTManager * rdtmanager) { rdtmanager->provided_clock = gst_system_clock_obtain (); rdtmanager->latency = DEFAULT_LATENCY_MS; GST_OBJECT_FLAG_SET (rdtmanager, GST_ELEMENT_FLAG_PROVIDE_CLOCK); }
static void nle_operation_init (NleOperation * operation) { GST_OBJECT_FLAG_SET (operation, NLE_OBJECT_OPERATION); nle_operation_reset (operation); operation->element = NULL; }
static void gst_audio_clock_init (GstAudioClock * clock) { clock->last_time = 0; clock->abidata.ABI.time_offset = 0; GST_OBJECT_FLAG_SET (clock, GST_CLOCK_FLAG_CAN_SET_MASTER); }
/** * gst_bus_set_flushing: * @bus: a #GstBus * @flushing: whether or not to flush the bus * * If @flushing, flush out and unref any messages queued in the bus. Releases * references to the message origin objects. Will flush future messages until * gst_bus_set_flushing() sets @flushing to %FALSE. * * MT safe. */ void gst_bus_set_flushing (GstBus * bus, gboolean flushing) { GstMessage *message; GList *message_list = NULL; g_return_if_fail (GST_IS_BUS (bus)); GST_OBJECT_LOCK (bus); if (flushing) { GST_OBJECT_FLAG_SET (bus, GST_BUS_FLUSHING); GST_DEBUG_OBJECT (bus, "set bus flushing"); while ((message = gst_bus_pop (bus))) message_list = g_list_prepend (message_list, message); } else { GST_DEBUG_OBJECT (bus, "unset bus flushing"); GST_OBJECT_FLAG_UNSET (bus, GST_BUS_FLUSHING); } GST_OBJECT_UNLOCK (bus); g_list_free_full (message_list, (GDestroyNotify) gst_message_unref); }
static gboolean gst_artsdsink_open_audio (GstArtsdsink * sink) { const char connname[] = "gstreamer"; int errcode; /* Name used by aRtsd for this connection. */ if (sink->connect_name != NULL) connname = sink->connect_name; /* FIXME: this should only ever happen once per process. */ /* Really, artsc needs to be made thread safe to fix this (and other related */ /* problems). */ errcode = arts_init (); if (errcode < 0) { fprintf (stderr, "arts_init error: %s\n", arts_error_text (errcode)); return FALSE; } GST_DEBUG ("artsdsink: attempting to open connection to aRtsd server"); sink->stream = arts_play_stream (sink->frequency, sink->depth, sink->channels, connname); /* FIXME: check connection */ /* GST_DEBUG ("artsdsink: can't open connection to aRtsd server"); */ GST_OBJECT_FLAG_SET (sink, GST_ARTSDSINK_OPEN); sink->connected = TRUE; return TRUE; }
static void owr_inter_src_init(OwrInterSrc *self) { GstPad *srcpad, *sinkpad; GST_OBJECT_FLAG_SET(self, GST_ELEMENT_FLAG_SOURCE); self->queue = gst_element_factory_make("queue", NULL); gst_bin_add(GST_BIN(self), self->queue); srcpad = gst_element_get_static_pad(self->queue, "src"); self->srcpad = gst_ghost_pad_new_from_template("src", srcpad, gst_static_pad_template_get(&src_template)); gst_object_unref(srcpad); gst_element_add_pad(GST_ELEMENT(self), self->srcpad); /* Just to allow linking... */ self->dummy_sinkpad = gst_pad_new("dummy_sinkpad", GST_PAD_SINK); gst_object_set_parent(GST_OBJECT(self->dummy_sinkpad), GST_OBJECT(self)); self->internal_srcpad = gst_pad_new("internal_src", GST_PAD_SRC); gst_object_set_parent(GST_OBJECT(self->internal_srcpad), GST_OBJECT(self->dummy_sinkpad)); gst_pad_set_event_function(self->internal_srcpad, owr_inter_src_internal_src_event); gst_pad_set_query_function(self->internal_srcpad, owr_inter_src_internal_src_query); sinkpad = gst_element_get_static_pad(self->queue, "sink"); gst_pad_link(self->internal_srcpad, sinkpad); gst_object_unref(sinkpad); }
static void gst_hls_sink_init (GstHlsSink * sink) { GstPadTemplate *templ = gst_static_pad_template_get (&sink_template); sink->ghostpad = gst_ghost_pad_new_no_target_from_template ("sink", templ); gst_object_unref (templ); gst_element_add_pad (GST_ELEMENT_CAST (sink), sink->ghostpad); gst_pad_add_probe (sink->ghostpad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM, gst_hls_sink_ghost_event_probe, sink, NULL); gst_pad_add_probe (sink->ghostpad, GST_PAD_PROBE_TYPE_BUFFER, gst_hls_sink_ghost_buffer_probe, sink, NULL); gst_pad_set_chain_list_function (sink->ghostpad, gst_hls_sink_chain_list); sink->location = g_strdup (DEFAULT_LOCATION); sink->playlist_location = g_strdup (DEFAULT_PLAYLIST_LOCATION); sink->playlist_root = g_strdup (DEFAULT_PLAYLIST_ROOT); sink->playlist_length = DEFAULT_PLAYLIST_LENGTH; sink->max_files = DEFAULT_MAX_FILES; sink->target_duration = DEFAULT_TARGET_DURATION; /* haven't added a sink yet, make it is detected as a sink meanwhile */ GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_FLAG_SINK); gst_hls_sink_reset (sink); }
static void gst_v4lmjpegsink_init (GstV4lMjpegSink * v4lmjpegsink) { GstElementClass *klass = GST_ELEMENT_GET_CLASS (v4lmjpegsink); v4lmjpegsink->sinkpad = gst_pad_new_from_template (gst_element_class_get_pad_template (klass, "sink"), "sink"); gst_element_add_pad (GST_ELEMENT (v4lmjpegsink), v4lmjpegsink->sinkpad); gst_pad_set_chain_function (v4lmjpegsink->sinkpad, gst_v4lmjpegsink_chain); gst_pad_set_link_function (v4lmjpegsink->sinkpad, gst_v4lmjpegsink_sinkconnect); v4lmjpegsink->clock = NULL; v4lmjpegsink->width = -1; v4lmjpegsink->height = -1; v4lmjpegsink->x_offset = -1; v4lmjpegsink->y_offset = -1; v4lmjpegsink->numbufs = 64; v4lmjpegsink->bufsize = 256; GST_OBJECT_FLAG_SET (v4lmjpegsink, GST_ELEMENT_THREAD_SUGGESTED); }
static GstPadProbeReturn kms_agnostic_bin2_src_reconfigure_probe (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { KmsAgnosticBin2 *self = KMS_AGNOSTIC_BIN2 (gst_pad_get_parent_element (pad)); GstPadProbeReturn ret = GST_PAD_PROBE_OK; GstEvent *event; if (self == NULL) { return GST_PAD_PROBE_OK; } if (GST_PAD_PROBE_INFO_TYPE (info) & GST_PAD_PROBE_TYPE_EVENT_BOTH) { event = gst_pad_probe_info_get_event (info); if (GST_EVENT_TYPE (event) == GST_EVENT_RECONFIGURE) { KmsAgnosticBin2 *self = user_data; GST_DEBUG_OBJECT (pad, "Received reconfigure event"); KMS_AGNOSTIC_BIN2_LOCK (self); GST_OBJECT_FLAG_SET (pad, KMS_AGNOSTIC_PAD_STARTED); kms_agnostic_bin2_process_pad (self, pad); KMS_AGNOSTIC_BIN2_UNLOCK (self); } } g_object_unref (self); return ret; }
static void gst_hls_sink2_init (GstHlsSink2 * sink) { GstElement *mux; sink->location = g_strdup (DEFAULT_LOCATION); sink->playlist_location = g_strdup (DEFAULT_PLAYLIST_LOCATION); sink->playlist_root = g_strdup (DEFAULT_PLAYLIST_ROOT); sink->playlist_length = DEFAULT_PLAYLIST_LENGTH; sink->max_files = DEFAULT_MAX_FILES; sink->target_duration = DEFAULT_TARGET_DURATION; g_queue_init (&sink->old_locations); sink->splitmuxsink = gst_element_factory_make ("splitmuxsink", NULL); gst_bin_add (GST_BIN (sink), sink->splitmuxsink); mux = gst_element_factory_make ("mpegtsmux", NULL); g_object_set (sink->splitmuxsink, "location", sink->location, "max-size-time", ((GstClockTime) sink->target_duration * GST_SECOND), "send-keyframe-requests", TRUE, "muxer", mux, "reset-muxer", FALSE, NULL); GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_FLAG_SINK); gst_hls_sink2_reset (sink); }
static gboolean dxr3videosink_open (Dxr3VideoSink * sink) { g_return_val_if_fail (!GST_OBJECT_FLAG_IS_SET (sink, DXR3VIDEOSINK_OPEN), FALSE); /* Compute the name of the video device file. */ sink->video_filename = g_strdup_printf ("/dev/em8300_mv-%d", sink->card_number); sink->video_fd = open (sink->video_filename, O_WRONLY); if (sink->video_fd < 0) { GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (_("Could not open video device \"%s\" for writing."), sink->video_filename), GST_ERROR_SYSTEM); return FALSE; } /* Open the control device. */ sink->control_filename = g_strdup_printf ("/dev/em8300-%d", sink->card_number); sink->control_fd = open (sink->control_filename, O_WRONLY); if (sink->control_fd < 0) { GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (_("Could not open control device \"%s\" for writing."), sink->control_filename), GST_ERROR_SYSTEM); return FALSE; } GST_OBJECT_FLAG_SET (sink, DXR3VIDEOSINK_OPEN); return TRUE; }
static void dxr3videosink_init (Dxr3VideoSink * sink) { GstPad *pad; pad = gst_pad_new_from_static_template (&dxr3videosink_sink_factory, "sink"); gst_element_add_pad (GST_ELEMENT (sink), pad); gst_pad_set_chain_function (pad, dxr3videosink_chain); GST_OBJECT_FLAG_SET (GST_ELEMENT (sink), GST_ELEMENT_EVENT_AWARE); sink->card_number = 0; sink->video_filename = NULL; sink->video_fd = -1; sink->control_filename = NULL; sink->control_fd = -1; sink->clock = NULL; sink->last_ts = GST_CLOCK_TIME_NONE; sink->cur_buf = NULL; dxr3videosink_reset_parser (sink); }
static void gst_net_client_clock_constructed (GObject * object) { GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object); GstClock *internal_clock; GList *l; ClockCache *cache = NULL; G_OBJECT_CLASS (gst_net_client_clock_parent_class)->constructed (object); G_LOCK (clocks_lock); for (l = clocks; l; l = l->next) { ClockCache *tmp = l->data; GstNetClientInternalClock *internal_clock = GST_NET_CLIENT_INTERNAL_CLOCK (tmp->clock); if (strcmp (internal_clock->address, self->priv->address) == 0 && internal_clock->port == self->priv->port) { cache = tmp; if (cache->remove_id) { gst_clock_id_unschedule (cache->remove_id); cache->remove_id = NULL; } break; } } if (!cache) { cache = g_new0 (ClockCache, 1); cache->clock = g_object_new (GST_TYPE_NET_CLIENT_INTERNAL_CLOCK, "address", self->priv->address, "port", self->priv->port, "is-ntp", self->priv->is_ntp, NULL); clocks = g_list_prepend (clocks, cache); /* Not actually leaked but is cached for a while before being disposed, * see gst_net_client_clock_finalize, so pretend it is to not confuse * tests. */ GST_OBJECT_FLAG_SET (cache->clock, GST_OBJECT_FLAG_MAY_BE_LEAKED); } cache->clocks = g_list_prepend (cache->clocks, self); GST_OBJECT_LOCK (cache->clock); if (gst_clock_is_synced (cache->clock)) gst_clock_set_synced (GST_CLOCK (self), TRUE); self->priv->synced_id = g_signal_connect (cache->clock, "synced", G_CALLBACK (gst_net_client_clock_synced_cb), self); GST_OBJECT_UNLOCK (cache->clock); G_UNLOCK (clocks_lock); self->priv->internal_clock = internal_clock = cache->clock; /* all systems go, cap'n */ }
static void gst_net_client_clock_init (GstNetClientClock * self) { GstNetClientClockPrivate *priv; self->priv = priv = GST_NET_CLIENT_CLOCK_GET_PRIVATE (self); GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_CAN_SET_MASTER); GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC); priv->port = DEFAULT_PORT; priv->address = g_strdup (DEFAULT_ADDRESS); priv->roundtrip_limit = DEFAULT_ROUNDTRIP_LIMIT; priv->minimum_update_interval = DEFAULT_MINIMUM_UPDATE_INTERVAL; priv->base_time = DEFAULT_BASE_TIME; }
static void gst_ios_gl_memory_allocator_init (GstIOSGLMemoryAllocator * allocator) { GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator); alloc->mem_type = GST_IOS_GL_MEMORY_ALLOCATOR_NAME; GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC); }
static void gst_rtp_dec_init (GstRTPDec * rtpdec) { rtpdec->provided_clock = gst_system_clock_obtain (); rtpdec->latency = DEFAULT_LATENCY_MS; GST_OBJECT_FLAG_SET (rtpdec, GST_ELEMENT_FLAG_PROVIDE_CLOCK); }
static void gst_wl_shm_allocator_init (GstWlShmAllocator * self) { self->parent_instance.mem_type = GST_ALLOCATOR_WL_SHM; self->parent_instance.mem_map = gst_wl_shm_mem_map; self->parent_instance.mem_unmap = gst_wl_shm_mem_unmap; GST_OBJECT_FLAG_SET (self, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC); }
static void gst_gl_buffer_allocator_init (GstGLBufferAllocator * allocator) { GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator); alloc->mem_type = GST_GL_BUFFER_ALLOCATOR_NAME; GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC); }
static void gst_gl_memory_pbo_allocator_init (GstGLMemoryPBOAllocator * allocator) { GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator); alloc->mem_type = GST_GL_MEMORY_PBO_ALLOCATOR_NAME; GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC); }
static void gst_index_init (GstIndex * index) { index->curgroup = gst_index_group_new (0); index->maxgroup = 0; index->groups = g_list_prepend (NULL, index->curgroup); index->writers = g_hash_table_new (NULL, NULL); index->last_id = 0; index->method = GST_INDEX_RESOLVER_PATH; index->resolver = resolvers[index->method].resolver; index->resolver_user_data = resolvers[index->method].user_data; GST_OBJECT_FLAG_SET (index, GST_INDEX_WRITABLE); GST_OBJECT_FLAG_SET (index, GST_INDEX_READABLE); GST_DEBUG ("created new index"); }
static void gst_msdk_system_allocator_init (GstMsdkSystemAllocator * allocator) { GstAllocator *const base_allocator = GST_ALLOCATOR_CAST (allocator); base_allocator->mem_type = GST_MSDK_SYSTEM_MEMORY_NAME; base_allocator->mem_map_full = gst_msdk_system_memory_map_full; base_allocator->mem_unmap = gst_msdk_system_memory_unmap; GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC); }
static void gst_auto_video_src_clear_kid (GstAutoVideoSrc * src) { if (src->kid) { gst_element_set_state (src->kid, GST_STATE_NULL); gst_bin_remove (GST_BIN (src), src->kid); src->kid = NULL; /* Don't loose SOURCE flag */ GST_OBJECT_FLAG_SET (src, GST_ELEMENT_FLAG_SOURCE); } }
static void gst_auto_video_sink_clear_kid (GstAutoVideoSink * sink) { if (sink->kid) { gst_element_set_state (sink->kid, GST_STATE_NULL); gst_bin_remove (GST_BIN (sink), sink->kid); sink->kid = NULL; /* Don't lose the SINK flag */ GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_IS_SINK); } }
static void nle_source_init (NleSource * source) { GST_OBJECT_FLAG_SET (source, NLE_OBJECT_SOURCE); source->element = NULL; source->priv = G_TYPE_INSTANCE_GET_PRIVATE (source, NLE_TYPE_SOURCE, NleSourcePrivate); GST_DEBUG_OBJECT (source, "Setting GstBin async-handling to TRUE"); g_object_set (G_OBJECT (source), "async-handling", TRUE, NULL); }
static GstStateChangeReturn gst_sdlvideosink_change_state (GstElement * element, GstStateChange transition) { GstSDLVideoSink *sdlvideosink; GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; g_return_val_if_fail (GST_IS_SDLVIDEOSINK (element), GST_STATE_CHANGE_FAILURE); sdlvideosink = GST_SDLVIDEOSINK (element); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: sdlvideosink->is_xwindows = GST_IS_X_OVERLAY (sdlvideosink); g_mutex_lock (sdlvideosink->lock); if (!gst_sdlvideosink_initsdl (sdlvideosink)) { g_mutex_unlock (sdlvideosink->lock); goto init_failed; } GST_OBJECT_FLAG_SET (sdlvideosink, GST_SDLVIDEOSINK_OPEN); g_mutex_unlock (sdlvideosink->lock); break; default: /* do nothing */ break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: sdlvideosink->framerate_n = 0; sdlvideosink->framerate_d = 1; g_mutex_lock (sdlvideosink->lock); gst_sdlvideosink_destroy (sdlvideosink); g_mutex_unlock (sdlvideosink->lock); break; case GST_STATE_CHANGE_READY_TO_NULL: g_mutex_lock (sdlvideosink->lock); gst_sdlvideosink_deinitsdl (sdlvideosink); GST_OBJECT_FLAG_UNSET (sdlvideosink, GST_SDLVIDEOSINK_OPEN); g_mutex_unlock (sdlvideosink->lock); break; default: /* do nothing */ break; } return ret; init_failed: { /* method posted detailed error message */ GST_DEBUG_OBJECT (sdlvideosink, "init failed"); return GST_STATE_CHANGE_FAILURE; } }
static void gst_splitmux_sink_init (GstSplitMuxSink * splitmux) { g_mutex_init (&splitmux->lock); g_cond_init (&splitmux->data_cond); splitmux->mux_overhead = DEFAULT_MUXER_OVERHEAD; splitmux->threshold_time = DEFAULT_MAX_SIZE_TIME; splitmux->threshold_bytes = DEFAULT_MAX_SIZE_BYTES; GST_OBJECT_FLAG_SET (splitmux, GST_ELEMENT_FLAG_SINK); }