|
1 /* GStreamer |
|
2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu> |
|
3 * 2000 Wim Taymans <wim.taymans@chello.be> |
|
4 * 2005 Wim Taymans <wim@fluendo.com> |
|
5 * |
|
6 * gstformat.c: GstFormat registration |
|
7 * |
|
8 * This library is free software; you can redistribute it and/or |
|
9 * modify it under the terms of the GNU Library General Public |
|
10 * License as published by the Free Software Foundation; either |
|
11 * version 2 of the License, or (at your option) any later version. |
|
12 * |
|
13 * This library is distributed in the hope that it will be useful, |
|
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
16 * Library General Public License for more details. |
|
17 * |
|
18 * You should have received a copy of the GNU Library General Public |
|
19 * License along with this library; if not, write to the |
|
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
|
21 * Boston, MA 02111-1307, USA. |
|
22 */ |
|
23 |
|
24 /** |
|
25 * SECTION:gstformat |
|
26 * @short_description: Dynamically register new data formats |
|
27 * @see_also: #GstPad, #GstElement |
|
28 * |
|
29 * GstFormats functions are used to register a new format to the gstreamer |
|
30 * core. Formats can be used to perform seeking or conversions/query |
|
31 * operations. |
|
32 */ |
|
33 |
|
34 |
|
35 #include "gst_private.h" |
|
36 #include <string.h> |
|
37 #include "gstformat.h" |
|
38 #include "gstenumtypes.h" |
|
39 |
|
40 #ifdef __SYMBIAN32__ |
|
41 #include <glib_global.h> |
|
42 #endif |
|
43 |
|
44 static GStaticMutex mutex = G_STATIC_MUTEX_INIT; |
|
45 static GList *_gst_formats = NULL; |
|
46 static GHashTable *_nick_to_format = NULL; |
|
47 static GHashTable *_format_to_nick = NULL; |
|
48 static guint32 _n_values = 1; /* we start from 1 because 0 reserved for UNDEFINED */ |
|
49 |
|
50 static GstFormatDefinition standard_definitions[] = { |
|
51 {GST_FORMAT_DEFAULT, "default", "Default format for the media type", 0}, |
|
52 {GST_FORMAT_BYTES, "bytes", "Bytes", 0}, |
|
53 {GST_FORMAT_TIME, "time", "Time", 0}, |
|
54 {GST_FORMAT_BUFFERS, "buffers", "Buffers", 0}, |
|
55 {GST_FORMAT_PERCENT, "percent", "Percent", 0}, |
|
56 {0, NULL, NULL, 0} |
|
57 }; |
|
58 #ifdef __SYMBIAN32__ |
|
59 EXPORT_C |
|
60 #endif |
|
61 |
|
62 |
|
63 void |
|
64 _gst_format_initialize (void) |
|
65 { |
|
66 GstFormatDefinition *standards = standard_definitions; |
|
67 |
|
68 g_static_mutex_lock (&mutex); |
|
69 if (_nick_to_format == NULL) { |
|
70 _nick_to_format = g_hash_table_new (g_str_hash, g_str_equal); |
|
71 _format_to_nick = g_hash_table_new (NULL, NULL); |
|
72 } |
|
73 |
|
74 while (standards->nick) { |
|
75 standards->quark = g_quark_from_static_string (standards->nick); |
|
76 g_hash_table_insert (_nick_to_format, standards->nick, standards); |
|
77 g_hash_table_insert (_format_to_nick, GINT_TO_POINTER (standards->value), |
|
78 standards); |
|
79 |
|
80 _gst_formats = g_list_append (_gst_formats, standards); |
|
81 standards++; |
|
82 _n_values++; |
|
83 } |
|
84 /* getting the type registers the enum */ |
|
85 g_type_class_ref (gst_format_get_type ()); |
|
86 g_static_mutex_unlock (&mutex); |
|
87 } |
|
88 |
|
89 /** |
|
90 * gst_format_get_name: |
|
91 * @format: a #GstFormat |
|
92 * |
|
93 * Get a printable name for the given format. Do not modify or free. |
|
94 * |
|
95 * Returns: a reference to the static name of the format or NULL if |
|
96 * the format is unknown. |
|
97 */ |
|
98 #ifdef __SYMBIAN32__ |
|
99 EXPORT_C |
|
100 #endif |
|
101 |
|
102 const gchar * |
|
103 gst_format_get_name (GstFormat format) |
|
104 { |
|
105 const GstFormatDefinition *def; |
|
106 const gchar *result; |
|
107 |
|
108 if ((def = gst_format_get_details (format)) != NULL) |
|
109 result = def->nick; |
|
110 else |
|
111 result = NULL; |
|
112 |
|
113 return result; |
|
114 } |
|
115 |
|
116 /** |
|
117 * gst_format_to_quark: |
|
118 * @format: a #GstFormat |
|
119 * |
|
120 * Get the unique quark for the given format. |
|
121 * |
|
122 * Returns: the quark associated with the format or 0 if the format |
|
123 * is unknown. |
|
124 */ |
|
125 #ifdef __SYMBIAN32__ |
|
126 EXPORT_C |
|
127 #endif |
|
128 |
|
129 GQuark |
|
130 gst_format_to_quark (GstFormat format) |
|
131 { |
|
132 const GstFormatDefinition *def; |
|
133 GQuark result; |
|
134 |
|
135 if ((def = gst_format_get_details (format)) != NULL) |
|
136 result = def->quark; |
|
137 else |
|
138 result = 0; |
|
139 |
|
140 return result; |
|
141 } |
|
142 |
|
143 /** |
|
144 * gst_format_register: |
|
145 * @nick: The nick of the new format |
|
146 * @description: The description of the new format |
|
147 * |
|
148 * Create a new GstFormat based on the nick or return an |
|
149 * already registered format with that nick. |
|
150 * |
|
151 * Returns: A new GstFormat or an already registered format |
|
152 * with the same nick. |
|
153 * |
|
154 * MT safe. |
|
155 */ |
|
156 #ifdef __SYMBIAN32__ |
|
157 EXPORT_C |
|
158 #endif |
|
159 |
|
160 GstFormat |
|
161 gst_format_register (const gchar * nick, const gchar * description) |
|
162 { |
|
163 GstFormatDefinition *format; |
|
164 GstFormat query; |
|
165 |
|
166 g_return_val_if_fail (nick != NULL, 0); |
|
167 g_return_val_if_fail (description != NULL, 0); |
|
168 |
|
169 query = gst_format_get_by_nick (nick); |
|
170 if (query != GST_FORMAT_UNDEFINED) |
|
171 return query; |
|
172 |
|
173 g_static_mutex_lock (&mutex); |
|
174 format = g_new0 (GstFormatDefinition, 1); |
|
175 format->value = _n_values; |
|
176 format->nick = g_strdup (nick); |
|
177 format->description = g_strdup (description); |
|
178 format->quark = g_quark_from_static_string (format->nick); |
|
179 |
|
180 g_hash_table_insert (_nick_to_format, format->nick, format); |
|
181 g_hash_table_insert (_format_to_nick, GINT_TO_POINTER (format->value), |
|
182 format); |
|
183 _gst_formats = g_list_append (_gst_formats, format); |
|
184 _n_values++; |
|
185 g_static_mutex_unlock (&mutex); |
|
186 |
|
187 return format->value; |
|
188 } |
|
189 |
|
190 /** |
|
191 * gst_format_get_by_nick: |
|
192 * @nick: The nick of the format |
|
193 * |
|
194 * Return the format registered with the given nick. |
|
195 * |
|
196 * Returns: The format with @nick or GST_FORMAT_UNDEFINED |
|
197 * if the format was not registered. |
|
198 */ |
|
199 #ifdef __SYMBIAN32__ |
|
200 EXPORT_C |
|
201 #endif |
|
202 |
|
203 GstFormat |
|
204 gst_format_get_by_nick (const gchar * nick) |
|
205 { |
|
206 GstFormatDefinition *format; |
|
207 |
|
208 g_return_val_if_fail (nick != NULL, 0); |
|
209 |
|
210 g_static_mutex_lock (&mutex); |
|
211 format = g_hash_table_lookup (_nick_to_format, nick); |
|
212 g_static_mutex_unlock (&mutex); |
|
213 |
|
214 if (format != NULL) |
|
215 return format->value; |
|
216 else |
|
217 return GST_FORMAT_UNDEFINED; |
|
218 } |
|
219 |
|
220 /** |
|
221 * gst_formats_contains: |
|
222 * @formats: The format array to search |
|
223 * @format: the format to find |
|
224 * |
|
225 * See if the given format is inside the format array. |
|
226 * |
|
227 * Returns: TRUE if the format is found inside the array |
|
228 */ |
|
229 #ifdef __SYMBIAN32__ |
|
230 EXPORT_C |
|
231 #endif |
|
232 |
|
233 gboolean |
|
234 gst_formats_contains (const GstFormat * formats, GstFormat format) |
|
235 { |
|
236 if (!formats) |
|
237 return FALSE; |
|
238 |
|
239 while (*formats) { |
|
240 if (*formats == format) |
|
241 return TRUE; |
|
242 |
|
243 formats++; |
|
244 } |
|
245 return FALSE; |
|
246 } |
|
247 |
|
248 |
|
249 /** |
|
250 * gst_format_get_details: |
|
251 * @format: The format to get details of |
|
252 * |
|
253 * Get details about the given format. |
|
254 * |
|
255 * Returns: The #GstFormatDefinition for @format or NULL on failure. |
|
256 * |
|
257 * MT safe. |
|
258 */ |
|
259 #ifdef __SYMBIAN32__ |
|
260 EXPORT_C |
|
261 #endif |
|
262 |
|
263 const GstFormatDefinition * |
|
264 gst_format_get_details (GstFormat format) |
|
265 { |
|
266 const GstFormatDefinition *result; |
|
267 |
|
268 g_static_mutex_lock (&mutex); |
|
269 result = g_hash_table_lookup (_format_to_nick, GINT_TO_POINTER (format)); |
|
270 g_static_mutex_unlock (&mutex); |
|
271 |
|
272 return result; |
|
273 } |
|
274 |
|
275 /** |
|
276 * gst_format_iterate_definitions: |
|
277 * |
|
278 * Iterate all the registered formats. The format definition is read |
|
279 * only. |
|
280 * |
|
281 * Returns: A GstIterator of #GstFormatDefinition. |
|
282 */ |
|
283 #ifdef __SYMBIAN32__ |
|
284 EXPORT_C |
|
285 #endif |
|
286 |
|
287 GstIterator * |
|
288 gst_format_iterate_definitions (void) |
|
289 { |
|
290 GstIterator *result; |
|
291 |
|
292 g_static_mutex_lock (&mutex); |
|
293 /* FIXME: register a boxed type for GstFormatDefinition */ |
|
294 result = gst_iterator_new_list (G_TYPE_POINTER, |
|
295 g_static_mutex_get_mutex (&mutex), &_n_values, &_gst_formats, |
|
296 NULL, NULL, NULL); |
|
297 g_static_mutex_unlock (&mutex); |
|
298 |
|
299 return result; |
|
300 } |