gst-convenience: Change GstDiscoverer namespace
[gupnp:gupnp-dlna.git] / libgupnp-dlna / gupnp-dlna-discoverer.c
1 /*
2  * Copyright (C) 2010 Nokia Corporation.
3  *
4  * Authors: Arun Raghavan <arun.raghavan@collabora.co.uk>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #include "gupnp-dlna-discoverer.h"
23 #include "gupnp-dlna-marshal.h"
24 #include "gupnp-dlna-load.h"
25
26 /**
27  * SECTION:gupnp-dlna-discoverer
28  * @short_description: Utility API for discovering DLNA profile/mime type and
29  * other metadata for given media.
30  *
31  * The GUPnPDLNADiscoverer object provides a light-weight wrapper over the
32  * #GstDiscoverer API. The latter provides a simple interface to discover
33  * media metadata given a URI. GUPnPDLNADiscoverer extends this API to also
34  * provide a DLNA profile name and mime type for the media.
35  *
36  * The API provided corresponds very closely to the API provided by
37  * #GstDiscoverer - both synchronous and asynchronous discovery of metadata
38  * are possible.
39  *
40  * The asynchronous mode requires a running #GMainLoop in the default
41  * #GMainContext, where one connects to the various signals, appends the
42  * URIs to be processed and then asks for the discovery to begin.
43  */
44 enum {
45         DONE,
46         SIGNAL_LAST
47 };
48
49 static guint signals[SIGNAL_LAST];
50
51
52 G_DEFINE_TYPE (GUPnPDLNADiscoverer, \
53                gupnp_dlna_discoverer, \
54                GST_TYPE_DISCOVERER_INTERNAL)
55
56 #define GET_PRIVATE(o) \
57   (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
58                                 GUPNP_TYPE_DLNA_DISCOVERER, \
59                                 GUPnPDLNADiscovererPrivate))
60
61 typedef struct _GUPnPDLNADiscovererPrivate GUPnPDLNADiscovererPrivate;
62
63 struct _GUPnPDLNADiscovererPrivate {
64         gboolean  relaxed_mode;
65         gboolean  extended_mode;
66 };
67
68 enum {
69         PROP_0,
70         PROP_DLNA_RELAXED_MODE,
71         PROP_DLNA_EXTENDED_MODE,
72 };
73
74 static void
75 gupnp_dlna_discoverer_set_property (GObject      *object,
76                                     guint        property_id,
77                                     const GValue *value,
78                                     GParamSpec   *pspec)
79 {
80         GUPnPDLNADiscoverer *self = GUPNP_DLNA_DISCOVERER (object);
81         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
82
83         switch (property_id) {
84                 case PROP_DLNA_RELAXED_MODE:
85                         priv->relaxed_mode = g_value_get_boolean (value);
86                         break;
87
88                 case PROP_DLNA_EXTENDED_MODE:
89                         priv->extended_mode = g_value_get_boolean (value);
90                         break;
91
92                 default:
93                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
94                                                            property_id,
95                                                            pspec);
96                         break;
97         }
98 }
99
100 static void
101 gupnp_dlna_discoverer_get_property (GObject    *object,
102                                     guint      property_id,
103                                     GValue     *value,
104                                     GParamSpec *pspec)
105 {
106         GUPnPDLNADiscoverer *self = GUPNP_DLNA_DISCOVERER (object);
107         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
108
109         switch (property_id) {
110                 case PROP_DLNA_RELAXED_MODE:
111                         g_value_set_boolean (value, priv->relaxed_mode);
112                         break;
113
114                 case PROP_DLNA_EXTENDED_MODE:
115                         g_value_set_boolean (value, priv->extended_mode);
116                         break;
117
118                 default:
119                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object,
120                                                            property_id,
121                                                            pspec);
122                         break;
123         }
124 }
125
126 static void
127 gupnp_dlna_discoverer_dispose (GObject *object)
128 {
129         G_OBJECT_CLASS (gupnp_dlna_discoverer_parent_class)->dispose (object);
130 }
131
132 static void
133 gupnp_dlna_discoverer_finalize (GObject *object)
134 {
135         G_OBJECT_CLASS (gupnp_dlna_discoverer_parent_class)->finalize (object);
136 }
137
138 static void gupnp_dlna_discovered_cb (GstDiscovererInternal    *discoverer,
139                                       GstDiscovererInformation *info,
140                                       GError                   *err)
141 {
142         GUPnPDLNAInformation *dlna = NULL;
143         GUPnPDLNADiscovererClass *klass = GUPNP_DLNA_DISCOVERER_GET_CLASS (discoverer);
144         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (GUPNP_DLNA_DISCOVERER (discoverer));
145         gboolean relaxed = priv->relaxed_mode;
146         gboolean extended = priv->extended_mode;
147
148         if (info)
149                 dlna = gupnp_dlna_information_new_from_discoverer_info (info,
150                                                  klass->profiles_list [relaxed][extended]);
151
152         g_signal_emit (GUPNP_DLNA_DISCOVERER (discoverer),
153                        signals[DONE], 0, dlna, err);
154
155         if (dlna)
156                 g_object_unref (dlna);
157 }
158
159 static void
160 gupnp_dlna_discoverer_class_init (GUPnPDLNADiscovererClass *klass)
161 {
162         GObjectClass *object_class = G_OBJECT_CLASS (klass);
163         GParamSpec *pspec;
164
165         g_type_class_add_private (klass, sizeof (GUPnPDLNADiscovererPrivate));
166
167         object_class->get_property = gupnp_dlna_discoverer_get_property;
168         object_class->set_property = gupnp_dlna_discoverer_set_property;
169         object_class->dispose = gupnp_dlna_discoverer_dispose;
170         object_class->finalize = gupnp_dlna_discoverer_finalize;
171
172         /**
173          * GUPnPDLNADiscoverer::relaxed-mode:
174          * @relaxed_mode: setting to true will enable relaxed mode
175          *
176          * The current release does not support relaxed mode yet
177          */
178         pspec = g_param_spec_boolean ("relaxed-mode",
179                                       "Relaxed mode property",
180                                       "Indicates that profile matching should"
181                                       "be strictly compliant with the DLNA "
182                                       "specification",
183                                       FALSE,
184                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
185         g_object_class_install_property (object_class,
186                                          PROP_DLNA_RELAXED_MODE,
187                                          pspec);
188
189         /**
190          * GUPnPDLNADiscoverer::extended-mode:
191          * @extended: setting true will enable extended profile support
192          *
193          * The current release does not support extended mode yet
194          */
195         pspec = g_param_spec_boolean ("extended-mode",
196                                       "Extended mode property",
197                                       "Indicates support for profiles that are "
198                                       "not part of the DLNA specification",
199                                       FALSE,
200                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
201         g_object_class_install_property (object_class,
202                                          PROP_DLNA_EXTENDED_MODE,
203                                          pspec);
204
205         /**
206          * GUPnPDLNADiscoverer::done:
207          * @discoverer: the #GUPnPDLNADiscoverer
208          * @dlna: the results as #GUPnPDLNAInformation
209          * @err: contains details of the error if discovery fails, else is NULL
210          *
211          * Will be emitted when all information on a URI could be discovered.
212          *
213          * The reciever must unref @dlna with when done using it.
214          */
215         signals[DONE] =
216                 g_signal_new ("done", G_TYPE_FROM_CLASS (klass),
217                               G_SIGNAL_RUN_LAST,
218                               G_STRUCT_OFFSET (GUPnPDLNADiscovererClass, done),
219                               NULL, NULL,
220                               gupnp_dlna_marshal_VOID__OBJECT_BOXED,
221                               G_TYPE_NONE, 2, GUPNP_TYPE_DLNA_INFORMATION,
222                               GST_TYPE_G_ERROR);
223
224         /* Load DLNA profiles from disk */
225         if (g_type_from_name ("GstElement")) {
226                 klass->profiles_list [0][0]
227                         = gupnp_dlna_load_profiles_from_disk (FALSE,
228                                                               FALSE);
229                 klass->profiles_list [0][1]
230                         = gupnp_dlna_load_profiles_from_disk (FALSE,
231                                                               TRUE);
232                 klass->profiles_list [1][0]
233                         = gupnp_dlna_load_profiles_from_disk (TRUE,
234                                                               FALSE);
235                 klass->profiles_list [1][1]
236                         = gupnp_dlna_load_profiles_from_disk (TRUE,
237                                                               TRUE);
238         } else {
239                 klass->profiles_list [0][0] = NULL;
240                 klass->profiles_list [0][1] = NULL;
241                 klass->profiles_list [1][0] = NULL;
242                 klass->profiles_list [1][1] = NULL;
243                 g_warning ("GStreamer has not yet been initialised. You need "
244                            "to call gst_init()/gst_init_check() for discovery "
245                            "to work.");
246         }
247 }
248
249 static void
250 gupnp_dlna_discoverer_init (GUPnPDLNADiscoverer *self)
251 {
252         g_signal_connect (&self->parent,
253                           "discovered",
254                           G_CALLBACK (gupnp_dlna_discovered_cb),
255                           NULL);
256 }
257
258 /**
259  * gupnp_dlna_discoverer_new:
260  * @timeout: default discovery timeout, in nanoseconds
261  *
262  * Creates a new #GUPnPDLNADiscoverer object with the given default timeout
263  * value.
264  *
265  * Returns: A new #GUPnPDLNADiscoverer object.
266  */
267 GUPnPDLNADiscoverer*
268 gupnp_dlna_discoverer_new (GstClockTime timeout,
269                            gboolean     relaxed_mode,
270                            gboolean     extended_mode)
271 {
272         return g_object_new (GUPNP_TYPE_DLNA_DISCOVERER,
273                              "timeout", timeout,
274                              "relaxed-mode", relaxed_mode,
275                              "extended-mode", extended_mode,
276                              NULL);
277 }
278
279 /* Asynchronous API */
280
281 /**
282  * gupnp_dlna_discoverer_start:
283  * @discoverer: #GUPnPDLNADiscoverer object to start discovery on
284  *
285  * Allows asynchronous discovery of URIs to begin.
286  */
287
288 /**
289  * gupnp_dlna_discoverer_stop:
290  * @discoverer: #GUPnPDLNADiscoverer object to stop discovery on
291  *
292  * Stops asynchronous discovery of URIs.
293  */
294
295 /**
296  * gupnp_dlna_discoverer_discover_uri:
297  * @discoverer: #GUPnPDLNADiscoverer object to use for discovery
298  * @uri: URI to gather metadata for
299  *
300  * Queues @uri for metadata discovery. When discovery is completed, the
301  * "discovered" signal is emitted on @discoverer.
302  *
303  * Returns: TRUE if @uri was successfully queued, FALSE otherwise.
304  */
305 gboolean
306 gupnp_dlna_discoverer_discover_uri (GUPnPDLNADiscoverer *discoverer, gchar *uri)
307 {
308         return gst_discoverer_internal_append_uri (
309                         GST_DISCOVERER_INTERNAL (discoverer), uri);
310 }
311
312 /* Synchronous API */
313
314 /**
315  * gupnp_dlna_discoverer_discover_uri_sync:
316  * @discoverer: #GUPnPDLNADiscoverer object to use for discovery
317  * @uri: URI to gather metadata for
318  * @err: contains details of the error if discovery fails, else is NULL
319  *
320  * Synchronously gathers metadata for @uri.
321  *
322  * Returns: a #GUPnPDLNAInformation with the metadata for @uri on success, NULL
323  *          otherwise
324  */
325 GUPnPDLNAInformation *
326 gupnp_dlna_discoverer_discover_uri_sync (GUPnPDLNADiscoverer *discoverer,
327                                          gchar               *uri,
328                                          GError              **err)
329 {
330         GstDiscovererInformation *info;
331         GUPnPDLNADiscovererClass *klass = GUPNP_DLNA_DISCOVERER_GET_CLASS (discoverer);
332         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (discoverer);
333         gboolean relaxed = priv->relaxed_mode;
334         gboolean extended = priv->extended_mode;
335
336         info = gst_discoverer_internal_discover_uri (
337                         GST_DISCOVERER_INTERNAL (discoverer),
338                         uri,
339                         err);
340
341         if (info)
342                 return gupnp_dlna_information_new_from_discoverer_info (info,
343                                      klass->profiles_list [relaxed][extended]);
344
345         return NULL;
346 }
347
348 /**
349  * gupnp_dlna_discoverer_get_profile:
350  * @self: The #GUPnPDLNADiscoverer object
351  * @name: The name of the DLNA profile to be retrieved
352  *
353  * Given @name, this finds the corresponding DLNA profile information (stored
354  * as a #GUPnPDLNAProfile).
355  *
356  * Returns: a #GUPnPDLNAProfile on success, NULL otherwise.
357  **/
358 GUPnPDLNAProfile *
359 gupnp_dlna_discoverer_get_profile (GUPnPDLNADiscoverer *self,
360                                    const gchar         *name)
361 {
362         GList *i;
363         GUPnPDLNADiscovererClass *klass;
364         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
365         gboolean relaxed = priv->relaxed_mode;
366         gboolean extended = priv->extended_mode;
367
368         g_return_val_if_fail (self != NULL, NULL);
369         klass = GUPNP_DLNA_DISCOVERER_GET_CLASS (self);
370
371         for (i = klass->profiles_list [relaxed][extended];
372              i != NULL;
373              i = i->next) {
374                 GUPnPDLNAProfile *profile = (GUPnPDLNAProfile *) i->data;
375
376                 if (g_str_equal (gupnp_dlna_profile_get_name (profile), name)) {
377                         g_object_ref (profile);
378                         return profile;
379                 }
380         }
381
382         return NULL;
383 }
384
385 /**
386  * gupnp_dlna_discoverer_list_profiles:
387  * @self: The #GUPnPDLNADiscoverer whose profile list is required
388  *
389  * Retuns a list of the all the DLNA profiles supported by @self.
390  *
391  * Returns: a #GList of #GUPnPDLNAProfile on success, NULL otherwise.
392  **/
393 const GList *
394 gupnp_dlna_discoverer_list_profiles (GUPnPDLNADiscoverer *self)
395 {
396         GUPnPDLNADiscovererClass *klass;
397         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
398         gboolean relaxed = priv->relaxed_mode;
399         gboolean extended = priv->extended_mode;
400
401         g_return_val_if_fail (self != NULL, NULL);
402
403         klass = GUPNP_DLNA_DISCOVERER_GET_CLASS (self);
404
405         return klass->profiles_list [relaxed][extended];
406 }
407
408 /**
409  * gupnp_dlna_discoverer_get_relaxed_mode:
410  * @self: The #GUPnPDLNADiscoverer object
411  *
412  * Returns: true if relaxed mode is set and false otherwise
413  */
414 gboolean
415 gupnp_dlna_discoverer_get_relaxed_mode (GUPnPDLNADiscoverer *self)
416 {
417         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
418         return priv->relaxed_mode;
419 }
420
421 /**
422  * gupnp_dlna_discoverer_get_extended_mode:
423  * @self: The #GUPnPDLNADiscoverer object
424  *
425  * Returns: true if application is using extended mode and false otherwise
426  */
427 gboolean
428 gupnp_dlna_discoverer_get_extended_mode (GUPnPDLNADiscoverer *self)
429 {
430         GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
431         return priv->extended_mode;
432 }