gst/rtsp-server/rtsp-media-factory-uri.c

   1 /* GStreamer
   2  * Copyright (C) 2008 Wim Taymans <wim.taymans at gmail.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <string.h>
  21
  22 #include "rtsp-media-factory-uri.h"
  23
  24 #define DEFAULT_URI         NULL
  25 #define DEFAULT_USE_GSTPAY  FALSE
  26
  27 enum
  28 {
  29   PROP_0,
  30   PROP_URI,
  31   PROP_USE_GSTPAY,
  32   PROP_LAST
  33 };
  34
  35
  36 #define RAW_VIDEO_CAPS \
  37     "video/x-raw"
  38
  39 #define RAW_AUDIO_CAPS \
  40     "audio/x-raw"
  41
  42 static GstStaticCaps raw_video_caps = GST_STATIC_CAPS (RAW_VIDEO_CAPS);
  43 static GstStaticCaps raw_audio_caps = GST_STATIC_CAPS (RAW_AUDIO_CAPS);
  44
  45 typedef struct
  46 {
  47   GstRTSPMediaFactoryURI *factory;
  48   guint pt;
  49 } FactoryData;
  50
  51 static void
  52 free_data (FactoryData * data)
  53 {
  54   g_object_unref (data->factory);
  55   g_free (data);
  56 }
  57
  58 static const gchar *factory_key = "GstRTSPMediaFactoryURI";
  59
  60 GST_DEBUG_CATEGORY_STATIC (rtsp_media_factory_uri_debug);
  61 #define GST_CAT_DEFAULT rtsp_media_factory_uri_debug
  62
  63 static void gst_rtsp_media_factory_uri_get_property (GObject * object,
  64     guint propid, GValue * value, GParamSpec * pspec);
  65 static void gst_rtsp_media_factory_uri_set_property (GObject * object,
  66     guint propid, const GValue * value, GParamSpec * pspec);
  67 static void gst_rtsp_media_factory_uri_finalize (GObject * obj);
  68
  69 static GstElement *rtsp_media_factory_uri_get_element (GstRTSPMediaFactory *
  70     factory, const GstRTSPUrl * url);
  71
  72 G_DEFINE_TYPE (GstRTSPMediaFactoryURI, gst_rtsp_media_factory_uri,
  73     GST_TYPE_RTSP_MEDIA_FACTORY);
  74
  75 static void
  76 gst_rtsp_media_factory_uri_class_init (GstRTSPMediaFactoryURIClass * klass)
  77 {
  78   GObjectClass *gobject_class;
  79   GstRTSPMediaFactoryClass *mediafactory_class;
  80
  81   gobject_class = G_OBJECT_CLASS (klass);
  82   mediafactory_class = GST_RTSP_MEDIA_FACTORY_CLASS (klass);
  83
  84   gobject_class->get_property = gst_rtsp_media_factory_uri_get_property;
  85   gobject_class->set_property = gst_rtsp_media_factory_uri_set_property;
  86   gobject_class->finalize = gst_rtsp_media_factory_uri_finalize;
  87
  88   /**
  89    * GstRTSPMediaFactoryURI::uri
  90    *
  91    * The uri of the resource that will be served by this factory.
  92    */
  93   g_object_class_install_property (gobject_class, PROP_URI,
  94       g_param_spec_string ("uri", "URI",
  95           "The URI of the resource to stream", DEFAULT_URI,
  96           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  97   /**
  98    * GstRTSPMediaFactoryURI::use-gstpay
  99    *
 100    * Allow the usage of gstpay in order to avoid decoding of compressed formats
 101    * without a payloader.
 102    */
 103   g_object_class_install_property (gobject_class, PROP_USE_GSTPAY,
 104       g_param_spec_boolean ("use-gstpay", "Use gstpay",
 105           "Use the gstpay payloader to avoid decoding", DEFAULT_USE_GSTPAY,
 106           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 107
 108   mediafactory_class->get_element = rtsp_media_factory_uri_get_element;
 109
 110   GST_DEBUG_CATEGORY_INIT (rtsp_media_factory_uri_debug, "rtspmediafactoryuri",
 111       0, "GstRTSPMediaFactoryUri");
 112 }
 113
 114 typedef struct
 115 {
 116   GList *demux;
 117   GList *payload;
 118   GList *decode;
 119 } FilterData;
 120
 121 static gboolean
 122 payloader_filter (GstPluginFeature * feature, FilterData * data)
 123 {
 124   const gchar *klass;
 125   GstElementFactory *fact;
 126   GList **list = NULL;
 127
 128   /* we only care about element factories */
 129   if (G_UNLIKELY (!GST_IS_ELEMENT_FACTORY (feature)))
 130     return FALSE;
 131
 132   if (gst_plugin_feature_get_rank (feature) < GST_RANK_MARGINAL)
 133     return FALSE;
 134
 135   fact = GST_ELEMENT_FACTORY_CAST (feature);
 136
 137   klass = gst_element_factory_get_klass (fact);
 138
 139   if (strstr (klass, "Decoder"))
 140     list = &data->decode;
 141   else if (strstr (klass, "Demux"))
 142     list = &data->demux;
 143   else if (strstr (klass, "Parser") && strstr (klass, "Codec"))
 144     list = &data->demux;
 145   else if (strstr (klass, "Payloader") && strstr (klass, "RTP"))
 146     list = &data->payload;
 147
 148   if (list) {
 149     GST_DEBUG ("adding %s", GST_OBJECT_NAME (fact));
 150     *list = g_list_prepend (*list, fact);
 151   }
 152
 153   return FALSE;
 154 }
 155
 156 static void
 157 gst_rtsp_media_factory_uri_init (GstRTSPMediaFactoryURI * factory)
 158 {
 159   FilterData data = { NULL, NULL, NULL };
 160
 161   factory->uri = g_strdup (DEFAULT_URI);
 162   factory->use_gstpay = DEFAULT_USE_GSTPAY;
 163
 164   /* get the feature list using the filter */
 165   gst_registry_feature_filter (gst_registry_get (), (GstPluginFeatureFilter)
 166       payloader_filter, FALSE, &data);
 167   /* sort */
 168   factory->demuxers =
 169       g_list_sort (data.demux, gst_plugin_feature_rank_compare_func);
 170   factory->payloaders =
 171       g_list_sort (data.payload, gst_plugin_feature_rank_compare_func);
 172   factory->decoders =
 173       g_list_sort (data.decode, gst_plugin_feature_rank_compare_func);
 174
 175   factory->raw_vcaps = gst_static_caps_get (&raw_video_caps);
 176   factory->raw_acaps = gst_static_caps_get (&raw_audio_caps);
 177 }
 178
 179 static void
 180 gst_rtsp_media_factory_uri_finalize (GObject * obj)
 181 {
 182   GstRTSPMediaFactoryURI *factory = GST_RTSP_MEDIA_FACTORY_URI (obj);
 183
 184   g_free (factory->uri);
 185   gst_plugin_feature_list_free (factory->demuxers);
 186   gst_plugin_feature_list_free (factory->payloaders);
 187   gst_plugin_feature_list_free (factory->decoders);
 188   gst_caps_unref (factory->raw_vcaps);
 189   gst_caps_unref (factory->raw_acaps);
 190
 191   G_OBJECT_CLASS (gst_rtsp_media_factory_uri_parent_class)->finalize (obj);
 192 }
 193
 194 static void
 195 gst_rtsp_media_factory_uri_get_property (GObject * object, guint propid,
 196     GValue * value, GParamSpec * pspec)
 197 {
 198   GstRTSPMediaFactoryURI *factory = GST_RTSP_MEDIA_FACTORY_URI (object);
 199
 200   switch (propid) {
 201     case PROP_URI:
 202       g_value_take_string (value, gst_rtsp_media_factory_uri_get_uri (factory));
 203       break;
 204     case PROP_USE_GSTPAY:
 205       g_value_set_boolean (value, factory->use_gstpay);
 206       break;
 207     default:
 208       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 209   }
 210 }
 211
 212 static void
 213 gst_rtsp_media_factory_uri_set_property (GObject * object, guint propid,
 214     const GValue * value, GParamSpec * pspec)
 215 {
 216   GstRTSPMediaFactoryURI *factory = GST_RTSP_MEDIA_FACTORY_URI (object);
 217
 218   switch (propid) {
 219     case PROP_URI:
 220       gst_rtsp_media_factory_uri_set_uri (factory, g_value_get_string (value));
 221       break;
 222     case PROP_USE_GSTPAY:
 223       factory->use_gstpay = g_value_get_boolean (value);
 224       break;
 225     default:
 226       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec);
 227   }
 228 }
 229
 230 /**
 231  * gst_rtsp_media_factory_uri_new:
 232  *
 233  * Create a new #GstRTSPMediaFactoryURI instance.
 234  *
 235  * Returns: a new #GstRTSPMediaFactoryURI object.
 236  */
 237 GstRTSPMediaFactoryURI *
 238 gst_rtsp_media_factory_uri_new (void)
 239 {
 240   GstRTSPMediaFactoryURI *result;
 241
 242   result = g_object_new (GST_TYPE_RTSP_MEDIA_FACTORY_URI, NULL);
 243
 244   return result;
 245 }
 246
 247 /**
 248  * gst_rtsp_media_factory_uri_set_uri:
 249  * @factory: a #GstRTSPMediaFactory
 250  * @uri: the uri the stream
 251  *
 252  * Set the URI of the resource that will be streamed by this factory.
 253  */
 254 void
 255 gst_rtsp_media_factory_uri_set_uri (GstRTSPMediaFactoryURI * factory,
 256     const gchar * uri)
 257 {
 258   g_return_if_fail (GST_IS_RTSP_MEDIA_FACTORY_URI (factory));
 259   g_return_if_fail (uri != NULL);
 260
 261   GST_RTSP_MEDIA_FACTORY_LOCK (factory);
 262   g_free (factory->uri);
 263   factory->uri = g_strdup (uri);
 264   GST_RTSP_MEDIA_FACTORY_UNLOCK (factory);
 265 }
 266
 267 /**
 268  * gst_rtsp_media_factory_uri_get_uri:
 269  * @factory: a #GstRTSPMediaFactory
 270  *
 271  * Get the URI that will provide media for this factory.
 272  *
 273  * Returns: the configured URI. g_free() after usage.
 274  */
 275 gchar *
 276 gst_rtsp_media_factory_uri_get_uri (GstRTSPMediaFactoryURI * factory)
 277 {
 278   gchar *result;
 279
 280   g_return_val_if_fail (GST_IS_RTSP_MEDIA_FACTORY_URI (factory), NULL);
 281
 282   GST_RTSP_MEDIA_FACTORY_LOCK (factory);
 283   result = g_strdup (factory->uri);
 284   GST_RTSP_MEDIA_FACTORY_UNLOCK (factory);
 285
 286   return result;
 287 }
 288
 289 static GstElementFactory *
 290 find_payloader (GstRTSPMediaFactoryURI * urifact, GstCaps * caps)
 291 {
 292   GList *list;
 293   GstElementFactory *factory = NULL;
 294
 295   /* first find a demuxer that can link */
 296   list = gst_element_factory_list_filter (urifact->demuxers, caps,
 297       GST_PAD_SINK, FALSE);
 298
 299   if (list != NULL) {
 300     /* we have a demuxer, try that one first */
 301     gst_plugin_feature_list_free (list);
 302     return NULL;
 303   }
 304
 305   /* no demuxer try a depayloader */
 306   list = gst_element_factory_list_filter (urifact->payloaders, caps,
 307       GST_PAD_SINK, FALSE);
 308
 309   if (list == NULL) {
 310     if (urifact->use_gstpay) {
 311       /* no depayloader or parser/demuxer, use gstpay when allowed */
 312       factory = gst_element_factory_find ("rtpgstpay");
 313     } else {
 314       /* no depayloader, try a decoder, we'll get to a payloader for a decoded
 315        * video or audio format, worst case. */
 316       list = gst_element_factory_list_filter (urifact->decoders, caps,
 317           GST_PAD_SINK, FALSE);
 318
 319       if (list != NULL) {
 320         /* we have a decoder, try that one first */
 321         gst_plugin_feature_list_free (list);
 322         return NULL;
 323       }
 324     }
 325   }
 326
 327   if (list != NULL) {
 328     factory = GST_ELEMENT_FACTORY_CAST (list->data);
 329     g_object_ref (factory);
 330     gst_plugin_feature_list_free (list);
 331   }
 332   return factory;
 333 }
 334
 335 static gboolean
 336 autoplug_continue_cb (GstElement * uribin, GstPad * pad, GstCaps * caps,
 337     GstElement * element)
 338 {
 339   FactoryData *data;
 340   GstElementFactory *factory;
 341
 342   GST_DEBUG ("found pad %s:%s of caps %" GST_PTR_FORMAT,
 343       GST_DEBUG_PAD_NAME (pad), caps);
 344
 345   data = g_object_get_data (G_OBJECT (element), factory_key);
 346
 347   if (!(factory = find_payloader (data->factory, caps)))
 348     goto no_factory;
 349
 350   /* we found a payloader, stop autoplugging so we can plug the
 351    * payloader. */
 352   GST_DEBUG ("found factory %s",
 353       gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));
 354   gst_object_unref (factory);
 355
 356   return FALSE;
 357
 358   /* ERRORS */
 359 no_factory:
 360   {
 361     /* no payloader, continue autoplugging */
 362     GST_DEBUG ("no payloader found");
 363     return TRUE;
 364   }
 365 }
 366
 367 static void
 368 pad_added_cb (GstElement * uribin, GstPad * pad, GstElement * element)
 369 {
 370   GstRTSPMediaFactoryURI *urifact;
 371   FactoryData *data;
 372   GstElementFactory *factory;
 373   GstElement *payloader;
 374   GstCaps *caps;
 375   GstPad *sinkpad, *srcpad, *ghostpad;
 376   GstElement *convert;
 377   gchar *padname;
 378
 379   GST_DEBUG ("added pad %s:%s", GST_DEBUG_PAD_NAME (pad));
 380
 381   /* link the element now and expose the pad */
 382   data = g_object_get_data (G_OBJECT (element), factory_key);
 383   urifact = data->factory;
 384
 385   /* ref to make refcounting easier later */
 386   gst_object_ref (pad);
 387   padname = gst_pad_get_name (pad);
 388
 389   /* get pad caps first, then call get_caps, then fail */
 390   if ((caps = gst_pad_get_current_caps (pad)) == NULL)
 391     if ((caps = gst_pad_query_caps (pad, NULL)) == NULL)
 392       goto no_caps;
 393
 394   /* check for raw caps */
 395   if (gst_caps_can_intersect (caps, urifact->raw_vcaps)) {
 396     /* we have raw video caps, insert converter */
 397     convert = gst_element_factory_make ("videoconvert", NULL);
 398   } else if (gst_caps_can_intersect (caps, urifact->raw_acaps)) {
 399     /* we have raw audio caps, insert converter */
 400     convert = gst_element_factory_make ("audioconvert", NULL);
 401   } else {
 402     convert = NULL;
 403   }
 404
 405   if (convert) {
 406     gst_bin_add (GST_BIN_CAST (element), convert);
 407     gst_element_set_state (convert, GST_STATE_PLAYING);
 408
 409     sinkpad = gst_element_get_static_pad (convert, "sink");
 410     gst_pad_link (pad, sinkpad);
 411     gst_object_unref (sinkpad);
 412
 413     /* unref old pad, we reffed before */
 414     gst_object_unref (pad);
 415
 416     /* continue with new pad and caps */
 417     pad = gst_element_get_static_pad (convert, "src");
 418     if ((caps = gst_pad_get_current_caps (pad)) == NULL)
 419       if ((caps = gst_pad_query_caps (pad, NULL)) == NULL)
 420         goto no_caps;
 421   }
 422
 423   if (!(factory = find_payloader (urifact, caps)))
 424     goto no_factory;
 425
 426   gst_caps_unref (caps);
 427
 428   /* we have a payloader now */
 429   GST_DEBUG ("found payloader factory %s",
 430       gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));
 431
 432   payloader = gst_element_factory_create (factory, NULL);
 433   if (payloader == NULL)
 434     goto no_payloader;
 435
 436   g_object_set (payloader, "pt", data->pt, NULL);
 437   data->pt++;
 438
 439   if (g_object_class_find_property (G_OBJECT_GET_CLASS (payloader),
 440           "buffer-list"))
 441     g_object_set (payloader, "buffer-list", TRUE, NULL);
 442
 443   /* add the payloader to the pipeline */
 444   gst_bin_add (GST_BIN_CAST (element), payloader);
 445   gst_element_set_state (payloader, GST_STATE_PLAYING);
 446
 447   /* link the pad to the sinkpad of the payloader */
 448   sinkpad = gst_element_get_static_pad (payloader, "sink");
 449   gst_pad_link (pad, sinkpad);
 450   gst_object_unref (sinkpad);
 451   gst_object_unref (pad);
 452
 453   /* now expose the srcpad of the payloader as a ghostpad with the same name
 454    * as the uridecodebin pad name. */
 455   srcpad = gst_element_get_static_pad (payloader, "src");
 456   ghostpad = gst_ghost_pad_new (padname, srcpad);
 457   gst_object_unref (srcpad);
 458   g_free (padname);
 459
 460   gst_pad_set_active (ghostpad, TRUE);
 461   gst_element_add_pad (element, ghostpad);
 462
 463   return;
 464
 465   /* ERRORS */
 466 no_caps:
 467   {
 468     GST_WARNING ("could not get caps from pad");
 469     g_free (padname);
 470     gst_object_unref (pad);
 471     return;
 472   }
 473 no_factory:
 474   {
 475     GST_DEBUG ("no payloader found");
 476     g_free (padname);
 477     gst_caps_unref (caps);
 478     gst_object_unref (pad);
 479     return;
 480   }
 481 no_payloader:
 482   {
 483     GST_ERROR ("could not create payloader from factory");
 484     g_free (padname);
 485     gst_caps_unref (caps);
 486     gst_object_unref (pad);
 487     return;
 488   }
 489 }
 490
 491 static void
 492 no_more_pads_cb (GstElement * uribin, GstElement * element)
 493 {
 494   GST_DEBUG ("no-more-pads");
 495   gst_element_no_more_pads (element);
 496 }
 497
 498 static GstElement *
 499 rtsp_media_factory_uri_get_element (GstRTSPMediaFactory * factory,
 500     const GstRTSPUrl * url)
 501 {
 502   GstElement *topbin, *element, *uribin;
 503   GstRTSPMediaFactoryURI *urifact;
 504   FactoryData *data;
 505
 506   urifact = GST_RTSP_MEDIA_FACTORY_URI_CAST (factory);
 507
 508   GST_LOG ("creating element");
 509
 510   topbin = gst_bin_new ("GstRTSPMediaFactoryURI");
 511   g_assert (topbin != NULL);
 512
 513   /* our bin will dynamically expose payloaded pads */
 514   element = gst_bin_new ("dynpay0");
 515   g_assert (element != NULL);
 516
 517   uribin = gst_element_factory_make ("uridecodebin", "uribin");
 518   if (uribin == NULL)
 519     goto no_uridecodebin;
 520
 521   g_object_set (uribin, "uri", urifact->uri, NULL);
 522
 523   /* keep factory data around */
 524   data = g_new0 (FactoryData, 1);
 525   data->factory = g_object_ref (factory);
 526   data->pt = 96;
 527
 528   g_object_set_data_full (G_OBJECT (element), factory_key,
 529       data, (GDestroyNotify) free_data);
 530
 531   /* connect to the signals */
 532   g_signal_connect (uribin, "autoplug-continue",
 533       (GCallback) autoplug_continue_cb, element);
 534   g_signal_connect (uribin, "pad-added", (GCallback) pad_added_cb, element);
 535   g_signal_connect (uribin, "no-more-pads", (GCallback) no_more_pads_cb,
 536       element);
 537
 538   gst_bin_add (GST_BIN_CAST (element), uribin);
 539   gst_bin_add (GST_BIN_CAST (topbin), element);
 540
 541   return topbin;
 542
 543 no_uridecodebin:
 544   {
 545     g_critical ("can't create uridecodebin element");
 546     g_object_unref (element);
 547     return NULL;
 548   }
 549 }