/** * gst_app_src_set_callbacks: (skip) * @appsrc: a #GstAppSrc * @callbacks: the callbacks * @user_data: a user_data argument for the callbacks * @notify: a destroy notify function * * Set callbacks which will be executed when data is needed, enough data has * been collected or when a seek should be performed. * This is an alternative to using the signals, it has lower overhead and is thus * less expensive, but also less flexible. * * If callbacks are installed, no signals will be emitted for performance * reasons. */ void gst_app_src_set_callbacks (GstAppSrc * appsrc, GstAppSrcCallbacks * callbacks, gpointer user_data, GDestroyNotify notify) { GDestroyNotify old_notify; GstAppSrcPrivate *priv; g_return_if_fail (GST_IS_APP_SRC (appsrc)); g_return_if_fail (callbacks != NULL); priv = appsrc->priv; GST_OBJECT_LOCK (appsrc); old_notify = priv->notify; if (old_notify) { gpointer old_data; old_data = priv->user_data; priv->user_data = NULL; priv->notify = NULL; GST_OBJECT_UNLOCK (appsrc); old_notify (old_data); GST_OBJECT_LOCK (appsrc); } priv->callbacks = *callbacks; priv->user_data = user_data; priv->notify = notify; GST_OBJECT_UNLOCK (appsrc); }
/** * gst_app_sink_set_callbacks: * @appsink: a #GstAppSink * @callbacks: the callbacks * @user_data: a user_data argument for the callbacks * @notify: a destroy notify function * * Set callbacks which will be executed for each new preroll, new buffer and eos. * This is an alternative to using the signals, it has lower overhead and is thus * less expensive, but also less flexible. * * If callbacks are installed, no signals will be emited for performance * reasons. * * Since: 0.10.23 */ void gst_app_sink_set_callbacks (GstAppSink * appsink, GstAppSinkCallbacks * callbacks, gpointer user_data, GDestroyNotify notify) { GDestroyNotify old_notify; g_return_if_fail (appsink != NULL); g_return_if_fail (GST_IS_APP_SINK (appsink)); g_return_if_fail (callbacks != NULL); GST_OBJECT_LOCK (appsink); old_notify = appsink->priv->notify; if (old_notify) { gpointer old_data; old_data = appsink->priv->user_data; appsink->priv->user_data = NULL; appsink->priv->notify = NULL; GST_OBJECT_UNLOCK (appsink); old_notify (old_data); GST_OBJECT_LOCK (appsink); } appsink->priv->callbacks = *callbacks; appsink->priv->user_data = user_data; appsink->priv->notify = notify; GST_OBJECT_UNLOCK (appsink); }
/** * gst_mini_object_set_qdata: * @object: a #GstMiniObject * @quark: A #GQuark, naming the user data pointer * @data: An opaque user data pointer * @destroy: Function to invoke with @data as argument, when @data * needs to be freed * * This sets an opaque, named pointer on a miniobject. * The name is specified through a #GQuark (retrieved e.g. via * g_quark_from_static_string()), and the pointer * can be gotten back from the @object with gst_mini_object_get_qdata() * until the @object is disposed. * Setting a previously set user data pointer, overrides (frees) * the old pointer set, using #NULL as pointer essentially * removes the data stored. * * @destroy may be specified which is called with @data as argument * when the @object is disposed, or the data is being overwritten by * a call to gst_mini_object_set_qdata() with the same @quark. */ void gst_mini_object_set_qdata (GstMiniObject * object, GQuark quark, gpointer data, GDestroyNotify destroy) { gint i; gpointer old_data = NULL; GDestroyNotify old_notify = NULL; g_return_if_fail (object != NULL); g_return_if_fail (quark > 0); G_LOCK (qdata_mutex); if ((i = find_notify (object, quark, FALSE, NULL, NULL)) != -1) { old_data = QDATA_DATA (object, i); old_notify = QDATA_DESTROY (object, i); if (data == NULL) remove_notify (object, i); } if (data != NULL) set_notify (object, i, quark, NULL, data, destroy); G_UNLOCK (qdata_mutex); if (old_notify) old_notify (old_data); }
/** * gst_task_set_thread_callbacks: * @task: The #GstTask to use * @callbacks: a #GstTaskThreadCallbacks pointer * @user_data: user data passed to the callbacks * @notify: called when @user_data is no longer referenced * * Set callbacks which will be executed when a new thread is needed, the thread * function is entered and left and when the thread is joined. * * By default a thread for @task will be created from a default thread pool. * * Objects can use custom GThreads or can perform additional configuration of * the threads (such as changing the thread priority) by installing callbacks. * * MT safe. * * Since: 0.10.24 */ void gst_task_set_thread_callbacks (GstTask * task, GstTaskThreadCallbacks * callbacks, gpointer user_data, GDestroyNotify notify) { GDestroyNotify old_notify; g_return_if_fail (task != NULL); g_return_if_fail (GST_IS_TASK (task)); g_return_if_fail (callbacks != NULL); GST_OBJECT_LOCK (task); old_notify = task->priv->thr_notify; if (old_notify) { gpointer old_data; old_data = task->priv->thr_user_data; task->priv->thr_user_data = NULL; task->priv->thr_notify = NULL; GST_OBJECT_UNLOCK (task); old_notify (old_data); GST_OBJECT_LOCK (task); } task->priv->thr_callbacks = *callbacks; task->priv->thr_user_data = user_data; task->priv->thr_notify = notify; GST_OBJECT_UNLOCK (task); }
/** * gst_bus_set_sync_handler: * @bus: a #GstBus to install the handler on * @func: (allow-none): The handler function to install * @user_data: User data that will be sent to the handler function. * @notify: called when @user_data becomes unused * * Sets the synchronous handler on the bus. The function will be called * every time a new message is posted on the bus. Note that the function * will be called in the same thread context as the posting object. This * function is usually only called by the creator of the bus. Applications * should handle messages asynchronously using the gst_bus watch and poll * functions. * * You cannot replace an existing sync_handler. You can pass %NULL to this * function, which will clear the existing handler. */ void gst_bus_set_sync_handler (GstBus * bus, GstBusSyncHandler func, gpointer user_data, GDestroyNotify notify) { GDestroyNotify old_notify; g_return_if_fail (GST_IS_BUS (bus)); GST_OBJECT_LOCK (bus); /* Assert if the user attempts to replace an existing sync_handler, * other than to clear it */ if (func != NULL && bus->priv->sync_handler != NULL) goto no_replace; if ((old_notify = bus->priv->sync_handler_notify)) { gpointer old_data = bus->priv->sync_handler_data; bus->priv->sync_handler_data = NULL; bus->priv->sync_handler_notify = NULL; GST_OBJECT_UNLOCK (bus); old_notify (old_data); GST_OBJECT_LOCK (bus); } bus->priv->sync_handler = func; bus->priv->sync_handler_data = user_data; bus->priv->sync_handler_notify = notify; GST_OBJECT_UNLOCK (bus); return; no_replace: { GST_OBJECT_UNLOCK (bus); g_warning ("cannot replace existing sync handler"); return; } }