static void
transport_stream_constructed (GObject * object)
{
TransportStream *stream = TRANSPORT_STREAM (object);
GstWebRTCBin *webrtc;
GstWebRTCICETransport *ice_trans;
stream->transport = gst_webrtc_dtls_transport_new (stream->session_id, FALSE);
stream->rtcp_transport =
gst_webrtc_dtls_transport_new (stream->session_id, TRUE);
webrtc = GST_WEBRTC_BIN (gst_object_get_parent (GST_OBJECT (object)));
g_object_bind_property (stream->transport, "client", stream, "dtls-client",
G_BINDING_BIDIRECTIONAL);
g_object_bind_property (stream->rtcp_transport, "client", stream,
"dtls-client", G_BINDING_BIDIRECTIONAL);
g_object_bind_property (stream->transport, "certificate",
stream->rtcp_transport, "certificate", G_BINDING_BIDIRECTIONAL);
/* Need to go full Java and have a transport manager?
* Or make the caller set the ICE transport up? */
stream->stream = _find_ice_stream_for_session (webrtc, stream->session_id);
if (stream->stream == NULL) {
stream->stream = gst_webrtc_ice_add_stream (webrtc->priv->ice,
stream->session_id);
_add_ice_stream_item (webrtc, stream->session_id, stream->stream);
}
ice_trans =
gst_webrtc_ice_find_transport (webrtc->priv->ice, stream->stream,
GST_WEBRTC_ICE_COMPONENT_RTP);
gst_webrtc_dtls_transport_set_transport (stream->transport, ice_trans);
gst_object_unref (ice_trans);
ice_trans =
gst_webrtc_ice_find_transport (webrtc->priv->ice, stream->stream,
GST_WEBRTC_ICE_COMPONENT_RTCP);
gst_webrtc_dtls_transport_set_transport (stream->rtcp_transport, ice_trans);
gst_object_unref (ice_trans);
stream->send_bin = g_object_new (transport_send_bin_get_type (), "stream",
stream, NULL);
gst_object_ref_sink (stream->send_bin);
stream->receive_bin = g_object_new (transport_receive_bin_get_type (),
"stream", stream, NULL);
gst_object_ref_sink (stream->receive_bin);
gst_object_unref (webrtc);
G_OBJECT_CLASS (parent_class)->constructed (object);
}
/**
* gst_gl_shader_attach_unlocked:
* @shader: a #GstGLShader
* @stage: (transfer floating): a #GstGLSLStage to attach
*
* Attaches @stage to @shader. @stage must have been successfully compiled
* with gst_glsl_stage_compile().
*
* Note: must be called in the GL thread
*
* Returns: whether @stage could be attached to @shader
*
* Since: 1.8
*/
gboolean
gst_gl_shader_attach_unlocked (GstGLShader * shader, GstGLSLStage * stage)
{
guint stage_handle;
g_return_val_if_fail (GST_IS_GL_SHADER (shader), FALSE);
g_return_val_if_fail (GST_IS_GLSL_STAGE (stage), FALSE);
if (!_gst_glsl_funcs_fill (&shader->priv->vtable, shader->context)) {
GST_WARNING_OBJECT (shader, "Failed to retreive required GLSL functions");
gst_object_ref_sink (stage);
gst_object_unref (stage);
return FALSE;
}
if (!_ensure_program (shader)) {
gst_object_ref_sink (stage);
gst_object_unref (stage);
return FALSE;
}
/* already attached? */
if (g_list_find (shader->priv->stages, stage)) {
gst_object_ref_sink (stage);
gst_object_unref (stage);
return TRUE;
}
stage_handle = gst_glsl_stage_get_handle (stage);
if (!stage_handle) {
gst_object_ref_sink (stage);
gst_object_unref (stage);
return FALSE;
}
if (shader->context->gl_vtable->IsProgram)
g_assert (shader->context->gl_vtable->IsProgram (shader->priv->
program_handle));
if (shader->context->gl_vtable->IsShader)
g_assert (shader->context->gl_vtable->IsShader (stage_handle));
shader->priv->stages =
g_list_prepend (shader->priv->stages, gst_object_ref_sink (stage));
GST_LOG_OBJECT (shader, "attaching shader %i to program %i", stage_handle,
(int) shader->priv->program_handle);
shader->priv->vtable.AttachShader (shader->priv->program_handle,
stage_handle);
return TRUE;
}
template <> WebKitMediaSrc* refGPtr<WebKitMediaSrc>(WebKitMediaSrc* ptr)
{
if (ptr)
gst_object_ref_sink(GST_OBJECT(ptr));
return ptr;
}
static void
gst_clock_init (GstClock * clock)
{
GstClockPrivate *priv;
clock->priv = priv =
G_TYPE_INSTANCE_GET_PRIVATE (clock, GST_TYPE_CLOCK, GstClockPrivate);
priv->last_time = 0;
priv->internal_calibration = 0;
priv->external_calibration = 0;
priv->rate_numerator = 1;
priv->rate_denominator = 1;
g_mutex_init (&priv->slave_lock);
priv->window_size = DEFAULT_WINDOW_SIZE;
priv->window_threshold = DEFAULT_WINDOW_THRESHOLD;
priv->filling = TRUE;
priv->time_index = 0;
priv->timeout = DEFAULT_TIMEOUT;
priv->times = g_new0 (GstClockTime, 4 * priv->window_size);
/* clear floating flag */
gst_object_ref_sink (clock);
}
static GList *
gst_v4l2_device_provider_probe (GstDeviceProvider * provider)
{
GstV4l2DeviceProvider *self = GST_V4L2_DEVICE_PROVIDER (provider);
GstV4l2Iterator *it;
GList *devices = NULL;
it = gst_v4l2_iterator_new ();
while (gst_v4l2_iterator_next (it)) {
GstStructure *props;
GstV4l2Device *device;
props = gst_structure_new ("v4l2-proplist", "device.path", G_TYPE_STRING,
it->device_path, "udev-probed", G_TYPE_BOOLEAN, FALSE, NULL);
device = gst_v4l2_device_provider_probe_device (self, it->device_path, NULL,
props);
if (device) {
gst_object_ref_sink (device);
devices = g_list_prepend (devices, device);
}
}
gst_v4l2_iterator_free (it);
return devices;
}
static void
gst_gl_sink_bin_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGLSinkBin *self = GST_GL_SINK_BIN (object);
switch (prop_id) {
case PROP_SINK:
{
GstElement *sink = g_value_get_object (value);
if (self->sink)
gst_bin_remove (GST_BIN (self), self->sink);
self->sink = sink;
if (sink) {
gst_object_ref_sink (sink);
_connect_sink_element (self);
}
break;
}
case PROP_CONTRAST:
case PROP_BRIGHTNESS:
case PROP_HUE:
case PROP_SATURATION:
if (self->balance)
g_object_set_property (G_OBJECT (self->balance), pspec->name, value);
break;
default:
if (self->sink)
g_object_set_property (G_OBJECT (self->sink), pspec->name, value);
break;
}
}
/**
* gst_object_set_parent:
* @object: a #GstObject
* @parent: new parent of object
*
* Sets the parent of @object to @parent. The object's reference count will
* be incremented, and any floating reference will be removed (see gst_object_ref_sink()).
*
* Returns: TRUE if @parent could be set or FALSE when @object
* already had a parent or @object and @parent are the same.
*
* MT safe. Grabs and releases @object's LOCK.
*/
gboolean
gst_object_set_parent (GstObject * object, GstObject * parent)
{
g_return_val_if_fail (GST_IS_OBJECT (object), FALSE);
g_return_val_if_fail (GST_IS_OBJECT (parent), FALSE);
g_return_val_if_fail (object != parent, FALSE);
GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object,
"set parent (ref and sink)");
GST_OBJECT_LOCK (object);
if (G_UNLIKELY (object->parent != NULL))
goto had_parent;
object->parent = parent;
gst_object_ref_sink (object);
GST_OBJECT_UNLOCK (object);
/* FIXME, this does not work, the deep notify takes the lock from the parent
* object and deadlocks when the parent holds its lock when calling this
* function (like _element_add_pad()) */
/* g_object_notify_by_pspec ((GObject *)object, properties[PROP_PARENT]); */
return TRUE;
/* ERROR handling */
had_parent:
{
GST_CAT_DEBUG_OBJECT (GST_CAT_REFCOUNTING, object,
"set parent failed, object already had a parent");
GST_OBJECT_UNLOCK (object);
return FALSE;
}
}
static void
gst_insert_bin_add (GstInsertBin * self, GstElement * element,
GstElement * sibling, GstInsertBinDirection direction,
GstInsertBinCallback callback, gpointer user_data)
{
gst_object_ref_sink (element);
if (!validate_element (self, element))
goto reject;
if (sibling) {
gboolean is_parent;
GST_OBJECT_LOCK (sibling);
is_parent = (GST_OBJECT_PARENT (sibling) == GST_OBJECT_CAST (self));
GST_OBJECT_UNLOCK (sibling);
if (!is_parent)
goto reject;
}
gst_insert_bin_add_operation (self, element, GST_INSERT_BIN_ACTION_ADD,
sibling, direction, callback, user_data);
return;
reject:
if (callback)
callback (self, element, FALSE, user_data);
gst_object_unref (element);
}
//static
PadPtr Pad::create(PadDirection direction, const char *name)
{
GstPad *pad = gst_pad_new(name, static_cast<GstPadDirection>(direction));
if (pad) {
gst_object_ref_sink(pad);
}
return PadPtr::wrap(pad, false);
}
//static
BinPtr Bin::create(const char *name)
{
GstElement *bin = gst_bin_new(name);
if (bin) {
gst_object_ref_sink(bin);
}
return BinPtr::wrap(GST_BIN(bin), false);
}
void webkitGstObjectRefSink(GstObject* gstObject)
{
#ifdef GST_API_VERSION_1
gst_object_ref_sink(gstObject);
#else
gst_object_ref(gstObject);
gst_object_sink(gstObject);
#endif
}
void
gst_wl_shm_allocator_register (void)
{
GstAllocator *alloc;
alloc = g_object_new (GST_TYPE_WL_SHM_ALLOCATOR, NULL);
gst_object_ref_sink (alloc);
gst_allocator_register (GST_ALLOCATOR_WL_SHM, alloc);
}
void RefPointerTest::dynamicCastIfaceToObjectTest()
{
GstElement *e = gst_element_factory_make("filesrc", NULL);
gst_object_ref_sink(e);
QGst::UriHandlerPtr u = QGst::UriHandlerPtr::wrap(GST_URI_HANDLER(e), false);
QVERIFY(!u.isNull());
QVERIFY(!u.dynamicCast<QGst::Element>().isNull());
}
static GstStateChangeReturn
gst_gl_mixer_bin_change_state (GstElement * element, GstStateChange transition)
{
GstGLMixerBin *self = GST_GL_MIXER_BIN (element);
GstGLMixerBinClass *klass = GST_GL_MIXER_BIN_GET_CLASS (self);
GstStateChangeReturn ret;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
GST_OBJECT_LOCK (element);
if (!self->mixer) {
if (klass->create_element)
self->mixer = klass->create_element ();
if (!self->mixer) {
g_signal_emit (element,
gst_gl_mixer_bin_signals[SIGNAL_CREATE_ELEMENT], 0, &self->mixer);
if (self->mixer && g_object_is_floating (self->mixer))
gst_object_ref_sink (self->mixer);
}
if (!self->mixer) {
GST_ERROR_OBJECT (element, "Failed to retrieve element");
GST_OBJECT_UNLOCK (element);
return GST_STATE_CHANGE_FAILURE;
}
GST_OBJECT_UNLOCK (element);
if (!_connect_mixer_element (self))
return GST_STATE_CHANGE_FAILURE;
GST_OBJECT_LOCK (element);
}
self->priv->running = TRUE;
GST_OBJECT_UNLOCK (element);
break;
default:
break;
}
ret =
GST_ELEMENT_CLASS (gst_gl_mixer_bin_parent_class)->change_state (element,
transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_NULL:
GST_OBJECT_LOCK (self);
self->priv->running = FALSE;
GST_OBJECT_UNLOCK (self);
default:
break;
}
return ret;
}
static void
ges_project_add_formatter (GESProject * project, GESFormatter * formatter)
{
GESProjectPrivate *priv = GES_PROJECT (project)->priv;
ges_formatter_set_project (formatter, project);
priv->formatters = g_list_append (priv->formatters, formatter);
gst_object_ref_sink (formatter);
}
static gboolean player_gstreamer_trySetupDecoder (PlayerGstreamer* self, const gchar* extension, const gchar* decoder) {
gboolean result = FALSE;
GError * _inner_error_ = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (extension != NULL, FALSE);
g_return_val_if_fail (decoder != NULL, FALSE);
{
const gchar* _tmp0_;
GstElement* _tmp1_ = NULL;
GstElement* _tmp2_;
GeeHashMap* _tmp3_;
const gchar* _tmp4_;
const gchar* _tmp5_;
_tmp0_ = decoder;
_tmp1_ = gst_parse_bin_from_description (_tmp0_, FALSE, &_inner_error_);
gst_object_ref_sink (_tmp1_);
_tmp2_ = _tmp1_;
_gst_object_unref0 (_tmp2_);
if (_inner_error_ != NULL) {
goto __catch0_g_error;
}
_tmp3_ = self->priv->decoders;
_tmp4_ = extension;
_tmp5_ = decoder;
gee_abstract_map_set ((GeeAbstractMap*) _tmp3_, _tmp4_, _tmp5_);
result = TRUE;
return result;
}
goto __finally0;
__catch0_g_error:
{
GError* e = NULL;
FsoFrameworkLogger* _tmp6_;
const gchar* _tmp7_;
const gchar* _tmp8_ = NULL;
gchar* _tmp9_ = NULL;
gchar* _tmp10_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp6_ = fso_framework_theLogger;
_tmp7_ = decoder;
_tmp8_ = string_to_string (_tmp7_);
_tmp9_ = g_strconcat ("Gstreamer does not understand ", _tmp8_, "; not adding to map", NULL);
_tmp10_ = _tmp9_;
fso_framework_logger_warning (_tmp6_, _tmp10_);
_g_free0 (_tmp10_);
result = FALSE;
_g_error_free0 (e);
return result;
}
__finally0:
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return FALSE;
}
/**
* gst_interpolation_control_source_new:
*
* This returns a new, unbound #GstInterpolationControlSource.
*
* Returns: (transfer full): a new, unbound #GstInterpolationControlSource.
*/
GstControlSource *
gst_interpolation_control_source_new (void)
{
GstControlSource *csource =
g_object_new (GST_TYPE_INTERPOLATION_CONTROL_SOURCE, NULL);
/* Clear floating flag */
gst_object_ref_sink (csource);
return csource;
}
void RefPointerTest::refTest1()
{
GstElement *element = gst_bin_new(NULL);
GstObject *bin1 = GST_OBJECT(element);
QCOMPARE(GST_OBJECT_REFCOUNT_VALUE(element), 1);
GstObject *bin2 = GST_OBJECT(gst_object_ref_sink(bin1));
QCOMPARE(GST_OBJECT_REFCOUNT_VALUE(bin2), 1);
QGst::ObjectPtr object = QGst::ObjectPtr::wrap(bin2, false);
QCOMPARE(GST_OBJECT_REFCOUNT_VALUE(bin2), 1);
}
static GstShmSinkAllocator *
gst_shm_sink_allocator_new (GstShmSink * sink)
{
GstShmSinkAllocator *self = g_object_new (GST_TYPE_SHM_SINK_ALLOCATOR, NULL);
gst_object_ref_sink (self);
self->sink = gst_object_ref (sink);
return self;
}
/**
* gst_trigger_control_source_new:
*
* This returns a new, unbound #GstTriggerControlSource.
*
* Returns: (transfer full): a new, unbound #GstTriggerControlSource.
*/
GstControlSource *
gst_trigger_control_source_new (void)
{
GstControlSource *csource =
g_object_new (GST_TYPE_TRIGGER_CONTROL_SOURCE, NULL);
/* Clear floating flag */
gst_object_ref_sink (csource);
return csource;
}
/**
* gst_device_monitor_new:
*
* Create a new #GstDeviceMonitor
*
* Returns: (transfer full): a new device monitor.
*
* Since: 1.4
*/
GstDeviceMonitor *
gst_device_monitor_new (void)
{
GstDeviceMonitor *monitor;
monitor = g_object_new (GST_TYPE_DEVICE_MONITOR, NULL);
/* Clear floating flag */
gst_object_ref_sink (monitor);
return monitor;
}
GstElement *
rygel_gst_utils_get_rtp_depayloader (GstCaps *caps) {
GList *features;
GList *filtered;
const gchar *feature_name;
if (!rygel_gst_utils_need_rtp_depayloader (caps)) {
return NULL;
}
features = gst_element_factory_list_get_elements ((GstElementFactoryListType) GST_ELEMENT_FACTORY_TYPE_DEPAYLOADER, GST_RANK_NONE);
filtered = gst_element_factory_list_filter (features, caps, GST_PAD_SINK, FALSE);
gst_plugin_feature_list_free (features);
feature_name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (filtered->data));
/* If most "fitting" depayloader was rtpdepay skip it because it is
* just some kind of proxy.
*/
if (g_strcmp0 (feature_name, "rtpdepay") == 0) {
if (filtered->next) {
GstElement* element = gst_element_factory_create (GST_ELEMENT_FACTORY (filtered->next->data), NULL);
if (element) {
gst_object_ref_sink (element);
}
gst_plugin_feature_list_free (filtered);
return element;
}
return NULL;
} else {
GstElement* element = gst_element_factory_create (GST_ELEMENT_FACTORY (filtered->data), NULL);
if (element) {
gst_object_ref_sink (element);
}
gst_plugin_feature_list_free (filtered);
return element;
}
}
void RefPointerTest::dynamicCastUpObjectTest()
{
GstBin *bin = GST_BIN(gst_object_ref_sink(gst_bin_new(NULL)));
{
QGst::BinPtr object = QGst::BinPtr::wrap(bin);
QVERIFY(!object.dynamicCast<QGst::Element>().isNull());
QVERIFY(!object.dynamicCast<QGlib::Object>().isNull());
QVERIFY(!object.dynamicCast<QGst::ChildProxy>().isNull());
}
gst_object_unref(bin);
}
static GObject *
gst_control_source_constructor (GType type, guint n_construct_params,
GObjectConstructParam * construct_params)
{
GObject *self;
self =
G_OBJECT_CLASS (gst_control_source_parent_class)->constructor (type,
n_construct_params, construct_params);
gst_object_ref_sink (self);
return self;
}
void RefPointerTest::dynamicCastDownObjectTest()
{
GstObject *bin = GST_OBJECT(gst_object_ref_sink(gst_bin_new(NULL)));
{
QGlib::ObjectPtr object = QGlib::ObjectPtr::wrap(G_OBJECT(bin));
QVERIFY(!object.dynamicCast<QGst::Object>().isNull());
QVERIFY(!object.dynamicCast<QGst::Bin>().isNull());
QVERIFY(object.dynamicCast<QGst::Pipeline>().isNull());
}
gst_object_unref(bin);
}
//static
BinPtr Bin::fromDescription(const char *description, BinFromDescriptionOption ghostUnlinkedPads)
{
GError *error = NULL;
GstElement *e = gst_parse_bin_from_description_full(description, ghostUnlinkedPads,
NULL, GST_PARSE_FLAG_FATAL_ERRORS, &error);
if (error) {
throw QGlib::Error(error);
}
if (e) {
gst_object_ref_sink(e);
}
return BinPtr::wrap(GST_BIN(e), false);
}
static void
gst_bus_init (GstBus * bus)
{
bus->priv = G_TYPE_INSTANCE_GET_PRIVATE (bus, GST_TYPE_BUS, GstBusPrivate);
bus->priv->enable_async = DEFAULT_ENABLE_ASYNC;
g_mutex_init (&bus->priv->queue_lock);
bus->priv->queue = gst_atomic_queue_new (32);
/* clear floating flag */
gst_object_ref_sink (bus);
GST_DEBUG_OBJECT (bus, "created");
}
/**
* gst_bus_new:
*
* Creates a new #GstBus instance.
*
* Returns: (transfer full): a new #GstBus instance
*/
GstBus *
gst_bus_new (void)
{
GstBus *result;
result = g_object_new (gst_bus_get_type (), NULL);
GST_DEBUG_OBJECT (result, "created new bus");
/* clear floating flag */
gst_object_ref_sink (result);
return result;
}
static gboolean
impl_remove_filter (RBPlayerGstFilter *player, GstElement *element)
{
RBPlayerGst *mp = RB_PLAYER_GST (player);
if (mp->priv->filterbin == NULL) {
gst_object_ref_sink (element);
mp->priv->waiting_filters = g_list_remove (mp->priv->waiting_filters, element);
return TRUE;
}
return rb_gst_remove_filter (RB_PLAYER (mp), mp->priv->filterbin, element, need_pad_blocking (mp));
}
GstBufferPool *
gst_xvimage_buffer_pool_new (GstXvImageAllocator * allocator)
{
GstXvImageBufferPool *pool;
pool = g_object_new (GST_TYPE_XVIMAGE_BUFFER_POOL, NULL);
gst_object_ref_sink (pool);
pool->allocator = gst_object_ref (allocator);
GST_LOG_OBJECT (pool, "new XvImage buffer pool %p", pool);
return GST_BUFFER_POOL_CAST (pool);
}