PROP_LAST
};
+GST_DEBUG_CATEGORY_STATIC (rtsp_client_debug);
+#define GST_CAT_DEFAULT rtsp_client_debug
+
static void gst_rtsp_client_get_property (GObject * object, guint propid,
GValue * value, GParamSpec * pspec);
static void gst_rtsp_client_set_property (GObject * object, guint propid,
tunnels =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
tunnels_lock = g_mutex_new ();
+
+ GST_DEBUG_CATEGORY_INIT (rtsp_client_debug, "rtspclient", 0, "GstRTSPClient");
}
static void
GstRTSPClient *client = GST_RTSP_CLIENT (obj);
GList *walk;
- g_message ("finalize client %p", client);
+ GST_INFO ("finalize client %p", client);
/* remove weak-ref from sessions */
for (walk = client->sessions; walk; walk = g_list_next (walk)) {
} else {
/* we have seen this uri before, used cached media */
media = client->media;
- g_message ("reusing cached media %p", media);
+ GST_INFO ("reusing cached media %p", media);
}
if (media)
sstream = gst_rtsp_session_media_get_stream (media, i);
/* get the transport, if there is no transport configured, skip this stream */
if (!(tr = sstream->trans.transport)) {
- g_message ("stream %d is not configured", i);
+ GST_INFO ("stream %d is not configured", i);
continue;
}
infocount++;
} else {
- g_warning ("RTP-Info cannot be determined for stream %d", i);
+ GST_WARNING ("RTP-Info cannot be determined for stream %d", i);
}
}
static void
do_keepalive (GstRTSPSession * session)
{
- g_message ("keep session %p alive", session);
+ GST_INFO ("keep session %p alive", session);
gst_rtsp_session_touch (session);
}
client_session_finalized (GstRTSPClient * client, GstRTSPSession * session)
{
if (!(client->sessions = g_list_remove (client->sessions, session))) {
- g_message ("all sessions finalized, close the connection");
+ GST_INFO ("all sessions finalized, close the connection");
g_source_destroy ((GSource *) client->watch);
}
}
return;
}
- g_message ("watching session %p", session);
+ GST_INFO ("watching session %p", session);
g_object_weak_ref (G_OBJECT (session), (GWeakNotify) client_session_finalized,
client);
gst_rtsp_message_dump (request);
#endif
- g_message ("client %p: received a request", client);
+ GST_INFO ("client %p: received a request", client);
gst_rtsp_message_parse_request (request, &method, &uristr, &version);
client = GST_RTSP_CLIENT (user_data);
- /* g_message ("client %p: sent a message with cseq %d", client, cseq); */
+ /* GST_INFO ("client %p: sent a message with cseq %d", client, cseq); */
return GST_RTSP_OK;
}
GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
const gchar *tunnelid;
- g_message ("client %p: connection closed", client);
+ GST_INFO ("client %p: connection closed", client);
if ((tunnelid = gst_rtsp_connection_get_tunnelid (client->connection))) {
g_mutex_lock (tunnels_lock);
gchar *str;
str = gst_rtsp_strresult (result);
- g_message ("client %p: received an error %s", client, str);
+ GST_INFO ("client %p: received an error %s", client, str);
g_free (str);
return GST_RTSP_OK;
client = GST_RTSP_CLIENT (user_data);
- g_message ("client %p: tunnel start", client);
+ GST_INFO ("client %p: tunnel start", client);
/* store client in the pending tunnels */
tunnelid = gst_rtsp_connection_get_tunnelid (client->connection);
if (tunnelid == NULL)
goto no_tunnelid;
- g_message ("client %p: inserting %s", client, tunnelid);
+ GST_INFO ("client %p: inserting %s", client, tunnelid);
/* we can't have two clients connecting with the same tunnelid */
g_mutex_lock (tunnels_lock);
/* ERRORS */
no_tunnelid:
{
- g_message ("client %p: no tunnelid provided", client);
+ GST_INFO ("client %p: no tunnelid provided", client);
return GST_RTSP_STS_SERVICE_UNAVAILABLE;
}
tunnel_existed:
{
g_mutex_unlock (tunnels_lock);
- g_message ("client %p: tunnel session %s existed", client, tunnelid);
+ GST_INFO ("client %p: tunnel session %s existed", client, tunnelid);
return GST_RTSP_STS_SERVICE_UNAVAILABLE;
}
}
GstRTSPClient *client = GST_RTSP_CLIENT (user_data);
GstRTSPClient *oclient;
- g_message ("client %p: tunnel complete", client);
+ GST_INFO ("client %p: tunnel complete", client);
/* find previous tunnel */
tunnelid = gst_rtsp_connection_get_tunnelid (client->connection);
g_hash_table_remove (tunnels, tunnelid);
g_mutex_unlock (tunnels_lock);
- g_message ("client %p: found tunnel %p", client, oclient);
+ GST_INFO ("client %p: found tunnel %p", client, oclient);
/* merge the tunnels into the first client */
gst_rtsp_connection_do_tunnel (oclient->connection, client->connection);
/* ERRORS */
no_tunnelid:
{
- g_message ("client %p: no tunnelid provided", client);
+ GST_INFO ("client %p: no tunnelid provided", client);
return GST_RTSP_STS_SERVICE_UNAVAILABLE;
}
no_tunnel:
{
g_mutex_unlock (tunnels_lock);
- g_message ("client %p: tunnel session %s not found", client, tunnelid);
+ GST_INFO ("client %p: tunnel session %s not found", client, tunnelid);
return GST_RTSP_STS_SERVICE_UNAVAILABLE;
}
}
GST_RTSP_CHECK (gst_rtsp_connection_accept (sock, &conn), accept_failed);
url = gst_rtsp_connection_get_url (conn);
- g_message ("added new client %p ip %s:%d", client, url->host, url->port);
+ GST_INFO ("added new client %p ip %s:%d", client, url->host, url->port);
client->connection = conn;
else
context = NULL;
- g_message ("attaching to context %p", context);
+ GST_INFO ("attaching to context %p", context);
client->watchid = gst_rtsp_watch_attach (client->watch, context);
gst_rtsp_watch_unref (client->watch);
{
gchar *str = gst_rtsp_strresult (res);
- g_error ("Could not accept client on server socket %d: %s", sock, str);
+ GST_ERROR ("Could not accept client on server socket %d: %s", sock, str);
g_free (str);
return FALSE;
}
PROP_LAST
};
+GST_DEBUG_CATEGORY (rtsp_media_debug);
+#define GST_CAT_DEFAULT rtsp_media_debug
+
static void gst_rtsp_media_factory_get_property (GObject *object, guint propid,
GValue *value, GParamSpec *pspec);
static void gst_rtsp_media_factory_set_property (GObject *object, guint propid,
klass->construct = default_construct;
klass->configure = default_configure;
klass->create_pipeline = default_create_pipeline;
+
+ GST_DEBUG_CATEGORY_INIT (rtsp_media_debug, "rtspmedia", 0, "GstRTSPMedia");
}
static void
if (key)
g_free (key);
- g_message ("constructed media %p for url %s", media, url->abspath);
+ GST_INFO ("constructed media %p for url %s", media, url->abspath);
return media;
}
if (error != NULL) {
/* a recoverable error was encountered */
- g_warning ("recoverable parsing error: %s", error->message);
+ GST_WARNING ("recoverable parsing error: %s", error->message);
g_error_free (error);
}
return element;
stream = g_new0 (GstRTSPMediaStream, 1);
stream->payloader = elem;
- g_message ("found stream %d with payloader %p", i, elem);
+ GST_INFO ("found stream %d with payloader %p", i, elem);
pad = gst_element_get_static_pad (elem, "src");
if ((elem = gst_bin_get_by_name (GST_BIN (element), name))) {
/* a stream that will dynamically create pads to provide RTP packets */
- g_message ("found dynamic element %d, %p", i, elem);
+ GST_INFO ("found dynamic element %d, %p", i, elem);
media->dynamic = g_list_prepend (media->dynamic, elem);
G_DEFINE_TYPE (GstRTSPMediaMapping, gst_rtsp_media_mapping, G_TYPE_OBJECT);
+GST_DEBUG_CATEGORY_EXTERN (rtsp_media_debug);
+#define GST_CAT_DEFAULT rtsp_media_debug
+
static void gst_rtsp_media_mapping_finalize (GObject * obj);
static GstRTSPMediaFactory * find_media (GstRTSPMediaMapping *mapping, const GstRTSPUrl *url);
if (result)
g_object_ref (result);
- g_message ("found media %p for url abspath %s", result, url->abspath);
+ GST_INFO ("found media %p for url abspath %s", result, url->abspath);
return result;
}
SIGNAL_LAST
};
+GST_DEBUG_CATEGORY_EXTERN (rtsp_media_debug);
+#define GST_CAT_DEFAULT rtsp_media_debug
+
static GQuark ssrc_stream_map_key;
static void gst_rtsp_media_get_property (GObject *object, guint propid,
media = GST_RTSP_MEDIA (obj);
- g_message ("finalize media %p", media);
+ GST_INFO ("finalize media %p", media);
if (media->pipeline) {
unlock_streams (media);
static gpointer
do_loop (GstRTSPMediaClass *klass)
{
- g_message ("enter mainloop");
+ GST_INFO ("enter mainloop");
g_main_loop_run (klass->loop);
- g_message ("exit mainloop");
+ GST_INFO ("exit mainloop");
return NULL;
}
/* get the position */
format = GST_FORMAT_TIME;
if (!gst_element_query_position (media->pipeline, &format, &position)) {
- g_message ("position query failed");
+ GST_INFO ("position query failed");
position = 0;
}
/* get the duration */
format = GST_FORMAT_TIME;
if (!gst_element_query_duration (media->pipeline, &format, &duration)) {
- g_message ("duration query failed");
+ GST_INFO ("duration query failed");
duration = -1;
}
- g_message ("stats: position %"GST_TIME_FORMAT", duration %"GST_TIME_FORMAT,
+ GST_INFO ("stats: position %"GST_TIME_FORMAT", duration %"GST_TIME_FORMAT,
GST_TIME_ARGS (position), GST_TIME_ARGS (duration));
if (position == -1) {
}
if (start != -1 || stop != -1) {
- g_message ("seeking to %"GST_TIME_FORMAT" - %"GST_TIME_FORMAT,
+ GST_INFO ("seeking to %"GST_TIME_FORMAT" - %"GST_TIME_FORMAT,
GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
res = gst_element_seek (media->pipeline, 1.0, GST_FORMAT_TIME,
flags, start_type, start, stop_type, stop);
/* and block for the seek to complete */
- g_message ("done seeking %d", res);
+ GST_INFO ("done seeking %d", res);
gst_element_get_state (media->pipeline, NULL, NULL, -1);
- g_message ("prerolled again");
+ GST_INFO ("prerolled again");
collect_media_stats (media);
}
else {
- g_message ("no seek needed");
+ GST_INFO ("no seek needed");
res = TRUE;
}
/* ERRORS */
not_supported:
{
- g_warning ("seek unit %d not supported", range->unit);
+ GST_WARNING ("seek unit %d not supported", range->unit);
return FALSE;
}
weird_type:
{
- g_warning ("weird range type %d not supported", range->min.type);
+ GST_WARNING ("weird range type %d not supported", range->min.type);
return FALSE;
}
}
gst_caps_unref (oldcaps);
capsstr = gst_caps_to_string (newcaps);
- g_message ("stream %p received caps %p, %s", stream, newcaps, capsstr);
+ GST_INFO ("stream %p received caps %p, %s", stream, newcaps, capsstr);
g_free (capsstr);
}
gchar *sstr;
sstr = gst_structure_to_string (s);
- g_message ("structure: %s", sstr);
+ GST_INFO ("structure: %s", sstr);
g_free (sstr);
}
port = atoi (tmp + 1);
dest = g_strndup (rtcp_from, tmp - rtcp_from);
- g_message ("finding %s:%d", dest, port);
+ GST_INFO ("finding %s:%d", dest, port);
for (walk = stream->transports; walk; walk = g_list_next (walk)) {
GstRTSPMediaTrans *trans = walk->data;
GstStructure *stats;
GstRTSPMediaTrans *trans;
- g_message ("%p: new source %p", stream, source);
+ GST_INFO ("%p: new source %p", stream, source);
/* see if we have a stream to match with the origin of the RTCP packet */
trans = g_object_get_qdata (source, ssrc_stream_map_key);
rtcp_from = gst_structure_get_string (stats, "rtcp-from");
if ((trans = find_transport (stream, rtcp_from))) {
- g_message ("%p: found transport %p for source %p", stream, trans, source);
+ GST_INFO ("%p: found transport %p for source %p", stream, trans, source);
/* keep ref to the source */
trans->rtpsource = source;
gst_structure_free (stats);
}
} else {
- g_message ("%p: source %p for transport %p", stream, source, trans);
+ GST_INFO ("%p: source %p for transport %p", stream, source, trans);
}
}
static void
on_ssrc_sdes (GObject *session, GObject *source, GstRTSPMediaStream *stream)
{
- g_message ("%p: new SDES %p", stream, source);
+ GST_INFO ("%p: new SDES %p", stream, source);
}
static void
trans = g_object_get_qdata (source, ssrc_stream_map_key);
- g_message ("%p: source %p in transport %p is active", stream, source, trans);
+ GST_INFO ("%p: source %p in transport %p is active", stream, source, trans);
if (trans && trans->keep_alive)
trans->keep_alive (trans->ka_user_data);
static void
on_bye_ssrc (GObject *session, GObject *source, GstRTSPMediaStream *stream)
{
- g_message ("%p: source %p bye", stream, source);
+ GST_INFO ("%p: source %p bye", stream, source);
}
static void
{
GstRTSPMediaTrans *trans;
- g_message ("%p: source %p bye timeout", stream, source);
+ GST_INFO ("%p: source %p bye timeout", stream, source);
if ((trans = g_object_get_qdata (source, ssrc_stream_map_key))) {
trans->rtpsource = NULL;
{
GstRTSPMediaTrans *trans;
- g_message ("%p: source %p timeout", stream, source);
+ GST_INFO ("%p: source %p timeout", stream, source);
if ((trans = g_object_get_qdata (source, ssrc_stream_map_key))) {
trans->rtpsource = NULL;
/* ERRORS */
link_failed:
{
- g_warning ("failed to link stream %d", idx);
+ GST_WARNING ("failed to link stream %d", idx);
return FALSE;
}
}
media->buffering = FALSE;
/* if the desired state is playing, go back */
if (media->target_state == GST_STATE_PLAYING) {
- g_message ("Buffering done, setting pipeline to PLAYING");
+ GST_INFO ("Buffering done, setting pipeline to PLAYING");
gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
}
else {
- g_message ("Buffering done");
+ GST_INFO ("Buffering done");
}
} else {
/* buffering busy */
if (media->buffering == FALSE) {
if (media->target_state == GST_STATE_PLAYING) {
/* we were not buffering but PLAYING, PAUSE the pipeline. */
- g_message ("Buffering, setting pipeline to PAUSED ...");
+ GST_INFO ("Buffering, setting pipeline to PAUSED ...");
gst_element_set_state (media->pipeline, GST_STATE_PAUSED);
}
else {
- g_message ("Buffering ...");
+ GST_INFO ("Buffering ...");
}
}
media->buffering = TRUE;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
- g_warning ("%p: got error %s (%s)", media, gerror->message, debug);
+ GST_WARNING ("%p: got error %s (%s)", media, gerror->message, debug);
g_error_free (gerror);
g_free (debug);
break;
gchar *debug;
gst_message_parse_warning (message, &gerror, &debug);
- g_warning ("%p: got warning %s (%s)", media, gerror->message, debug);
+ GST_WARNING ("%p: got warning %s (%s)", media, gerror->message, debug);
g_error_free (gerror);
g_free (debug);
break;
case GST_MESSAGE_STREAM_STATUS:
break;
default:
- g_message ("%p: got message type %s", media, gst_message_type_get_name (type));
+ GST_INFO ("%p: got message type %s", media, gst_message_type_get_name (type));
break;
}
return TRUE;
i = media->streams->len + 1;
- g_message ("pad added %s:%s, stream %d", GST_DEBUG_PAD_NAME (pad), i);
+ GST_INFO ("pad added %s:%s, stream %d", GST_DEBUG_PAD_NAME (pad), i);
stream = g_new0 (GstRTSPMediaStream, 1);
stream->payloader = element;
static void
no_more_pads_cb (GstElement *element, GstRTSPMedia *media)
{
- g_message ("no more pads");
+ GST_INFO ("no more pads");
if (media->fakesink) {
gst_object_ref (media->fakesink);
gst_bin_remove (GST_BIN (media->pipeline), media->fakesink);
gst_element_set_state (media->fakesink, GST_STATE_NULL);
gst_object_unref (media->fakesink);
media->fakesink = NULL;
- g_message ("removed fakesink");
+ GST_INFO ("removed fakesink");
}
}
if (!media->reusable && media->reused)
goto is_reused;
- g_message ("preparing media %p", media);
+ GST_INFO ("preparing media %p", media);
bus = gst_pipeline_get_bus (GST_PIPELINE_CAST (media->pipeline));
break;
case GST_STATE_CHANGE_NO_PREROLL:
/* we need to go to PLAYING */
- g_message ("live media %p", media);
+ GST_INFO ("live media %p", media);
media->is_live = TRUE;
ret = gst_element_set_state (media->pipeline, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE)
/* collect stats about the media */
collect_media_stats (media);
- g_message ("object %p is prerolled", media);
+ GST_INFO ("object %p is prerolled", media);
media->prepared = TRUE;
/* ERRORS */
state_failed:
{
- g_warning ("failed to preroll pipeline");
+ GST_WARNING ("failed to preroll pipeline");
unlock_streams (media);
gst_element_set_state (media->pipeline, GST_STATE_NULL);
return FALSE;
}
is_reused:
{
- g_warning ("can not reuse media %p", media);
+ GST_WARNING ("can not reuse media %p", media);
return FALSE;
}
}
if (!media->prepared)
return TRUE;
- g_message ("unprepare media %p", media);
+ GST_INFO ("unprepare media %p", media);
media->target_state = GST_STATE_NULL;
klass = GST_RTSP_MEDIA_GET_CLASS (media);
add = remove = FALSE;
- g_message ("going to state %s media %p", gst_element_state_get_name (state), media);
+ GST_INFO ("going to state %s media %p", gst_element_state_get_name (state), media);
switch (state) {
case GST_STATE_NULL:
max = trans->client_port.max;
if (add && !tr->active) {
- g_message ("adding %s:%d-%d", dest, min, max);
+ GST_INFO ("adding %s:%d-%d", dest, min, max);
g_signal_emit_by_name (stream->udpsink[0], "add", dest, min, NULL);
g_signal_emit_by_name (stream->udpsink[1], "add", dest, max, NULL);
stream->transports = g_list_prepend (stream->transports, tr);
tr->active = TRUE;
media->active++;
} else if (remove && tr->active) {
- g_message ("removing %s:%d-%d", dest, min, max);
+ GST_INFO ("removing %s:%d-%d", dest, min, max);
g_signal_emit_by_name (stream->udpsink[0], "remove", dest, min, NULL);
g_signal_emit_by_name (stream->udpsink[1], "remove", dest, max, NULL);
stream->transports = g_list_remove (stream->transports, tr);
}
case GST_RTSP_LOWER_TRANS_TCP:
if (add && !tr->active) {
- g_message ("adding TCP %s", trans->destination);
+ GST_INFO ("adding TCP %s", trans->destination);
stream->transports = g_list_prepend (stream->transports, tr);
tr->active = TRUE;
media->active++;
} else if (remove && tr->active) {
- g_message ("removing TCP %s", trans->destination);
+ GST_INFO ("removing TCP %s", trans->destination);
stream->transports = g_list_remove (stream->transports, tr);
tr->active = FALSE;
media->active--;
}
break;
default:
- g_message ("Unknown transport %d", trans->lower_transport);
+ GST_INFO ("Unknown transport %d", trans->lower_transport);
break;
}
}
else
do_state = FALSE;
- g_message ("active %d media %p", media->active, media);
+ GST_INFO ("active %d media %p", media->active, media);
if (do_state && media->target_state != state) {
if (state == GST_STATE_NULL) {
gst_rtsp_media_unprepare (media);
} else {
- g_message ("state %s media %p", gst_element_state_get_name (state), media);
+ GST_INFO ("state %s media %p", gst_element_state_get_name (state), media);
media->target_state = state;
ret = gst_element_set_state (media->pipeline, state);
}
for (i = 0; i < media->streams->len; i++) {
GstRTSPMediaStream *stream;
- g_message ("Removing elements of stream %d from pipeline", i);
+ GST_INFO ("Removing elements of stream %d from pipeline", i);
stream = g_array_index (media->streams, GstRTSPMediaStream *, i);
G_DEFINE_TYPE (GstRTSPServer, gst_rtsp_server, G_TYPE_OBJECT);
+GST_DEBUG_CATEGORY_STATIC (rtsp_server_debug);
+#define GST_CAT_DEFAULT rtsp_server_debug
+
static void gst_rtsp_server_get_property (GObject *object, guint propid,
GValue *value, GParamSpec *pspec);
static void gst_rtsp_server_set_property (GObject *object, guint propid,
GST_TYPE_RTSP_MEDIA_MAPPING, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
klass->accept_client = default_accept_client;
+
+ GST_DEBUG_CATEGORY_INIT (rtsp_server_debug, "rtspserver", 0, "GstRTSPServer");
}
static void
"listened on server socket %d, returning from connection setup",
server->server_sock.fd);
- g_message ("listening on port %d", server->port);
+ GST_INFO_OBJECT (server, "listening on port %d", server->port);
return TRUE;
/* ERRORS */
accept_failed:
{
- g_error ("Could not accept client on server socket %d: %s (%d)",
+ GST_ERROR_OBJECT (server, "Could not accept client on server socket %d: %s (%d)",
server->server_sock.fd, g_strerror (errno), errno);
gst_object_unref (client);
return NULL;
gst_object_unref (client);
}
else {
- g_print ("received unknown event %08x", condition);
+ GST_WARNING_OBJECT (server, "received unknown event %08x", condition);
}
return TRUE;
PROP_LAST
};
+GST_DEBUG_CATEGORY (rtsp_session_debug);
+#define GST_CAT_DEFAULT rtsp_session_debug
+
static void gst_rtsp_session_pool_get_property (GObject *object, guint propid,
GValue *value, GParamSpec *pspec);
static void gst_rtsp_session_pool_set_property (GObject *object, guint propid,
klass->create_session_id = create_session_id;
+ GST_DEBUG_CATEGORY_INIT (rtsp_session_debug, "rtspsession", 0, "GstRTSPSession");
}
static void
/* ERRORS */
no_function:
{
- g_warning ("no create_session_id vmethod in GstRTSPSessionPool %p", pool);
+ GST_WARNING ("no create_session_id vmethod in GstRTSPSessionPool %p", pool);
return NULL;
}
no_session:
{
- g_warning ("can't create session id with GstRTSPSessionPool %p", pool);
+ GST_WARNING ("can't create session id with GstRTSPSessionPool %p", pool);
return NULL;
}
collision:
{
- g_warning ("can't find unique sessionid for GstRTSPSessionPool %p", pool);
+ GST_WARNING ("can't find unique sessionid for GstRTSPSessionPool %p", pool);
g_mutex_unlock (pool->lock);
g_free (id);
return NULL;
}
too_many_sessions:
{
- g_warning ("session pool reached max sessions of %d", pool->max_sessions);
+ GST_WARNING ("session pool reached max sessions of %d", pool->max_sessions);
g_mutex_unlock (pool->lock);
g_free (id);
return NULL;
g_source_get_current_time ((GSource*)psrc, &now);
timeout = gst_rtsp_session_next_timeout (sess, &now);
- g_message ("%p: next timeout: %d", sess, timeout);
+ GST_INFO ("%p: next timeout: %d", sess, timeout);
if (psrc->timeout == -1 || timeout < psrc->timeout)
psrc->timeout = timeout;
}
result = psrc->timeout == 0;
- g_message ("prepare %d, %d", psrc->timeout, result);
+ GST_INFO ("prepare %d, %d", psrc->timeout, result);
return result;
}
static gboolean
gst_pool_source_check (GSource * source)
{
- g_message ("check");
+ GST_INFO ("check");
return gst_pool_source_prepare (source, NULL);
}
GstPoolSource *psrc = (GstPoolSource *) source;
GstRTSPSessionPoolFunc func = (GstRTSPSessionPoolFunc) callback;
- g_message ("dispatch");
+ GST_INFO ("dispatch");
if (func)
res = func (psrc->pool, user_data);
{
GstPoolSource *psrc = (GstPoolSource *) source;
- g_message ("finalize %p", psrc);
+ GST_INFO ("finalize %p", psrc);
g_object_unref (psrc->pool);
psrc->pool = NULL;
PROP_LAST
};
+GST_DEBUG_CATEGORY_EXTERN (rtsp_session_debug);
+#define GST_CAT_DEFAULT rtsp_session_debug
+
static void gst_rtsp_session_get_property (GObject *object, guint propid,
GValue *value, GParamSpec *pspec);
static void gst_rtsp_session_set_property (GObject *object, guint propid,
static void
gst_rtsp_session_free_stream (GstRTSPSessionStream *stream)
{
- g_message ("free session stream %p", stream);
+ GST_INFO ("free session stream %p", stream);
/* remove callbacks now */
gst_rtsp_session_stream_set_callbacks (stream, NULL, NULL, NULL, NULL);
size = media->streams->len;
- g_message ("free session media %p", media);
+ GST_INFO ("free session media %p", media);
gst_rtsp_session_media_set_state (media, GST_STATE_NULL);
session = GST_RTSP_SESSION (obj);
- g_message ("finalize session %p", session);
+ GST_INFO ("finalize session %p", session);
/* free all media */
g_list_foreach (session->medias, (GFunc) gst_rtsp_session_free_media,
sess->medias = g_list_prepend (sess->medias, result);
- g_message ("manage new media %p in session %p", media, result);
+ GST_INFO ("manage new media %p in session %p", media, result);
return result;
}
projects / platform / upstream / gstreamer.git / commitdiff