doc: Update NEWS for 0.4.1
[gupnp:gupnp-dlna.git] / tools / gupnp-dlna-info.c
1 /* GUPnPDLNA
2  * gupnp-dlna-info.c
3  *
4  * Copyright (C) 2010 Nokia Corporation
5  * Copyright (C) 2010 Collabora Multimedia
6  *
7  * Authors: Parthasarathi Susarla <partha.susarla@collabora.co.uk>
8  *
9  * Based on 'gst-discoverer.c' by
10  * Edward Hervey <edward.hervey@collabora.co.uk>
11  *
12  * This library is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2 of the License, or (at your option) any later version.
16  *
17  * This library is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with this library; if not, write to the
24  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25  * Boston, MA 02111-1307, USA.
26  */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <stdlib.h>
33 #include <string.h>
34
35 #include <glib.h>
36 #include <glib-object.h>
37 #include <gio/gio.h>
38
39 #include <gst/gst.h>
40 #include <gst/profile/gstprofile.h>
41 #include <gst/discoverer/gstdiscoverer.h>
42
43 #include <libgupnp-dlna/gupnp-dlna-load.h>
44 #include <libgupnp-dlna/gupnp-dlna-profile.h>
45 #include <libgupnp-dlna/gupnp-dlna-discoverer.h>
46 #include <libgupnp-dlna/gupnp-dlna-information.h>
47
48
49 static gboolean async = FALSE;
50 static gboolean verbose = FALSE;
51 static gint timeout = 10;
52
53 static const gchar *_gst_stream_type_to_string[] = {
54         "CONTAINER",
55         "AUDIO",
56         "VIDEO",
57         "IMAGE",
58         "UNKNOWN",
59 };
60
61
62 typedef struct
63 {
64         GUPnPDLNADiscoverer *dc;
65         int argc;
66         char **argv;
67 } PrivStruct;
68
69 /*
70  * The following functions are from gst-discoverer.c (gst-convenience/tools)
71  */
72 #define my_g_string_append_printf(str, format, ...)                     \
73         g_string_append_printf (str, "%*s" format, 2*depth, " ", ##__VA_ARGS__)
74
75 static gchar *
76 gst_stream_audio_information_to_string (GstStreamAudioInformation * info,
77                                         gint depth)
78 {
79         GString *s;
80         gchar *tmp;
81         int len = 400;
82
83         g_return_val_if_fail (info != NULL, NULL);
84
85         s = g_string_sized_new (len);
86
87         my_g_string_append_printf (s, "Codec:\n");
88         tmp = gst_caps_to_string (info->parent.caps);
89         my_g_string_append_printf (s, "  %s\n", tmp);
90         g_free (tmp);
91
92         my_g_string_append_printf (s, "Additional info:\n");
93         if (info->parent.misc) {
94                 tmp = gst_structure_to_string (info->parent.misc);
95                 my_g_string_append_printf (s, "  %s\n", tmp);
96                 g_free (tmp);
97         } else {
98                 my_g_string_append_printf (s, "  None\n");
99         }
100
101         my_g_string_append_printf (s, "Channels: %u\n", info->channels);
102         my_g_string_append_printf (s, "Sample rate: %u\n", info->sample_rate);
103         my_g_string_append_printf (s, "Depth: %u\n", info->depth);
104
105         my_g_string_append_printf (s, "Bitrate: %u\n", info->bitrate);
106         my_g_string_append_printf (s, "Max bitrate: %u\n", info->max_bitrate);
107         my_g_string_append_printf (s, "VBR: %s\n",
108                                    info->is_vbr ? "true" : "false");
109
110         my_g_string_append_printf (s, "Tags:\n");
111         if (info->parent.tags) {
112                 tmp = gst_structure_to_string ((GstStructure *) info->parent.tags);
113                 my_g_string_append_printf (s, "  %s\n", tmp);
114                 g_free (tmp);
115         } else {
116                 my_g_string_append_printf (s, "  None\n");
117         }
118
119         return g_string_free (s, FALSE);
120 }
121
122 static const gchar *_gst_video_format_to_string[] = {
123         "UNKNOWN",
124         "I420",
125         "YV12",
126         "YUY2",
127         "UYVY",
128         "AYUV",
129         "RGBx",
130         "BGRx",
131         "xRGB",
132         "xBGR",
133         "RGBA",
134         "BGRA",
135         "ARGB",
136         "ABGR",
137         "RGB",
138         "BGR",
139         "Y41B",
140         "Y42B",
141         "YVYU",
142         "Y444",
143         "v210",
144         "v216"
145 };
146
147 static gchar *
148 gst_stream_video_information_to_string (GstStreamVideoInformation * info,
149                                         gint depth)
150 {
151         GString *s;
152         gchar *tmp;
153         int len = 500, n, d;
154
155         g_return_val_if_fail (info != NULL, NULL);
156
157         s = g_string_sized_new (len);
158
159         my_g_string_append_printf (s, "Codec:\n");
160         tmp = gst_caps_to_string (info->parent.caps);
161         my_g_string_append_printf (s, "  %s\n", tmp);
162         g_free (tmp);
163
164         my_g_string_append_printf (s, "Additional info:\n");
165         if (info->parent.misc) {
166                 tmp = gst_structure_to_string (info->parent.misc);
167                 my_g_string_append_printf (s, "  %s\n", tmp);
168                 g_free (tmp);
169         } else {
170                 my_g_string_append_printf (s, "  None\n");
171         }
172
173         my_g_string_append_printf (s, "Width: %u\n", info->width);
174         my_g_string_append_printf (s, "Height: %u\n", info->height);
175         my_g_string_append_printf (s, "Depth: %u\n", info->depth);
176
177         n = gst_value_get_fraction_numerator (&info->frame_rate);
178         d = gst_value_get_fraction_denominator (&info->frame_rate);
179         my_g_string_append_printf (s, "Frame rate: %u/%u\n", n, d);
180
181         n = gst_value_get_fraction_numerator (&info->pixel_aspect_ratio);
182         d = gst_value_get_fraction_denominator (&info->pixel_aspect_ratio);
183         my_g_string_append_printf (s, "Pixel aspect ratio: %u/%u\n", n, d);
184
185         my_g_string_append_printf (s, "Format: %s\n",
186                                    _gst_video_format_to_string[info->format]);
187
188         my_g_string_append_printf (s, "Interlaced: %s\n",
189                                    info->interlaced ? "true" : "false");
190
191         my_g_string_append_printf (s, "Tags:\n");
192         if (info->parent.tags) {
193                 tmp = gst_structure_to_string ((GstStructure *) info->parent.tags);
194                 my_g_string_append_printf (s, "  %s\n", tmp);
195                 g_free (tmp);
196         } else {
197                 my_g_string_append_printf (s, "  None\n");
198         }
199
200
201         return g_string_free (s, FALSE);
202 }
203
204 static void
205 print_stream_info (GstStreamInformation * info, void *depth)
206 {
207         gchar *desc = NULL;
208
209         if (info->caps) {
210                 desc = gst_caps_to_string (info->caps);
211         }
212
213         g_print ("%*s%s: %s\n", 2 * GPOINTER_TO_INT (depth), " ",
214                  _gst_stream_type_to_string[info->streamtype], desc);
215
216         if (desc) {
217                 g_free (desc);
218                 desc = NULL;
219         }
220
221         switch (info->streamtype) {
222         case GST_STREAM_AUDIO:
223                 desc = gst_stream_audio_information_to_string (
224                                         (GstStreamAudioInformation *) info,
225                                         GPOINTER_TO_INT (depth) + 1);
226                 break;
227
228         case GST_STREAM_VIDEO:
229         case GST_STREAM_IMAGE:
230                 desc = gst_stream_video_information_to_string (
231                                          (GstStreamVideoInformation *) info,
232                                          GPOINTER_TO_INT (depth) + 1);
233                 break;
234
235         default:
236                 break;
237         }
238
239         if (desc) {
240                 g_print ("%s", desc);
241                 g_free (desc);
242         }
243 }
244
245 static void
246 print_topology (GstStreamInformation * info, gint depth)
247 {
248         if (!info)
249                 return;
250
251         print_stream_info (info, GINT_TO_POINTER (depth));
252
253         if (info->next)
254                 print_topology (info->next, depth + 1);
255         else if (info->streamtype == GST_STREAM_CONTAINER) {
256                 GstStreamContainerInformation *cont =
257                         (GstStreamContainerInformation *) info;
258                 GList *tmp;
259
260                 for (tmp = cont->streams; tmp; tmp = tmp->next) {
261                         GstStreamInformation *tmpinf =
262                                 (GstStreamInformation *) tmp->data;
263                         print_topology (tmpinf, depth + 1);
264                 }
265         }
266 }
267
268 static void
269 print_duration (const GstDiscovererInformation * info, gint tab)
270 {
271         g_print ("%*s%" GST_TIME_FORMAT "\n", tab + 1, " ",
272                  GST_TIME_ARGS (info->duration));
273 }
274
275 static void
276 print_gst_info (const GstDiscovererInformation *info, GError *err)
277 {
278         /* Get done with the error parsing first */
279         if (info->result & GST_DISCOVERER_URI_INVALID)
280                 g_print ("URI is not valid\n");
281         else if (info->result & GST_DISCOVERER_TIMEOUT)
282                 g_print ("Timeout !\n");
283         if (info->result & GST_DISCOVERER_ERROR) {
284                 g_print ("An error while discovering the file\n");
285                 g_print (" %s\n", err->message);
286                 if (info->result & GST_DISCOVERER_MISSING_PLUGINS) {
287                         gchar *tmp = gst_structure_to_string (info->misc);
288                         g_print (" (%s)\n", tmp);
289                         g_free (tmp);
290                 }
291
292                 return;
293         }
294
295         /* Print Useful information */
296         if (verbose) {
297                 if (!(info->result &
298                       (GST_DISCOVERER_ERROR | GST_DISCOVERER_TIMEOUT))) {
299                         g_print ("\nTopology:\n");
300                         print_topology (info->stream_info, 1);
301                         g_print ("\nDuration:\n");
302                         print_duration (info, 1);
303                 }
304         }
305 }
306
307 static void
308 print_dlna_info (GUPnPDLNAInformation *dlna, GError *err)
309 {
310         g_print ("\nURI: %s\n", gupnp_dlna_information_get_info (dlna)->uri);
311         g_print ("Profile Name: %s\n", gupnp_dlna_information_get_name (dlna));
312         g_print ("Profile MIME: %s\n", gupnp_dlna_information_get_mime (dlna));
313
314         print_gst_info (gupnp_dlna_information_get_info(dlna), err);
315
316         g_print ("\n");
317         return;
318 }
319
320 static void
321 discoverer_done (GUPnPDLNADiscoverer *discover,
322                  GUPnPDLNAInformation *dlna,
323                  GError *err)
324 {
325         print_dlna_info (dlna, err);
326         return;
327 }
328
329 static void
330 discoverer_ready (GUPnPDLNADiscoverer *dc, GMainLoop *ml)
331 {
332         g_main_loop_quit (ml);
333 }
334
335 static void
336 process_file (GUPnPDLNADiscoverer *discover, const gchar *filename)
337 {
338         GError *err = NULL;
339         GDir *dir;
340         gchar *uri, *path;
341         GUPnPDLNAInformation *dlna;
342
343         if(!gst_uri_is_valid (filename)) {
344                 if((dir = g_dir_open (filename, 0, NULL))) {
345                         const gchar *entry;
346
347                         while ((entry = g_dir_read_name (dir))) {
348                                 gchar *path;
349                                 path = g_strconcat (filename,
350                                                     G_DIR_SEPARATOR_S,
351                                                     entry,
352                                                     NULL);
353                                 process_file (discover, path);
354                                 g_free(path);
355                         }
356
357                         g_dir_close (dir);
358                         return;
359                 }
360
361                 if (!g_path_is_absolute (filename)) {
362                         gchar *cur_dir;
363
364                         cur_dir = g_get_current_dir ();
365                         path = g_build_filename (cur_dir, filename, NULL);
366                         g_free (cur_dir);
367                 } else {
368                         path = g_strdup (filename);
369                 }
370
371                 uri = g_filename_to_uri (path, NULL, &err);
372                 g_free (path);
373                 path = NULL;
374
375                 if (err) {
376                         g_warning ("Couldn't convert filename to URI: %s\n",
377                                    err->message);
378                         g_error_free (err);
379                         err = NULL;
380                         return;
381                 }
382         } else {
383                 uri = g_strdup (filename);
384         }
385
386         if (async == FALSE) {
387                 dlna = gupnp_dlna_discoverer_discover_uri_sync (discover,
388                                                                 uri,
389                                                                 &err);
390                 if (err) {
391                         /* Report error to user, and free error */
392                         fprintf (stderr,
393                                  "Unable to read file: %s\n",
394                                  err->message);
395                         g_error_free (err);
396                         err = NULL;
397                 } else {
398                         print_dlna_info (dlna, err);
399                 }
400         } else {
401                 gupnp_dlna_discoverer_discover_uri (discover, uri);
402         }
403
404         g_free (uri);
405 }
406
407
408 static gboolean
409 async_idle_loop (PrivStruct * ps)
410 {
411         gint i;
412
413         for (i = 1; i < ps->argc; i++)
414                 process_file (ps->dc, ps->argv[i]);
415
416         return FALSE;
417 }
418
419 /* Main */
420 int
421 main (int argc, char **argv)
422 {
423         gint i;
424         GUPnPDLNADiscoverer *discover;
425         gboolean relaxed_mode = FALSE;
426         gboolean extended_mode = FALSE;
427         GError *err = NULL;
428
429         GOptionEntry options[] = {
430                 {"timeout", 't', 0, G_OPTION_ARG_INT, &timeout,
431                  "Specify timeout (in seconds, defaults to 10)", "T"},
432                 {"async", 'a', 0, G_OPTION_ARG_NONE, &async,
433                  "Run asynchronously", NULL},
434                 {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
435                  "Print lot more information", NULL},
436                 {"relaxed mode", 'r', 0, G_OPTION_ARG_NONE, &relaxed_mode,
437                  "Enable Relaxed mode", NULL},
438                 {"extended mode", 'e', 0, G_OPTION_ARG_NONE, &extended_mode,
439                  "Enable extended mode", NULL},
440                 {NULL}
441         };
442
443         GOptionContext *ctx;
444
445
446         g_thread_init(NULL);
447
448         ctx = g_option_context_new (" - program to extract DLNA and related metadata");
449         g_option_context_add_main_entries (ctx, options, NULL);
450         g_option_context_add_group (ctx, gst_init_get_option_group ());
451
452         if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
453
454                 g_print ("Error initializing: %s\n", err->message);
455                 exit (1);
456         }
457
458         g_option_context_free (ctx);
459
460         if (argc < 2) {
461                 g_print ("usage:%s <files>\n", argv[0]);
462                 return -1;
463         }
464
465         gst_init(&argc, &argv);
466
467
468         discover = gupnp_dlna_discoverer_new ((GstClockTime)
469                                               (timeout * GST_SECOND),
470                                               relaxed_mode,
471                                               extended_mode);
472
473         if (async == FALSE) {
474                 for ( i = 1 ; i < argc ; i++ ) {
475                         process_file (discover, argv[i]);
476                 }
477         } else {
478                 PrivStruct *ps = g_new0 (PrivStruct, 1);
479                 GMainLoop *ml = g_main_loop_new (NULL, FALSE);
480
481                 ps->dc = discover;
482                 ps->argc = argc;
483                 ps->argv = argv;
484
485                 g_idle_add ((GSourceFunc) async_idle_loop, ps);
486
487                 g_signal_connect (discover, "done",
488                                   (GCallback) discoverer_done, 0);
489                 g_signal_connect (discover, "ready",
490                                   (GCallback) discoverer_ready, ml);
491
492                 gupnp_dlna_discoverer_start (discover);
493
494                 g_main_loop_run (ml);
495
496                 gupnp_dlna_discoverer_stop (discover);
497
498         }
499         g_object_unref (discover);
500         return 0;
501 }