#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <string.h>
#include <math.h>
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <string.h>
#include "gstflacdec.h"
typedef struct
{
gint refcount;
- GMutex *lock;
- GCond *flush_cond;
+ GMutex lock;
+ GCond flush_cond;
/* id/server pair and the connection */
gchar *id;
}
}
- g_mutex_lock (conn->lock);
+ g_mutex_lock (&conn->lock);
/* call sources first, then sinks. Sources will either push data into the
* ringbuffer of the sinks, which will then pull the data out of it, or
* sinks will pull the data from the sources. */
res = client->process (nframes, client->user_data);
if (client->deactivate) {
client->deactivate = FALSE;
- g_cond_signal (conn->flush_cond);
+ g_cond_signal (&conn->flush_cond);
}
}
}
res = client->process (nframes, client->user_data);
if (client->deactivate) {
client->deactivate = FALSE;
- g_cond_signal (conn->flush_cond);
+ g_cond_signal (&conn->flush_cond);
}
}
}
- g_mutex_unlock (conn->lock);
+ g_mutex_unlock (&conn->lock);
return res;
}
GST_DEBUG ("disconnect client %s from server %s", conn->id,
GST_STR_NULL (conn->server));
- g_mutex_lock (conn->lock);
+ g_mutex_lock (&conn->lock);
for (walk = conn->src_clients; walk; walk = g_list_next (walk)) {
GstJackAudioClient *client = (GstJackAudioClient *) walk->data;
if (client->shutdown)
client->shutdown (client->user_data);
}
- g_mutex_unlock (conn->lock);
+ g_mutex_unlock (&conn->lock);
}
typedef struct
/* now create object */
conn = g_new (GstJackAudioConnection, 1);
conn->refcount = 1;
- conn->lock = g_mutex_new ();
- conn->flush_cond = g_cond_new ();
+ g_mutex_init (&conn->lock);
+ g_cond_init (&conn->flush_cond);
conn->id = g_strdup (id);
conn->server = g_strdup (server);
conn->client = jclient;
{
GST_ERROR ("Could not activate client (%d)", res);
*status = JackFailure;
- g_mutex_free (conn->lock);
+ g_mutex_clear (&conn->lock);
g_free (conn->id);
g_free (conn->server);
g_free (conn);
}
/* free resources */
- g_mutex_free (conn->lock);
- g_cond_free (conn->flush_cond);
+ g_mutex_clear (&conn->lock);
+ g_cond_clear (&conn->flush_cond);
g_free (conn->id);
g_free (conn->server);
g_free (conn);
gst_jack_audio_connection_add_client (GstJackAudioConnection * conn,
GstJackAudioClient * client)
{
- g_mutex_lock (conn->lock);
+ g_mutex_lock (&conn->lock);
switch (client->type) {
case GST_JACK_CLIENT_SOURCE:
conn->src_clients = g_list_append (conn->src_clients, client);
g_warning ("trying to add unknown client type");
break;
}
- g_mutex_unlock (conn->lock);
+ g_mutex_unlock (&conn->lock);
}
static void
gst_jack_audio_connection_remove_client (GstJackAudioConnection * conn,
GstJackAudioClient * client)
{
- g_mutex_lock (conn->lock);
+ g_mutex_lock (&conn->lock);
switch (client->type) {
case GST_JACK_CLIENT_SOURCE:
conn->src_clients = g_list_remove (conn->src_clients, client);
g_warning ("trying to remove unknown client type");
break;
}
- g_mutex_unlock (conn->lock);
+ g_mutex_unlock (&conn->lock);
}
/**
g_return_val_if_fail (client != NULL, -1);
/* make sure that we are not dispatching the client */
- g_mutex_lock (client->conn->lock);
+ g_mutex_lock (&client->conn->lock);
if (client->active && !active) {
/* we need to process once more to flush the port */
client->deactivate = TRUE;
/* need to wait for process_cb run once more */
while (client->deactivate)
- g_cond_wait (client->conn->flush_cond, client->conn->lock);
+ g_cond_wait (&client->conn->flush_cond, &client->conn->lock);
}
client->active = active;
- g_mutex_unlock (client->conn->lock);
+ g_mutex_unlock (&client->conn->lock);
return 0;
}
static guint mainloop_ref_ct = 0;
/* lock for access to shared resources */
-static GMutex *pa_shared_resource_mutex = NULL;
+static GMutex pa_shared_resource_mutex;
/* We keep a custom ringbuffer that is backed up by data allocated by
* pulseaudio. We must also overide the commit function to write into
static void
gst_pulsesink_init_contexts (void)
{
- g_assert (pa_shared_resource_mutex == NULL);
- pa_shared_resource_mutex = g_mutex_new ();
+ g_mutex_init (&pa_shared_resource_mutex);
gst_pulse_shared_contexts = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
}
static void
gst_pulsering_destroy_context (GstPulseRingBuffer * pbuf)
{
- g_mutex_lock (pa_shared_resource_mutex);
+ g_mutex_lock (&pa_shared_resource_mutex);
GST_DEBUG_OBJECT (pbuf, "destroying ringbuffer %p", pbuf);
g_free (pbuf->context_name);
pbuf->context_name = NULL;
}
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
}
static void
pa_threaded_mainloop_lock (mainloop);
- g_mutex_lock (pa_shared_resource_mutex);
+ g_mutex_lock (&pa_shared_resource_mutex);
need_unlock_shared = TRUE;
pctx = g_hash_table_lookup (gst_pulse_shared_contexts, pbuf->context_name);
pctx->ring_buffers = g_slist_prepend (pctx->ring_buffers, pbuf);
}
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
need_unlock_shared = FALSE;
/* context created or shared okay */
unlock_and_fail:
{
if (need_unlock_shared)
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
gst_pulsering_destroy_context (pbuf);
pa_threaded_mainloop_unlock (mainloop);
return FALSE;
g_free (psink->device_description);
psink->device_description = g_strdup (i->description);
- g_mutex_lock (psink->sink_formats_lock);
+ g_mutex_lock (&psink->sink_formats_lock);
for (l = g_list_first (psink->sink_formats); l; l = g_list_next (l))
pa_format_info_free ((pa_format_info *) l->data);
psink->sink_formats = g_list_prepend (psink->sink_formats,
pa_format_info_copy (i->formats[j]));
- g_mutex_unlock (psink->sink_formats_lock);
+ g_mutex_unlock (&psink->sink_formats_lock);
done:
pa_threaded_mainloop_signal (mainloop, 0);
goto out;
}
- g_mutex_lock (psink->sink_formats_lock);
+ g_mutex_lock (&psink->sink_formats_lock);
for (i = g_list_first (psink->sink_formats); i; i = g_list_next (i)) {
if (pa_format_info_is_compatible ((pa_format_info *) i->data, format)) {
ret = TRUE;
break;
}
}
- g_mutex_unlock (psink->sink_formats_lock);
+ g_mutex_unlock (&psink->sink_formats_lock);
} else {
/* We're in READY, let's connect a stream to see if the format is
* accpeted by whatever sink we're routed to */
pulsesink->device_description = NULL;
pulsesink->client_name = gst_pulse_client_name ();
- pulsesink->sink_formats_lock = g_mutex_new ();
+ g_mutex_init (&pulsesink->sink_formats_lock);
pulsesink->sink_formats = NULL;
pulsesink->volume = DEFAULT_VOLUME;
pa_format_info_free ((pa_format_info *) i->data);
g_list_free (pulsesink->sink_formats);
- g_mutex_free (pulsesink->sink_formats_lock);
+ g_mutex_clear (&pulsesink->sink_formats_lock);
if (pulsesink->properties)
gst_structure_free (pulsesink->properties);
}
pa_threaded_mainloop_unlock (mainloop);
- g_mutex_lock (pa_shared_resource_mutex);
+ g_mutex_lock (&pa_shared_resource_mutex);
mainloop_ref_ct--;
if (!mainloop_ref_ct) {
GST_INFO_OBJECT (psink, "terminating pa main loop thread");
pa_threaded_mainloop_free (mainloop);
mainloop = NULL;
}
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
}
static GstStateChangeReturn
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
- g_mutex_lock (pa_shared_resource_mutex);
+ g_mutex_lock (&pa_shared_resource_mutex);
if (!mainloop_ref_ct) {
GST_INFO_OBJECT (element, "new pa main loop thread");
if (!(mainloop = pa_threaded_mainloop_new ()))
goto mainloop_failed;
mainloop_ref_ct = 1;
pa_threaded_mainloop_start (mainloop);
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
} else {
GST_INFO_OBJECT (element, "reusing pa main loop thread");
mainloop_ref_ct++;
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
}
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
/* ERRORS */
mainloop_failed:
{
- g_mutex_unlock (pa_shared_resource_mutex);
+ g_mutex_unlock (&pa_shared_resource_mutex);
GST_ELEMENT_ERROR (pulsesink, RESOURCE, FAILED,
("pa_threaded_mainloop_new() failed"), (NULL));
return GST_STATE_CHANGE_FAILURE;
GstStructure *properties;
pa_proplist *proplist;
- GMutex *sink_formats_lock;
+ GMutex sink_formats_lock;
GList *sink_formats;
volatile gint format_lost;
GstClockTime format_lost_time;
{
const char *proxy;
- souphttpsink->mutex = g_mutex_new ();
- souphttpsink->cond = g_cond_new ();
+ g_mutex_init (&souphttpsink->mutex);
+ g_cond_init (&souphttpsink->cond);
souphttpsink->location = NULL;
souphttpsink->automatic_redirect = TRUE;
{
GstSoupHttpClientSink *souphttpsink = GST_SOUP_HTTP_CLIENT_SINK (object);
- g_mutex_lock (souphttpsink->mutex);
+ g_mutex_lock (&souphttpsink->mutex);
switch (property_id) {
case PROP_SESSION:
if (souphttpsink->prop_session) {
break;
}
done:
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
}
void
soup_uri_free (souphttpsink->proxy);
g_free (souphttpsink->location);
- g_cond_free (souphttpsink->cond);
- g_mutex_free (souphttpsink->mutex);
+ g_cond_clear (&souphttpsink->cond);
+ g_mutex_clear (&souphttpsink->mutex);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GST_LOG_OBJECT (souphttpsink, "thread ready");
- g_mutex_lock (souphttpsink->mutex);
- g_cond_signal (souphttpsink->cond);
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_lock (&souphttpsink->mutex);
+ g_cond_signal (&souphttpsink->cond);
+ g_mutex_unlock (&souphttpsink->mutex);
return FALSE; /* only run once */
}
souphttpsink->loop = g_main_loop_new (souphttpsink->context, TRUE);
- g_mutex_lock (souphttpsink->mutex);
+ g_mutex_lock (&souphttpsink->mutex);
/* FIXME: error handling */
#if !GLIB_CHECK_VERSION (2, 31, 0)
#endif
GST_LOG_OBJECT (souphttpsink, "waiting for main loop thread to start up");
- g_cond_wait (souphttpsink->cond, souphttpsink->mutex);
- g_mutex_unlock (souphttpsink->mutex);
+ g_cond_wait (&souphttpsink->cond, &souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
GST_LOG_OBJECT (souphttpsink, "main loop thread running");
souphttpsink->session =
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
GST_DEBUG_OBJECT (souphttpsink, "got eos");
- g_mutex_lock (souphttpsink->mutex);
+ g_mutex_lock (&souphttpsink->mutex);
while (souphttpsink->message) {
GST_DEBUG_OBJECT (souphttpsink, "waiting");
- g_cond_wait (souphttpsink->cond, souphttpsink->mutex);
+ g_cond_wait (&souphttpsink->cond, &souphttpsink->mutex);
}
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
GST_DEBUG_OBJECT (souphttpsink, "finished eos");
}
static gboolean
send_message (GstSoupHttpClientSink * souphttpsink)
{
- g_mutex_lock (souphttpsink->mutex);
+ g_mutex_lock (&souphttpsink->mutex);
send_message_locked (souphttpsink);
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
return FALSE;
}
GST_DEBUG_OBJECT (souphttpsink, "callback status=%d %s",
msg->status_code, msg->reason_phrase);
- g_mutex_lock (souphttpsink->mutex);
- g_cond_signal (souphttpsink->cond);
+ g_mutex_lock (&souphttpsink->mutex);
+ g_cond_signal (&souphttpsink->cond);
souphttpsink->message = NULL;
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
souphttpsink->status_code = msg->status_code;
souphttpsink->reason_phrase = g_strdup (msg->reason_phrase);
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
return;
}
souphttpsink->sent_buffers = NULL;
send_message_locked (souphttpsink);
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
}
static GstFlowReturn
return GST_FLOW_ERROR;
}
- g_mutex_lock (souphttpsink->mutex);
+ g_mutex_lock (&souphttpsink->mutex);
if (souphttpsink->location != NULL) {
wake = (souphttpsink->queued_buffers == NULL);
souphttpsink->queued_buffers =
g_source_unref (source);
}
}
- g_mutex_unlock (souphttpsink->mutex);
+ g_mutex_unlock (&souphttpsink->mutex);
return GST_FLOW_OK;
}
{
GstBaseSink base_souphttpsink;
- GMutex *mutex;
- GCond *cond;
+ GMutex mutex;
+ GCond cond;
GMainContext *context;
GMainLoop *loop;
GThread *thread;
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <gst/gst.h>
#include <gst/gst-i18n-plugin.h>
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <string.h>
#include <stdio.h>
GST_DEBUG_CATEGORY (equalizer_debug);
#define GST_CAT_DEFAULT equalizer_debug
-#define BANDS_LOCK(equ) g_mutex_lock(equ->bands_lock)
-#define BANDS_UNLOCK(equ) g_mutex_unlock(equ->bands_lock)
+#define BANDS_LOCK(equ) g_mutex_lock(&equ->bands_lock)
+#define BANDS_UNLOCK(equ) g_mutex_unlock(&equ->bands_lock)
static void gst_iir_equalizer_child_proxy_interface_init (gpointer g_iface,
gpointer iface_data);
static void
gst_iir_equalizer_init (GstIirEqualizer * eq)
{
- eq->bands_lock = g_mutex_new ();
+ g_mutex_init (&eq->bands_lock);
eq->need_new_coefficients = TRUE;
}
g_free (equ->bands);
g_free (equ->history);
- g_mutex_free (equ->bands_lock);
+ g_mutex_clear (&equ->bands_lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/*< private >*/
- GMutex *bands_lock;
+ GMutex bands_lock;
GstIirEqualizerBand **bands;
/* properties */
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include "gstflvdemux.h"
#include "gstflvmux.h"
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <gst/glib-compat-private.h>
#include "gstimagefreeze.h"
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <glib/gstdio.h>
#include <gst/gst.h>
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
qtmr->task = gst_task_new (gst_qt_moov_recover_run, qtmr);
- g_static_rec_mutex_init (&qtmr->task_mutex);
+ g_rec_mutex_init (&qtmr->task_mutex);
gst_task_set_lock (qtmr->task, &qtmr->task_mutex);
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
g_assert (gst_task_get_state (qtmr->task) == GST_TASK_STOPPED);
gst_object_unref (qtmr->task);
qtmr->task = NULL;
- g_static_rec_mutex_free (&qtmr->task_mutex);
+ g_rec_mutex_clear (&qtmr->task_mutex);
break;
default:
break;
GstPipeline pipeline;
GstTask *task;
- GStaticRecMutex task_mutex;
+ GRecMutex task_mutex;
/* properties */
gboolean faststart_mode;
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include "gst/gst-i18n-plugin.h"
#include <glib/gprintf.h>
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <math.h>
#include <string.h>
#include <glib/gprintf.h>
#define GST_RTP_BIN_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_BIN, GstRtpBinPrivate))
-#define GST_RTP_BIN_LOCK(bin) g_mutex_lock ((bin)->priv->bin_lock)
-#define GST_RTP_BIN_UNLOCK(bin) g_mutex_unlock ((bin)->priv->bin_lock)
+#define GST_RTP_BIN_LOCK(bin) g_mutex_lock (&(bin)->priv->bin_lock)
+#define GST_RTP_BIN_UNLOCK(bin) g_mutex_unlock (&(bin)->priv->bin_lock)
/* lock to protect dynamic callbacks, like pad-added and new ssrc. */
-#define GST_RTP_BIN_DYN_LOCK(bin) g_mutex_lock ((bin)->priv->dyn_lock)
-#define GST_RTP_BIN_DYN_UNLOCK(bin) g_mutex_unlock ((bin)->priv->dyn_lock)
+#define GST_RTP_BIN_DYN_LOCK(bin) g_mutex_lock (&(bin)->priv->dyn_lock)
+#define GST_RTP_BIN_DYN_UNLOCK(bin) g_mutex_unlock (&(bin)->priv->dyn_lock)
/* lock for shutdown */
#define GST_RTP_BIN_SHUTDOWN_LOCK(bin,label) \
struct _GstRtpBinPrivate
{
- GMutex *bin_lock;
+ GMutex bin_lock;
/* lock protecting dynamic adding/removing */
- GMutex *dyn_lock;
+ GMutex dyn_lock;
/* if we are shutting down or not */
gint shutdown;
gint64 clock_base;
};
-#define GST_RTP_SESSION_LOCK(sess) g_mutex_lock ((sess)->lock)
-#define GST_RTP_SESSION_UNLOCK(sess) g_mutex_unlock ((sess)->lock)
+#define GST_RTP_SESSION_LOCK(sess) g_mutex_lock (&(sess)->lock)
+#define GST_RTP_SESSION_UNLOCK(sess) g_mutex_unlock (&(sess)->lock)
/* Manages the receiving end of the packets.
*
gulong demux_newpad_sig;
gulong demux_padremoved_sig;
- GMutex *lock;
+ GMutex lock;
/* list of GstRtpBinStream */
GSList *streams;
goto no_demux;
sess = g_new0 (GstRtpBinSession, 1);
- sess->lock = g_mutex_new ();
+ g_mutex_init (&sess->lock);
sess->id = id;
sess->bin = rtpbin;
sess->session = session;
g_slist_foreach (sess->streams, (GFunc) free_stream, NULL);
g_slist_free (sess->streams);
- g_mutex_free (sess->lock);
+ g_mutex_clear (&sess->lock);
g_hash_table_destroy (sess->ptmap);
g_free (sess);
gchar *str;
rtpbin->priv = GST_RTP_BIN_GET_PRIVATE (rtpbin);
- rtpbin->priv->bin_lock = g_mutex_new ();
- rtpbin->priv->dyn_lock = g_mutex_new ();
+ g_mutex_init (&rtpbin->priv->bin_lock);
+ g_mutex_init (&rtpbin->priv->dyn_lock);
rtpbin->latency_ms = DEFAULT_LATENCY_MS;
rtpbin->latency_ns = DEFAULT_LATENCY_MS * GST_MSECOND;
if (rtpbin->sdes)
gst_structure_free (rtpbin->sdes);
- g_mutex_free (rtpbin->priv->bin_lock);
- g_mutex_free (rtpbin->priv->dyn_lock);
+ g_mutex_clear (&rtpbin->priv->bin_lock);
+ g_mutex_clear (&rtpbin->priv->dyn_lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
PROP_LAST
};
-#define JBUF_LOCK(priv) (g_mutex_lock ((priv)->jbuf_lock))
+#define JBUF_LOCK(priv) (g_mutex_lock (&(priv)->jbuf_lock))
#define JBUF_LOCK_CHECK(priv,label) G_STMT_START { \
JBUF_LOCK (priv); \
goto label; \
} G_STMT_END
-#define JBUF_UNLOCK(priv) (g_mutex_unlock ((priv)->jbuf_lock))
-#define JBUF_WAIT(priv) (g_cond_wait ((priv)->jbuf_cond, (priv)->jbuf_lock))
+#define JBUF_UNLOCK(priv) (g_mutex_unlock (&(priv)->jbuf_lock))
+#define JBUF_WAIT(priv) (g_cond_wait (&(priv)->jbuf_cond, &(priv)->jbuf_lock))
#define JBUF_WAIT_CHECK(priv,label) G_STMT_START { \
JBUF_WAIT(priv); \
goto label; \
} G_STMT_END
-#define JBUF_SIGNAL(priv) (g_cond_signal ((priv)->jbuf_cond))
+#define JBUF_SIGNAL(priv) (g_cond_signal (&(priv)->jbuf_cond))
struct _GstRtpJitterBufferPrivate
{
GstPad *rtcpsinkpad;
RTPJitterBuffer *jbuf;
- GMutex *jbuf_lock;
- GCond *jbuf_cond;
+ GMutex jbuf_lock;
+ GCond jbuf_cond;
gboolean waiting;
gboolean discont;
gboolean active;
priv->do_lost = DEFAULT_DO_LOST;
priv->jbuf = rtp_jitter_buffer_new ();
- priv->jbuf_lock = g_mutex_new ();
- priv->jbuf_cond = g_cond_new ();
+ g_mutex_init (&priv->jbuf_lock);
+ g_cond_init (&priv->jbuf_cond);
/* reset skew detection initialy */
rtp_jitter_buffer_reset_skew (priv->jbuf);
jitterbuffer = GST_RTP_JITTER_BUFFER (object);
- g_mutex_free (jitterbuffer->priv->jbuf_lock);
- g_cond_free (jitterbuffer->priv->jbuf_cond);
+ g_mutex_clear (&jitterbuffer->priv->jbuf_lock);
+ g_cond_clear (&jitterbuffer->priv->jbuf_cond);
g_object_unref (jitterbuffer->priv->jbuf);
#define GST_RTP_SESSION_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_SESSION, GstRtpSessionPrivate))
-#define GST_RTP_SESSION_LOCK(sess) g_mutex_lock ((sess)->priv->lock)
-#define GST_RTP_SESSION_UNLOCK(sess) g_mutex_unlock ((sess)->priv->lock)
+#define GST_RTP_SESSION_LOCK(sess) g_mutex_lock (&(sess)->priv->lock)
+#define GST_RTP_SESSION_UNLOCK(sess) g_mutex_unlock (&(sess)->priv->lock)
struct _GstRtpSessionPrivate
{
- GMutex *lock;
+ GMutex lock;
GstClock *sysclock;
RTPSession *session;
gst_rtp_session_init (GstRtpSession * rtpsession)
{
rtpsession->priv = GST_RTP_SESSION_GET_PRIVATE (rtpsession);
- rtpsession->priv->lock = g_mutex_new ();
+ g_mutex_init (&rtpsession->priv->lock);
rtpsession->priv->sysclock = gst_system_clock_obtain ();
rtpsession->priv->session = rtp_session_new ();
rtpsession->priv->use_pipeline_clock = DEFAULT_USE_PIPELINE_CLOCK;
rtpsession = GST_RTP_SESSION (object);
g_hash_table_destroy (rtpsession->priv->ptmap);
- g_mutex_free (rtpsession->priv->lock);
+ g_mutex_clear (&rtpsession->priv->lock);
g_object_unref (rtpsession->priv->sysclock);
g_object_unref (rtpsession->priv->session);
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <string.h>
#include <gst/rtp/gstrtpbuffer.h>
#include <gst/rtp/gstrtcpbuffer.h>
GST_STATIC_CAPS ("application/x-rtcp")
);
-#define GST_PAD_LOCK(obj) (g_static_rec_mutex_lock (&(obj)->padlock))
-#define GST_PAD_UNLOCK(obj) (g_static_rec_mutex_unlock (&(obj)->padlock))
+#define GST_PAD_LOCK(obj) (g_rec_mutex_lock (&(obj)->padlock))
+#define GST_PAD_UNLOCK(obj) (g_rec_mutex_unlock (&(obj)->padlock))
/* signals */
enum
gst_rtp_ssrc_demux_iterate_internal_links_sink);
gst_element_add_pad (GST_ELEMENT_CAST (demux), demux->rtcp_sink);
- g_static_rec_mutex_init (&demux->padlock);
+ g_rec_mutex_init (&demux->padlock);
gst_segment_init (&demux->segment, GST_FORMAT_UNDEFINED);
}
GstRtpSsrcDemux *demux;
demux = GST_RTP_SSRC_DEMUX (object);
- g_static_rec_mutex_free (&demux->padlock);
+ g_rec_mutex_clear (&demux->padlock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GstPad *rtp_sink;
GstPad *rtcp_sink;
- GStaticRecMutex padlock;
+ GRecMutex padlock;
GSList *srcpads;
};
gint i;
gchar *str;
- sess->lock = g_mutex_new ();
+ g_mutex_init (&sess->lock);
sess->key = g_random_int ();
sess->mask_idx = 0;
sess->mask = 0;
sess = RTP_SESSION_CAST (object);
- g_mutex_free (sess->lock);
+ g_mutex_clear (&sess->lock);
for (i = 0; i < 32; i++)
g_hash_table_destroy (sess->ssrcs[i]);
#define RTP_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),RTP_TYPE_SESSION))
#define RTP_SESSION_CAST(sess) ((RTPSession *)(sess))
-#define RTP_SESSION_LOCK(sess) (g_mutex_lock ((sess)->lock))
-#define RTP_SESSION_UNLOCK(sess) (g_mutex_unlock ((sess)->lock))
+#define RTP_SESSION_LOCK(sess) (g_mutex_lock (&(sess)->lock))
+#define RTP_SESSION_UNLOCK(sess) (g_mutex_unlock (&(sess)->lock))
/**
* RTPSessionProcessRTP:
struct _RTPSession {
GObject object;
- GMutex *lock;
+ GMutex lock;
guint header_len;
guint mtu;
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif /* HAVE_UNISTD_H */
/* protects the streaming thread in interleaved mode or the polling
* thread in UDP mode. */
- src->stream_rec_lock = g_new (GStaticRecMutex, 1);
- g_static_rec_mutex_init (src->stream_rec_lock);
+ g_rec_mutex_init (&src->stream_rec_lock);
/* protects our state changes from multiple invocations */
- src->state_rec_lock = g_new (GStaticRecMutex, 1);
- g_static_rec_mutex_init (src->state_rec_lock);
+ g_rec_mutex_init (&src->state_rec_lock);
src->state = GST_RTSP_STATE_INVALID;
}
/* free locks */
- g_static_rec_mutex_free (rtspsrc->stream_rec_lock);
- g_free (rtspsrc->stream_rec_lock);
- g_static_rec_mutex_free (rtspsrc->state_rec_lock);
- g_free (rtspsrc->state_rec_lock);
+ g_rec_mutex_clear (&rtspsrc->stream_rec_lock);
+ g_rec_mutex_clear (&rtspsrc->state_rec_lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
typedef struct _GstRTSPSrc GstRTSPSrc;
typedef struct _GstRTSPSrcClass GstRTSPSrcClass;
-#define GST_RTSP_STATE_GET_LOCK(rtsp) (GST_RTSPSRC_CAST(rtsp)->state_rec_lock)
-#define GST_RTSP_STATE_LOCK(rtsp) (g_static_rec_mutex_lock (GST_RTSP_STATE_GET_LOCK(rtsp)))
-#define GST_RTSP_STATE_UNLOCK(rtsp) (g_static_rec_mutex_unlock (GST_RTSP_STATE_GET_LOCK(rtsp)))
+#define GST_RTSP_STATE_GET_LOCK(rtsp) (&GST_RTSPSRC_CAST(rtsp)->state_rec_lock)
+#define GST_RTSP_STATE_LOCK(rtsp) (g_rec_mutex_lock (GST_RTSP_STATE_GET_LOCK(rtsp)))
+#define GST_RTSP_STATE_UNLOCK(rtsp) (g_rec_mutex_unlock (GST_RTSP_STATE_GET_LOCK(rtsp)))
-#define GST_RTSP_STREAM_GET_LOCK(rtsp) (GST_RTSPSRC_CAST(rtsp)->stream_rec_lock)
-#define GST_RTSP_STREAM_LOCK(rtsp) (g_static_rec_mutex_lock (GST_RTSP_STREAM_GET_LOCK(rtsp)))
-#define GST_RTSP_STREAM_UNLOCK(rtsp) (g_static_rec_mutex_unlock (GST_RTSP_STREAM_GET_LOCK(rtsp)))
+#define GST_RTSP_STREAM_GET_LOCK(rtsp) (&GST_RTSPSRC_CAST(rtsp)->stream_rec_lock)
+#define GST_RTSP_STREAM_LOCK(rtsp) (g_rec_mutex_lock (GST_RTSP_STREAM_GET_LOCK(rtsp)))
+#define GST_RTSP_STREAM_UNLOCK(rtsp) (g_rec_mutex_unlock (GST_RTSP_STREAM_GET_LOCK(rtsp)))
typedef struct _GstRTSPConnInfo GstRTSPConnInfo;
/* task and mutex for interleaved mode */
gboolean interleaved;
GstTask *task;
- GStaticRecMutex *stream_rec_lock;
+ GRecMutex stream_rec_lock;
GstSegment segment;
gboolean running;
gboolean need_range;
gboolean open_error;
/* mutex for protecting state changes */
- GStaticRecMutex *state_rec_lock;
+ GRecMutex state_rec_lock;
GstSDPMessage *sdp;
gboolean from_sdp;
GST_DEBUG_FUNCPTR (gst_shape_wipe_src_query));
gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
- self->mask_mutex = g_mutex_new ();
- self->mask_cond = g_cond_new ();
+ g_mutex_init (&self->mask_mutex);
+ g_cond_init (&self->mask_cond);
gst_shape_wipe_reset (self);
}
gst_shape_wipe_reset (self);
- if (self->mask_cond)
- g_cond_free (self->mask_cond);
- self->mask_cond = NULL;
-
- if (self->mask_mutex)
- g_mutex_free (self->mask_mutex);
- self->mask_mutex = NULL;
+ g_cond_clear (&self->mask_cond);
+ g_mutex_clear (&self->mask_mutex);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
gst_buffer_unref (self->mask);
self->mask = NULL;
- g_mutex_lock (self->mask_mutex);
- g_cond_signal (self->mask_cond);
- g_mutex_unlock (self->mask_mutex);
+ g_mutex_lock (&self->mask_mutex);
+ g_cond_signal (&self->mask_cond);
+ g_mutex_unlock (&self->mask_mutex);
gst_video_info_init (&self->info);
self->mask_bpp = 0;
goto invalid_caps;
if (self->info.width != info.width || self->info.height != info.height) {
- g_mutex_lock (self->mask_mutex);
+ g_mutex_lock (&self->mask_mutex);
self->info = info;
if (self->mask)
gst_buffer_unref (self->mask);
self->mask = NULL;
- g_mutex_unlock (self->mask_mutex);
+ g_mutex_unlock (&self->mask_mutex);
}
"Blending buffer with timestamp %" GST_TIME_FORMAT " at position %f",
GST_TIME_ARGS (timestamp), self->mask_position);
- g_mutex_lock (self->mask_mutex);
+ g_mutex_lock (&self->mask_mutex);
if (self->shutdown)
goto shutdown;
if (!self->mask)
- g_cond_wait (self->mask_cond, self->mask_mutex);
+ g_cond_wait (&self->mask_cond, &self->mask_mutex);
if (self->mask == NULL || self->shutdown) {
goto shutdown;
} else {
mask = gst_buffer_ref (self->mask);
}
- g_mutex_unlock (self->mask_mutex);
+ g_mutex_unlock (&self->mask_mutex);
if (!gst_shape_wipe_do_qos (self, GST_BUFFER_TIMESTAMP (buffer)))
goto qos;
GstShapeWipe *self = GST_SHAPE_WIPE (parent);
GstFlowReturn ret = GST_FLOW_OK;
- g_mutex_lock (self->mask_mutex);
+ g_mutex_lock (&self->mask_mutex);
GST_DEBUG_OBJECT (self, "Setting new mask buffer: %" GST_PTR_FORMAT, buffer);
gst_buffer_replace (&self->mask, buffer);
- g_cond_signal (self->mask_cond);
- g_mutex_unlock (self->mask_mutex);
+ g_cond_signal (&self->mask_cond);
+ g_mutex_unlock (&self->mask_mutex);
gst_buffer_unref (buffer);
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
/* Unblock video sink chain function */
- g_mutex_lock (self->mask_mutex);
+ g_mutex_lock (&self->mask_mutex);
self->shutdown = TRUE;
- g_cond_signal (self->mask_cond);
- g_mutex_unlock (self->mask_mutex);
+ g_cond_signal (&self->mask_cond);
+ g_mutex_unlock (&self->mask_mutex);
break;
default:
break;
break;
}
case GST_EVENT_FLUSH_STOP:
- g_mutex_lock (self->mask_mutex);
+ g_mutex_lock (&self->mask_mutex);
gst_buffer_replace (&self->mask, NULL);
- g_mutex_unlock (self->mask_mutex);
+ g_mutex_unlock (&self->mask_mutex);
break;
default:
break;
GstBuffer *mask;
gfloat mask_position;
gfloat mask_border;
- GMutex *mask_mutex;
- GCond *mask_cond;
+ GMutex mask_mutex;
+ GCond mask_cond;
gint mask_bpp;
GstVideoInfo info;
static void
gst_multiudpsink_init (GstMultiUDPSink * sink)
{
- sink->client_lock = g_mutex_new ();
+ g_mutex_init (&sink->client_lock);
sink->socket = DEFAULT_SOCKET;
sink->used_socket = DEFAULT_USED_SOCKET;
sink->close_socket = DEFAULT_CLOSE_SOCKET;
g_object_unref (sink->cancellable);
sink->cancellable = NULL;
- g_mutex_free (sink->client_lock);
+ g_mutex_clear (&sink->client_lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/* grab lock while iterating and sending to clients, this should be
* fast as UDP never blocks */
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
GST_LOG_OBJECT (bsink, "about to send %d bytes", size);
no_clients = 0;
sink->bytes_served += ret;
}
}
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
/* unmap all memory again */
for (i = 0; i < n_mem; i++) {
clients = g_strsplit (string, ",", 0);
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
/* clear all existing clients */
gst_multiudpsink_clear_internal (sink, FALSE);
for (i = 0; clients[i]; i++) {
if (port != 0)
gst_multiudpsink_add_internal (sink, host, port, FALSE);
}
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
g_strfreev (clients);
}
str = g_string_new ("");
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
clients = sink->clients;
while (clients) {
GstUDPClient *client;
(clients || count > 1 ? "," : ""));
}
}
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
return g_string_free (str, FALSE);
}
GST_DEBUG_OBJECT (sink, "adding client on host %s, port %d", host, port);
if (lock)
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
find = g_list_find_custom (sink->clients, &udpclient,
(GCompareFunc) client_compare);
}
if (lock)
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
g_signal_emit (G_OBJECT (sink),
gst_multiudpsink_signals[SIGNAL_CLIENT_ADDED], 0, host, port);
GST_DEBUG_OBJECT (sink, "did not add client on host %s, port %d", host,
port);
if (lock)
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
return;
}
}
udpclient.host = (gchar *) host;
udpclient.port = port;
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
find = g_list_find_custom (sink->clients, &udpclient,
(GCompareFunc) client_compare);
if (!find)
}
/* Unlock to emit signal before we delete the actual client */
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
g_signal_emit (G_OBJECT (sink),
gst_multiudpsink_signals[SIGNAL_CLIENT_REMOVED], 0, host, port);
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
sink->clients = g_list_delete_link (sink->clients, find);
free_client (client);
}
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
return;
/* ERRORS */
not_found:
{
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
GST_WARNING_OBJECT (sink, "client at host %s, port %d not found",
host, port);
return;
/* we only need to remove the client structure, there is no additional
* socket or anything to free for UDP */
if (lock)
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
g_list_foreach (sink->clients, (GFunc) free_client, sink);
g_list_free (sink->clients);
sink->clients = NULL;
if (lock)
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
}
void
udpclient.host = (gchar *) host;
udpclient.port = port;
- g_mutex_lock (sink->client_lock);
+ g_mutex_lock (&sink->client_lock);
find = g_list_find_custom (sink->clients, &udpclient,
(GCompareFunc) client_compare);
"connect-time", G_TYPE_UINT64, client->connect_time,
"disconnect-time", G_TYPE_UINT64, client->disconnect_time, NULL);
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
return result;
/* ERRORS */
not_found:
{
- g_mutex_unlock (sink->client_lock);
+ g_mutex_unlock (&sink->client_lock);
GST_WARNING_OBJECT (sink, "client with host %s, port %d not found",
host, port);
/* Apparently (see comment in gstmultifdsink.c) returning NULL from here may
GSocket *used_socket;
GCancellable *cancellable;
- GMutex *client_lock;
+ GMutex client_lock;
GList *clients;
/* properties */
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <string.h>
#include "videomixer2.h"
#include "config.h"
#endif
-/* FIXME 0.11: suppress warnings for deprecated API such as GStaticRecMutex
- * with newer GLib versions (>= 2.31.0) */
-#define GLIB_DISABLE_DEPRECATION_WARNINGS
-
#include <string.h>
#include <math.h>
{
Display *dpy;
gint port, idle_id, event_id;
- GMutex *mutex; /* to serialize calls to X11 */
+ GMutex mutex; /* to serialize calls to X11 */
};
GST_DEBUG_CATEGORY_STATIC (v4l2xv_debug);
v4l2xv = g_new0 (GstV4l2Xv, 1);
v4l2xv->dpy = dpy;
v4l2xv->port = id;
- v4l2xv->mutex = g_mutex_new ();
+ g_mutex_init (&v4l2xv->mutex);
v4l2xv->idle_id = 0;
v4l2xv->event_id = 0;
v4l2object->xv = v4l2xv;
}
XCloseDisplay (v4l2xv->dpy);
- g_mutex_free (v4l2xv->mutex);
+ g_mutex_clear (&v4l2xv->mutex);
if (v4l2xv->idle_id)
g_source_remove (v4l2xv->idle_id);
if (v4l2xv->event_id)
GstV4l2Xv *v4l2xv = v4l2object->xv;
gboolean ret = FALSE;
if (v4l2xv) {
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
ret = get_render_rect (v4l2object, rect);
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
}
return ret;
}
GST_LOG_OBJECT (v4l2object->element, "idle refresh");
if (v4l2xv) {
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
update_geometry (v4l2object);
v4l2xv->idle_id = 0;
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
}
/* once */
if (v4l2xv) {
XEvent e;
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
/* If the element supports navigation, collect the relavent input
* events and push them upstream as navigation events
if (pointer_moved) {
GST_DEBUG_OBJECT (v4l2object->element,
"pointer moved over window at %d,%d", pointer_x, pointer_y);
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
gst_navigation_send_mouse_event (GST_NAVIGATION (v4l2object->element),
"mouse-move", 0, e.xbutton.x, e.xbutton.y);
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
}
/* We get all events on our window to throw them upstream
KeySym keysym;
const char *key_str = NULL;
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
switch (e.type) {
case ButtonPress:
break;
case KeyPress:
case KeyRelease:
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
keysym = XKeycodeToKeysym (v4l2xv->dpy, e.xkey.keycode, 0);
if (keysym != NoSymbol) {
key_str = XKeysymToString (keysym);
} else {
key_str = "unknown";
}
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element,
"key %d pressed over window at %d,%d (%s)",
e.xkey.keycode, e.xkey.x, e.xkey.y, key_str);
"unhandled X event (%d)", e.type);
}
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
}
}
break;
}
}
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
}
/* repeat */
v4l2xv = v4l2object->xv;
if (v4l2xv)
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
if (change) {
if (v4l2object->xwindow_id && v4l2xv) {
if (!v4l2xv || xwindow_id == 0) {
if (v4l2xv)
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
return;
}
if (v4l2xv->idle_id)
g_source_remove (v4l2xv->idle_id);
v4l2xv->idle_id = g_idle_add (idle_refresh, v4l2object);
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
}
/**
/* video_overlay is supported, but we don't have a window.. so create one */
GST_DEBUG_OBJECT (v4l2object->element, "creating window");
- g_mutex_lock (v4l2xv->mutex);
+ g_mutex_lock (&v4l2xv->mutex);
width = XDisplayWidth (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
height = XDisplayHeight (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
XSync (v4l2xv->dpy, FALSE);
- g_mutex_unlock (v4l2xv->mutex);
+ g_mutex_unlock (&v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element, "got window");
GST_DEBUG_OBJECT (ximagesrc,
"destroy image %p as its size changed %dx%d vs current %dx%d",
ximage, meta->width, meta->height, ximagesrc->width, ximagesrc->height);
- g_mutex_lock (ximagesrc->x_lock);
+ g_mutex_lock (&ximagesrc->x_lock);
gst_ximageutil_ximage_destroy (ximagesrc->xcontext, ximage);
- g_mutex_unlock (ximagesrc->x_lock);
+ g_mutex_unlock (&ximagesrc->x_lock);
} else {
/* In that case we can reuse the image and add it to our image pool. */
GST_LOG_OBJECT (ximagesrc, "recycling image %p in pool", ximage);
/* need to increment the refcount again to recycle */
gst_buffer_ref (ximage);
- g_mutex_lock (ximagesrc->pool_lock);
+ g_mutex_lock (&ximagesrc->pool_lock);
GST_BUFFER_FLAGS (GST_BUFFER (ximage)) = 0; /* clear out any flags from the previous use */
ximagesrc->buffer_pool = g_slist_prepend (ximagesrc->buffer_pool, ximage);
- g_mutex_unlock (ximagesrc->pool_lock);
+ g_mutex_unlock (&ximagesrc->pool_lock);
}
}
if (s->xcontext != NULL)
return TRUE;
- g_mutex_lock (s->x_lock);
+ g_mutex_lock (&s->x_lock);
s->xcontext = ximageutil_xcontext_get (GST_ELEMENT (s), name);
if (s->xcontext == NULL) {
- g_mutex_unlock (s->x_lock);
+ g_mutex_unlock (&s->x_lock);
GST_ELEMENT_ERROR (s, RESOURCE, OPEN_READ,
("Could not open X display for reading"),
("NULL returned from getting xcontext"));
#endif
#endif
- g_mutex_unlock (s->x_lock);
+ g_mutex_unlock (&s->x_lock);
if (s->xcontext == NULL)
return FALSE;
#endif
if (src->xcontext) {
- g_mutex_lock (src->x_lock);
+ g_mutex_lock (&src->x_lock);
#ifdef HAVE_XDAMAGE
if (src->damage_copy_gc != None) {
ximageutil_xcontext_clear (src->xcontext);
src->xcontext = NULL;
- g_mutex_unlock (src->x_lock);
+ g_mutex_unlock (&src->x_lock);
}
return TRUE;
GstBuffer *ximage = NULL;
GstMetaXImage *meta;
- g_mutex_lock (ximagesrc->pool_lock);
+ g_mutex_lock (&ximagesrc->pool_lock);
while (ximagesrc->buffer_pool != NULL) {
ximage = ximagesrc->buffer_pool->data;
ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
ximagesrc->buffer_pool);
}
- g_mutex_unlock (ximagesrc->pool_lock);
+ g_mutex_unlock (&ximagesrc->pool_lock);
if (ximage == NULL) {
- GstXContext *xcontext;
- GstCaps *caps = NULL;
-
GST_DEBUG_OBJECT (ximagesrc, "creating image (%dx%d)",
ximagesrc->width, ximagesrc->height);
- g_mutex_lock (ximagesrc->x_lock);
+ g_mutex_lock (&ximagesrc->x_lock);
ximage = gst_ximageutil_ximage_new (ximagesrc->xcontext,
GST_ELEMENT (ximagesrc), ximagesrc->width, ximagesrc->height,
(BufferReturnFunc) (gst_ximage_src_return_buf));
GST_ELEMENT_ERROR (ximagesrc, RESOURCE, WRITE, (NULL),
("could not create a %dx%d ximage", ximagesrc->width,
ximagesrc->height));
- g_mutex_unlock (ximagesrc->x_lock);
+ g_mutex_unlock (&ximagesrc->x_lock);
return NULL;
}
- xcontext = ximagesrc->xcontext;
-
- caps = gst_caps_new_simple ("video/x-raw-rgb",
- "bpp", G_TYPE_INT, xcontext->bpp,
- "depth", G_TYPE_INT, xcontext->depth,
- "endianness", G_TYPE_INT, xcontext->endianness,
- "red_mask", G_TYPE_INT, xcontext->r_mask_output,
- "green_mask", G_TYPE_INT, xcontext->g_mask_output,
- "blue_mask", G_TYPE_INT, xcontext->b_mask_output,
- "width", G_TYPE_INT, ximagesrc->width,
- "height", G_TYPE_INT, ximagesrc->height,
- "framerate", GST_TYPE_FRACTION, ximagesrc->fps_n, ximagesrc->fps_d,
- "pixel-aspect-ratio", GST_TYPE_FRACTION,
- gst_value_get_fraction_numerator (xcontext->par),
- gst_value_get_fraction_denominator (xcontext->par), NULL);
-
- g_mutex_unlock (ximagesrc->x_lock);
-
- gst_caps_unref (caps);
+ g_mutex_unlock (&ximagesrc->x_lock);
}
g_return_val_if_fail (GST_IS_XIMAGE_SRC (ximagesrc), NULL);
static void
gst_ximage_src_clear_bufpool (GstXImageSrc * ximagesrc)
{
- g_mutex_lock (ximagesrc->pool_lock);
+ g_mutex_lock (&ximagesrc->pool_lock);
while (ximagesrc->buffer_pool != NULL) {
GstBuffer *ximage = ximagesrc->buffer_pool->data;
ximagesrc->buffer_pool = g_slist_delete_link (ximagesrc->buffer_pool,
ximagesrc->buffer_pool);
}
- g_mutex_unlock (ximagesrc->pool_lock);
+ g_mutex_unlock (&ximagesrc->pool_lock);
}
static void
ximageutil_xcontext_clear (src->xcontext);
g_free (src->xname);
- g_mutex_free (src->pool_lock);
- g_mutex_free (src->x_lock);
+ g_mutex_clear (&src->pool_lock);
+ g_mutex_clear (&src->x_lock);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
gst_base_src_set_format (GST_BASE_SRC (ximagesrc), GST_FORMAT_TIME);
gst_base_src_set_live (GST_BASE_SRC (ximagesrc), TRUE);
- ximagesrc->pool_lock = g_mutex_new ();
- ximagesrc->x_lock = g_mutex_new ();
+ g_mutex_init (&ximagesrc->pool_lock);
+ g_mutex_init (&ximagesrc->x_lock);
ximagesrc->show_pointer = TRUE;
ximagesrc->use_damage = TRUE;
ximagesrc->startx = 0;
gint64 last_frame_no;
/* Protect X Windows calls */
- GMutex *x_lock;
+ GMutex x_lock;
/* Gathered pool of emitted buffers */
- GMutex *pool_lock;
+ GMutex pool_lock;
GSList *buffer_pool;
/* XFixes and XDamage support */
#include <stdio.h>
#include <gst/check/gstcheck.h>
-#include <gst/audio/multichannel.h>
GST_START_TEST (test_create_and_unref)
{
projects / platform / upstream / gst-plugins-good.git / commitdiff