mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-10-06 10:42:22 +00:00
df08a2dd9e
Use a GSequence to keep track of the mount points. Match a URL to the longest matching registered mount point. This should be the URL to perform aggreagate control and the remainder is the stream specific control part. Add some unit tests for this.
349 lines
8.9 KiB
C
349 lines
8.9 KiB
C
/* GStreamer
|
|
* Copyright (C) 2008 Wim Taymans <wim.taymans at gmail.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <string.h>
|
|
|
|
#include "rtsp-mount-points.h"
|
|
|
|
#define GST_RTSP_MOUNT_POINTS_GET_PRIVATE(obj) \
|
|
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTSP_MOUNT_POINTS, GstRTSPMountPointsPrivate))
|
|
|
|
typedef struct
|
|
{
|
|
gchar *path;
|
|
gint len;
|
|
GstRTSPMediaFactory *factory;
|
|
} DataItem;
|
|
|
|
static DataItem *
|
|
data_item_new (gchar * path, gint len, GstRTSPMediaFactory * factory)
|
|
{
|
|
DataItem *item;
|
|
|
|
item = g_slice_alloc (sizeof (DataItem));
|
|
item->path = path;
|
|
item->len = len;
|
|
item->factory = factory;
|
|
|
|
return item;
|
|
}
|
|
|
|
static void
|
|
data_item_free (gpointer data)
|
|
{
|
|
DataItem *item = data;
|
|
|
|
g_free (item->path);
|
|
g_object_unref (item->factory);
|
|
g_slice_free1 (sizeof (DataItem), item);
|
|
}
|
|
|
|
static void
|
|
data_item_dump (gconstpointer a, gpointer prefix)
|
|
{
|
|
const DataItem *item = a;
|
|
|
|
GST_DEBUG ("%s%s %p\n", (gchar *) prefix, item->path, item->factory);
|
|
}
|
|
|
|
static gint
|
|
data_item_compare (gconstpointer a, gconstpointer b, gpointer user_data)
|
|
{
|
|
const DataItem *item1 = a, *item2 = b;
|
|
gint res;
|
|
|
|
res = g_strcmp0 (item1->path, item2->path);
|
|
|
|
return res;
|
|
}
|
|
|
|
struct _GstRTSPMountPointsPrivate
|
|
{
|
|
GMutex lock;
|
|
GSequence *mounts; /* protected by lock */
|
|
gboolean dirty;
|
|
};
|
|
|
|
G_DEFINE_TYPE (GstRTSPMountPoints, gst_rtsp_mount_points, G_TYPE_OBJECT);
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (rtsp_media_debug);
|
|
#define GST_CAT_DEFAULT rtsp_media_debug
|
|
|
|
static void gst_rtsp_mount_points_finalize (GObject * obj);
|
|
|
|
static GstRTSPMediaFactory *find_factory (GstRTSPMountPoints * mounts,
|
|
const GstRTSPUrl * url);
|
|
|
|
static void
|
|
gst_rtsp_mount_points_class_init (GstRTSPMountPointsClass * klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
|
|
g_type_class_add_private (klass, sizeof (GstRTSPMountPointsPrivate));
|
|
|
|
gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
gobject_class->finalize = gst_rtsp_mount_points_finalize;
|
|
|
|
klass->find_factory = find_factory;
|
|
|
|
GST_DEBUG_CATEGORY_INIT (rtsp_media_debug, "rtspmountpoints", 0,
|
|
"GstRTSPMountPoints");
|
|
}
|
|
|
|
static void
|
|
gst_rtsp_mount_points_init (GstRTSPMountPoints * mounts)
|
|
{
|
|
GstRTSPMountPointsPrivate *priv = GST_RTSP_MOUNT_POINTS_GET_PRIVATE (mounts);
|
|
|
|
GST_DEBUG_OBJECT (mounts, "created");
|
|
|
|
mounts->priv = priv;
|
|
|
|
g_mutex_init (&priv->lock);
|
|
priv->mounts = g_sequence_new (data_item_free);
|
|
priv->dirty = FALSE;
|
|
}
|
|
|
|
static void
|
|
gst_rtsp_mount_points_finalize (GObject * obj)
|
|
{
|
|
GstRTSPMountPoints *mounts = GST_RTSP_MOUNT_POINTS (obj);
|
|
GstRTSPMountPointsPrivate *priv = mounts->priv;
|
|
|
|
GST_DEBUG_OBJECT (mounts, "finalized");
|
|
|
|
g_sequence_free (priv->mounts);
|
|
g_mutex_clear (&priv->lock);
|
|
|
|
G_OBJECT_CLASS (gst_rtsp_mount_points_parent_class)->finalize (obj);
|
|
}
|
|
|
|
/**
|
|
* gst_rtsp_mount_points_new:
|
|
*
|
|
* Make a new mount points object.
|
|
*
|
|
* Returns: a new #GstRTSPMountPoints
|
|
*/
|
|
GstRTSPMountPoints *
|
|
gst_rtsp_mount_points_new (void)
|
|
{
|
|
GstRTSPMountPoints *result;
|
|
|
|
result = g_object_new (GST_TYPE_RTSP_MOUNT_POINTS, NULL);
|
|
|
|
return result;
|
|
}
|
|
|
|
static GstRTSPMediaFactory *
|
|
find_factory (GstRTSPMountPoints * mounts, const GstRTSPUrl * url)
|
|
{
|
|
g_return_val_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts), NULL);
|
|
g_return_val_if_fail (url != NULL, NULL);
|
|
|
|
return gst_rtsp_mount_points_match (mounts, url->abspath, NULL);
|
|
}
|
|
|
|
/**
|
|
* gst_rtsp_mount_points_find_factory:
|
|
* @mounts: a #GstRTSPMountPoints
|
|
* @url: a url
|
|
*
|
|
* Find the #GstRTSPMediaFactory for @url. The default implementation of this object
|
|
* will use the media factory added with gst_rtsp_mount_points_add_factory ().
|
|
*
|
|
* Returns: (transfer full): the #GstRTSPMediaFactory for @url. g_object_unref() after usage.
|
|
*/
|
|
GstRTSPMediaFactory *
|
|
gst_rtsp_mount_points_find_factory (GstRTSPMountPoints * mounts,
|
|
const GstRTSPUrl * url)
|
|
{
|
|
GstRTSPMediaFactory *result;
|
|
GstRTSPMountPointsClass *klass;
|
|
|
|
g_return_val_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts), NULL);
|
|
g_return_val_if_fail (url != NULL, NULL);
|
|
|
|
klass = GST_RTSP_MOUNT_POINTS_GET_CLASS (mounts);
|
|
|
|
if (klass->find_factory)
|
|
result = klass->find_factory (mounts, url);
|
|
else
|
|
result = NULL;
|
|
|
|
return result;
|
|
}
|
|
|
|
static gboolean
|
|
has_prefix (DataItem * str, DataItem * prefix)
|
|
{
|
|
/* prefix needs to be smaller than str */
|
|
if (str->len < prefix->len)
|
|
return FALSE;
|
|
|
|
/* if str is larger, it there should be a / following the prefix */
|
|
if (str->len > prefix->len && str->path[prefix->len] != '/')
|
|
return FALSE;
|
|
|
|
return strncmp (str->path, prefix->path, prefix->len) == 0;
|
|
}
|
|
|
|
/**
|
|
* gst_rtsp_mount_points_match:
|
|
* @mounts: a #GstRTSPMountPoints
|
|
* @path: a mount point
|
|
* @matched: the amount of @path matched
|
|
*
|
|
* Find the factory in @mounts that has the longest match with @path.
|
|
*
|
|
* If @matched is NULL, @path willt match the factory exactly otherwise
|
|
* the amount of characters that matched is returned in @matched.
|
|
*
|
|
* Returns: (transfer full): the #GstRTSPMediaFactory for @path.
|
|
* g_object_unref() after usage.
|
|
*/
|
|
GstRTSPMediaFactory *
|
|
gst_rtsp_mount_points_match (GstRTSPMountPoints * mounts,
|
|
const gchar * path, gint * matched)
|
|
{
|
|
GstRTSPMountPointsPrivate *priv;
|
|
GstRTSPMediaFactory *result = NULL;
|
|
GSequenceIter *iter, *best;
|
|
DataItem item, *ritem;
|
|
|
|
g_return_val_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts), NULL);
|
|
g_return_val_if_fail (path != NULL, NULL);
|
|
|
|
priv = mounts->priv;
|
|
|
|
item.path = (gchar *) path;
|
|
item.len = strlen (path);
|
|
|
|
g_mutex_lock (&priv->lock);
|
|
if (priv->dirty) {
|
|
g_sequence_sort (priv->mounts, data_item_compare, mounts);
|
|
g_sequence_foreach (priv->mounts, (GFunc) data_item_dump, "sort :");
|
|
priv->dirty = FALSE;
|
|
}
|
|
|
|
/* find the location of the media in the hashtable we only use the absolute
|
|
* path of the uri to find a media factory. If the factory depends on other
|
|
* properties found in the url, this method should be overridden. */
|
|
iter = g_sequence_get_begin_iter (priv->mounts);
|
|
best = NULL;
|
|
while (!g_sequence_iter_is_end (iter)) {
|
|
ritem = g_sequence_get (iter);
|
|
|
|
data_item_dump (ritem, "inspect: ");
|
|
|
|
if (best == NULL) {
|
|
if (has_prefix (&item, ritem)) {
|
|
data_item_dump (ritem, "prefix: ");
|
|
best = iter;
|
|
}
|
|
} else {
|
|
if (!has_prefix (&item, ritem))
|
|
break;
|
|
|
|
best = iter;
|
|
data_item_dump (ritem, "new best: ");
|
|
}
|
|
iter = g_sequence_iter_next (iter);
|
|
}
|
|
if (best) {
|
|
ritem = g_sequence_get (best);
|
|
data_item_dump (ritem, "result: ");
|
|
if (matched || ritem->len == item.len) {
|
|
result = g_object_ref (ritem->factory);
|
|
if (matched)
|
|
*matched = ritem->len;
|
|
}
|
|
}
|
|
g_mutex_unlock (&priv->lock);
|
|
|
|
GST_INFO ("found media factory %p for path %s", result, path);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* gst_rtsp_mount_points_add_factory:
|
|
* @mounts: a #GstRTSPMountPoints
|
|
* @path: a mount point
|
|
* @factory: (transfer full): a #GstRTSPMediaFactory
|
|
*
|
|
* Attach @factory to the mount point @path in @mounts.
|
|
*
|
|
* @path is of the form (/node)+. Any previous mount point will be freed.
|
|
*
|
|
* Ownership is taken of the reference on @factory so that @factory should not be
|
|
* used after calling this function.
|
|
*/
|
|
void
|
|
gst_rtsp_mount_points_add_factory (GstRTSPMountPoints * mounts,
|
|
const gchar * path, GstRTSPMediaFactory * factory)
|
|
{
|
|
GstRTSPMountPointsPrivate *priv;
|
|
DataItem *item;
|
|
|
|
g_return_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts));
|
|
g_return_if_fail (GST_IS_RTSP_MEDIA_FACTORY (factory));
|
|
g_return_if_fail (path != NULL);
|
|
|
|
priv = mounts->priv;
|
|
|
|
item = data_item_new (g_strdup (path), strlen (path), factory);
|
|
|
|
g_mutex_lock (&priv->lock);
|
|
g_sequence_append (priv->mounts, item);
|
|
priv->dirty = TRUE;
|
|
g_mutex_unlock (&priv->lock);
|
|
}
|
|
|
|
/**
|
|
* gst_rtsp_mount_points_remove_factory:
|
|
* @mounts: a #GstRTSPMountPoints
|
|
* @path: a mount point
|
|
*
|
|
* Remove the #GstRTSPMediaFactory associated with @path in @mounts.
|
|
*/
|
|
void
|
|
gst_rtsp_mount_points_remove_factory (GstRTSPMountPoints * mounts,
|
|
const gchar * path)
|
|
{
|
|
GstRTSPMountPointsPrivate *priv;
|
|
DataItem item;
|
|
GSequenceIter *iter;
|
|
|
|
g_return_if_fail (GST_IS_RTSP_MOUNT_POINTS (mounts));
|
|
g_return_if_fail (path != NULL);
|
|
|
|
priv = mounts->priv;
|
|
|
|
item.path = (gchar *) path;
|
|
|
|
g_mutex_lock (&priv->lock);
|
|
iter = g_sequence_lookup (priv->mounts, &item, data_item_compare, mounts);
|
|
if (iter) {
|
|
g_sequence_remove (iter);
|
|
priv->dirty = TRUE;
|
|
}
|
|
g_mutex_unlock (&priv->lock);
|
|
}
|