【GStreamer开发】GStreamer基础教程09——收集媒体信息

目标

有时你需要快速的了解一个文件（或URI）包含的媒体格式或者看看是否支持这种格式。当然你可以创建一个pipeline，设置运行，观察总线上的消息，但GStreamer提供了一个工具可以帮你做这些。本教程主要讲述：

如何获得一个URI上的信息

如何确定一个URI是可以播放的

介绍

GstDiscover是一个在pbutils库提供的工具，接受输入URI或者URI列表，返回它们的信息。这个工具可以工作在同步或者异步模式下。

在同步模式下，只有一个API可以用，就是gst_discoverer_discover_uri()，这个API会阻塞线程直到得到需要的信息。因为阻塞会带来GUI上很糟糕的体验，所以基于UI的应用主要使用异步模式，本教程也是基于异步模式的。

检测到的信息会包括codec的描述，流的拓扑结构和可以获得的元数据。

[html] view
plain copy

1. <span style="font-size:14px;">As an example, this is the result of discovering http://docs.gstreamer.com/media/sintel_trailer-480p.webm (Click to expand)
2. Duration: 0:00:52.250000000
3. Tags:
4. video codec: On2 VP8
5. language code: en
6. container format: Matroska
7. application name: ffmpeg2theora-0.24
8. encoder: Xiph.Org libVorbis I 20090709
9. encoder version: 0
10. audio codec: Vorbis
11. nominal bitrate: 80000
12. bitrate: 80000
13. Seekable: yes
14. Stream information:
15. container: WebM
16. audio: Vorbis
17. Tags:
18. language code: en
19. container format: Matroska
20. audio codec: Vorbis
21. application name: ffmpeg2theora-0.24
22. encoder: Xiph.Org libVorbis I 20090709
23. encoder version: 0
24. nominal bitrate: 80000
25. bitrate: 80000
26. video: VP8
27. Tags:
28. video codec: VP8 video
29. container format: Matroska</span>

下面的代码试着通过命令行的方式来运行discover工具来解析URI的内容，输出获得的信息。

这是gst-discoverer工具使用的简单版本，这个应用仅仅显示数据，甚至不提供播放功能。

GStreamer Discoverer

[html] view
plain copy

1. <span style="font-size:14px;">#include <string.h>
2. #include <gst/gst.h>
3. #include <gst/pbutils/pbutils.h>
4. /* Structure to contain all our information, so we can pass it around */
5. typedef struct _CustomData {
6. GstDiscoverer *discoverer;
7. GMainLoop *loop;
8. } CustomData;
9. /* Print a tag in a human-readable format (name: value) */
10. static void print_tag_foreach (const GstTagList *tags, const gchar *tag, gpointer user_data) {
11. GValue val = { 0, };
12. gchar *str;
13. gint depth = GPOINTER_TO_INT (user_data);
14. gst_tag_list_copy_value (&val, tags, tag);
15. if (G_VALUE_HOLDS_STRING (&val))
16. str = g_value_dup_string (&val);
17. else
18. str = gst_value_serialize (&val);
19. g_print ("%*s%s: %s\n", 2 * depth, " ", gst_tag_get_nick (tag), str);
20. g_free (str);
21. g_value_unset (&val);
22. }
23. /* Print information regarding a stream */
24. static void print_stream_info (GstDiscovererStreamInfo *info, gint depth) {
25. gchar *desc = NULL;
26. GstCaps *caps;
27. const GstTagList *tags;
28. caps = gst_discoverer_stream_info_get_caps (info);
29. if (caps) {
30. if (gst_caps_is_fixed (caps))
31. desc = gst_pb_utils_get_codec_description (caps);
32. else
33. desc = gst_caps_to_string (caps);
34. gst_caps_unref (caps);
35. }
36. g_print ("%*s%s: %s\n", 2 * depth, " ", gst_discoverer_stream_info_get_stream_type_nick (info), (desc ? desc : ""));
37. if (desc) {
38. g_free (desc);
39. desc = NULL;
40. }
41. tags = gst_discoverer_stream_info_get_tags (info);
42. if (tags) {
43. g_print ("%*sTags:\n", 2 * (depth + 1), " ");
44. gst_tag_list_foreach (tags, print_tag_foreach, GINT_TO_POINTER (depth + 2));
45. }
46. }
47. /* Print information regarding a stream and its substreams, if any */
48. static void print_topology (GstDiscovererStreamInfo *info, gint depth) {
49. GstDiscovererStreamInfo *next;
50. if (!info)
51. return;
52. print_stream_info (info, depth);
53. next = gst_discoverer_stream_info_get_next (info);
54. if (next) {
55. print_topology (next, depth + 1);
56. gst_discoverer_stream_info_unref (next);
57. } else if (GST_IS_DISCOVERER_CONTAINER_INFO (info)) {
58. GList *tmp, *streams;
59. streams = gst_discoverer_container_info_get_streams (GST_DISCOVERER_CONTAINER_INFO (info));
60. for (tmp = streams; tmp; tmp = tmp->next) {
61. GstDiscovererStreamInfo *tmpinf = (GstDiscovererStreamInfo *) tmp->data;
62. print_topology (tmpinf, depth + 1);
63. }
64. gst_discoverer_stream_info_list_free (streams);
65. }
66. }
67. /* This function is called every time the discoverer has information regarding
68. * one of the URIs we provided.*/
69. static void on_discovered_cb (GstDiscoverer *discoverer, GstDiscovererInfo *info, GError *err, CustomData *data) {
70. GstDiscovererResult result;
71. const gchar *uri;
72. const GstTagList *tags;
73. GstDiscovererStreamInfo *sinfo;
74. uri = gst_discoverer_info_get_uri (info);
75. result = gst_discoverer_info_get_result (info);
76. switch (result) {
77. case GST_DISCOVERER_URI_INVALID:
78. g_print ("Invalid URI '%s'\n", uri);
79. break;
80. case GST_DISCOVERER_ERROR:
81. g_print ("Discoverer error: %s\n", err->message);
82. break;
83. case GST_DISCOVERER_TIMEOUT:
84. g_print ("Timeout\n");
85. break;
86. case GST_DISCOVERER_BUSY:
87. g_print ("Busy\n");
88. break;
89. case GST_DISCOVERER_MISSING_PLUGINS:{
90. const GstStructure *s;
91. gchar *str;
92. s = gst_discoverer_info_get_misc (info);
93. str = gst_structure_to_string (s);
94. g_print ("Missing plugins: %s\n", str);
95. g_free (str);
96. break;
97. }
98. case GST_DISCOVERER_OK:
99. g_print ("Discovered '%s'\n", uri);
100. break;
101. }
102. if (result != GST_DISCOVERER_OK) {
103. g_printerr ("This URI cannot be played\n");
104. return;
105. }
106. /* If we got no error, show the retrieved information */
107. g_print ("\nDuration: %" GST_TIME_FORMAT "\n", GST_TIME_ARGS (gst_discoverer_info_get_duration (info)));
108. tags = gst_discoverer_info_get_tags (info);
109. if (tags) {
110. g_print ("Tags:\n");
111. gst_tag_list_foreach (tags, print_tag_foreach, GINT_TO_POINTER (1));
112. }
113. g_print ("Seekable: %s\n", (gst_discoverer_info_get_seekable (info) ? "yes" : "no"));
114. g_print ("\n");
115. sinfo = gst_discoverer_info_get_stream_info (info);
116. if (!sinfo)
117. return;
118. g_print ("Stream information:\n");
119. print_topology (sinfo, 1);
120. gst_discoverer_stream_info_unref (sinfo);
121. g_print ("\n");
122. }
123. /* This function is called when the discoverer has finished examining
124. * all the URIs we provided.*/
125. static void on_finished_cb (GstDiscoverer *discoverer, CustomData *data) {
126. g_print ("Finished discovering\n");
127. g_main_loop_quit (data->loop);
128. }
129. int main (int argc, char **argv) {
130. CustomData data;
131. GError *err = NULL;
132. gchar *uri = "http://docs.gstreamer.com/media/sintel_trailer-480p.webm";
133. /* if a URI was provided, use it instead of the default one */
134. if (argc > 1) {
135. uri = argv[1];
136. }
137. /* Initialize cumstom data structure */
138. memset (&data, 0, sizeof (data));
139. /* Initialize GStreamer */
140. gst_init (&argc, &argv);
141. g_print ("Discovering '%s'\n", uri);
142. /* Instantiate the Discoverer */
143. data.discoverer = gst_discoverer_new (5 * GST_SECOND, &err);
144. if (!data.discoverer) {
145. g_print ("Error creating discoverer instance: %s\n", err->message);
146. g_clear_error (&err);
147. return -1;
148. }
149. /* Connect to the interesting signals */
150. g_signal_connect (data.discoverer, "discovered", G_CALLBACK (on_discovered_cb), &data);
151. g_signal_connect (data.discoverer, "finished", G_CALLBACK (on_finished_cb), &data);
152. /* Start the discoverer process (nothing to do yet) */
153. gst_discoverer_start (data.discoverer);
154. /* Add a request to process asynchronously the URI passed through the command line */
155. if (!gst_discoverer_discover_uri_async (data.discoverer, uri)) {
156. g_print ("Failed to start discovering URI '%s'\n", uri);
157. g_object_unref (data.discoverer);
158. return -1;
159. }
160. /* Create a GLib Main Loop and set it to run, so we can wait for the signals */
161. data.loop = g_main_loop_new (NULL, FALSE);
162. g_main_loop_run (data.loop);
163. /* Stop the discoverer process */
164. gst_discoverer_stop (data.discoverer);
165. /* Free resources */
166. g_object_unref (data.discoverer);
167. g_main_loop_unref (data.loop);
168. return 0;
169. }</span>

工作流程

下面是使用GstDiscoverer的主要步骤。

[objc] view
plain copy

1. <span style="font-size:14px;">  /* Instantiate the Discoverer */
2. 5 * GST_SECOND, &err);
3. if (!data.discoverer) {
4. g_print ("Error creating discoverer instance: %s\n", err->message);
5. g_clear_error (&err);
6. ;
7. }</span>

gst_discover_new()会创建一个Discoverer对象，第一个参数是超时时间（使用纳秒做单位）。

[objc] view
plain copy

1. <span style="font-size:14px;">  /* Connect to the interesting signals */
2. g_signal_connect (data.discoverer, "discovered", G_CALLBACK (on_discovered_cb), &data);
3. g_signal_connect (data.discoverer, "finished", G_CALLBACK (on_finished_cb), &data);</span>

像平常一样对必要的的信号注册回调，我们在他们的回调里面继续讨论。

[objc] view
plain copy

1. <span style="font-size:14px;">  /* Start the discoverer process (nothing to do yet) */
2. gst_discoverer_start (data.discoverer);</span>

gst_discover_start()启动检查进程，但我们还没有提供URI，下面就是提供URI了：

[objc] view
plain copy

1. <span style="font-size:14px;">  /* Add a request to process asynchronously the URI passed through the command line */
2. if (!gst_discoverer_discover_uri_async (data.discoverer, uri)) {
3. g_print ("Failed to start discovering URI '%s'\n", uri);
4. g_object_unref (data.discoverer);
5. ;
6. }</span>

gst_discoverer_discover_uri_async()会把需要检查的URI放入队列，这个函数支持把多个URI入队。在检查过程把所有的URI都检查过之后，会调用注册的回调函数。

[objc] view
plain copy

1. <span style="font-size:14px;">  /* Create a GLib Main Loop and set it to run, so we can wait for the signals */
2. data.loop = g_main_loop_new (NULL, FALSE);
3. g_main_loop_run (data.loop);</span>

GLib已经在运行主循环了，我们在on_finished_cb回调中调用g_main_loop_quit()来退出主循环。

[objc] view
plain copy

1. <span style="font-size:14px;">  /* Stop the discoverer process */
2. gst_discoverer_stop (data.discoverer);</span>

一旦我们检查结束，我们会调用gst_discoverer_stop()来停止，并且调用g_object_unref()来释放资源。

现在让我们来看一下我们注册的回调函数：

[objc] view
plain copy

1. <span style="font-size:14px;">/* This function is called every time the discoverer has information regarding
2. * one of the URIs we provided.*/
3. static void on_discovered_cb (GstDiscoverer *discoverer, GstDiscovererInfo *info, GError *err, CustomData *data) {
4. GstDiscovererResult result;
5. const gchar *uri;
6. const GstTagList *tags;
7. GstDiscovererStreamInfo *sinfo;
8. uri = gst_discoverer_info_get_uri (info);
9. result = gst_discoverer_info_get_result (info);</span>

当我们运行到这些代码时，discoverer已经完成了一个URI的检查了，用GstDiscovererInfo这个数据结构把内容传给我们。

这里第一步是用gst_discoverer_info_get_uri()方法去获得调用这个回调的URI（因为可能存在多个URI），然后通过gst_discoverer_info_get_result()方法来获得数据。

[objc] view
plain copy

1. switch (result) {
2. case GST_DISCOVERER_URI_INVALID:
3. g_print ("Invalid URI '%s'\n", uri);
4. break;
5. case GST_DISCOVERER_ERROR:
6. g_print ("Discoverer error: %s\n", err->message);
7. break;
8. case GST_DISCOVERER_TIMEOUT:
9. g_print ("Timeout\n");
10. break;
11. case GST_DISCOVERER_BUSY:
12. g_print ("Busy\n");
13. break;
14. case GST_DISCOVERER_MISSING_PLUGINS:{
15. const GstStructure *s;
16. gchar *str;
17. s = gst_discoverer_info_get_misc (info);
18. str = gst_structure_to_string (s);
19. g_print ("Missing plugins: %s\n", str);
20. g_free (str);
21. break;
22. }
23. case GST_DISCOVERER_OK:
24. g_print ("Discovered '%s'\n", uri);
25. break;
26. }
27. if (result != GST_DISCOVERER_OK) {
28. g_printerr ("This URI cannot be played\n");
29. return;
30. }

正如代码显示的那样，除了GST_DISCOVERER_OK之外，任何一个结果都意味着有某种问题，这个URI不能播放。不能播放的原因是多种多样的，但枚举出来后也比较清晰（GST_DISCOVERER_BUSY只可能在同步模式下出现，这里是不可能出现的）。

如果没有发生错误，那么可以用gst_discoverer_info_get_*系列方法从GstDiscovererInfo这个结构里面获得数据了。比如，用gst_discoverer_info_get_duration()方法可以获得播放总长度。

信息的位是由列表组成的，就像标签和流信息，需要再解析一下：

[objc] view
plain copy

1. tags = gst_discoverer_info_get_tags (info);
2. if (tags) {
3. g_print ("Tags:\n");
4. ));
5. }

标签是附着在媒体上得元数据。它们可以用gst_tag_list_foreach()方法来检查，每检查到一个标签就调用一次print_tag_foreach()。至于print_tag_foreach()方法的代码比较浅显，可以直接读懂。

[objc] view
plain copy

1. sinfo = gst_discoverer_info_get_stream_info (info);
2. if (!sinfo)
3. return;
4. g_print ("Stream information:\n");
5. );
6. gst_discoverer_stream_info_unref (sinfo);

gst_discoverer_info_get_stream_info()会返回一个GstDiscovererStreamInfo类型的数据，print_topology()函数会解析这个数据结构，然后调用gst_discoverer_stream_info_unref()来释放资源。

[objc] view
plain copy

1. /* Print information regarding a stream and its substreams, if any */
2. static void print_topology (GstDiscovererStreamInfo *info, gint depth) {
3. GstDiscovererStreamInfo *next;
4. if (!info)
5. return;
6. print_stream_info (info, depth);
7. next = gst_discoverer_stream_info_get_next (info);
8. if (next) {
9. );
10. gst_discoverer_stream_info_unref (next);
11. } else if (GST_IS_DISCOVERER_CONTAINER_INFO (info)) {
12. GList *tmp, *streams;
13. streams = gst_discoverer_container_info_get_streams (GST_DISCOVERER_CONTAINER_INFO (info));
14. for (tmp = streams; tmp; tmp = tmp->next) {
15. GstDiscovererStreamInfo *tmpinf = (GstDiscovererStreamInfo *) tmp->data;
16. );
17. }
18. gst_discoverer_stream_info_list_free (streams);
19. }
20. }

print_stream_info()函数的代码也是很简单直接的，它也调用了print_tag_foreach方法来打印流的capabilities和相关联的tags。

print_topology方法会寻找下一个流来显示。如果get_discoverer_stream_info_get_next()返回一个非空流信息的话，它需要被显示。另一方面，如果我们是一个容器，我们每一个用get_discoverer_container_info_get_streams()方法获得的子流都需要递归的调用print_topology方法。当然，如果我们是一个叶子流了，就不在需要继续递归下去了。