1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19  
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 /*
25  * Conversion parameters:
26  * inFile  = gstreamer-GstTagList.html
27  * outPack = gstreamer
28  * outFile = TagList
29  * strct   = GstTagList
30  * realStrct=
31  * ctorStrct=
32  * clss    = TagList
33  * interf  = 
34  * class Code: No
35  * interface Code: No
36  * template for:
37  * extend  = 
38  * implements:
39  * prefixes:
40  * 	- gst_tag_list_
41  * 	- gst_tag_
42  * omit structs:
43  * omit prefixes:
44  * omit code:
45  * omit signals:
46  * imports:
47  * 	- glib.Str
48  * 	- glib.Date
49  * 	- gobject.Value
50  * structWrap:
51  * 	- GDate* -> Date
52  * 	- GValue* -> Value
53  * 	- GstTagList* -> TagList
54  * module aliases:
55  * local aliases:
56  * overrides:
57  */
58 
59 module gstreamer.TagList;
60 
61 public  import gstreamerc.gstreamertypes;
62 
63 private import gstreamerc.gstreamer;
64 private import glib.ConstructionException;
65 private import gobject.ObjectG;
66 
67 
68 private import glib.Str;
69 private import glib.Date;
70 private import gobject.Value;
71 
72 
73 
74 
75 /**
76  * Description
77  * List of tags and values used to describe media metadata.
78  * Last reviewed on 2005-11-23 (0.9.5)
79  */
80 public class TagList
81 {
82 	
83 	/** the main Gtk struct */
84 	protected GstTagList* gstTagList;
85 	
86 	
87 	public GstTagList* getTagListStruct()
88 	{
89 		return gstTagList;
90 	}
91 	
92 	
93 	/** the main Gtk struct as a void* */
94 	protected void* getStruct()
95 	{
96 		return cast(void*)gstTagList;
97 	}
98 	
99 	/**
100 	 * Sets our main struct and passes it to the parent class
101 	 */
102 	public this (GstTagList* gstTagList)
103 	{
104 		this.gstTagList = gstTagList;
105 	}
106 	
107 	/**
108 	 */
109 	
110 	/**
111 	 * Registers a new tag type for the use with GStreamer's type system. If a type
112 	 * with that name is already registered, that one is used.
113 	 * The old registration may have used a different type however. So don't rely
114 	 * on your supplied values.
115 	 * Important: if you do not supply a merge function the implication will be
116 	 * that there can only be one single value for this tag in a tag list and
117 	 * any additional values will silenty be discarded when being added (unless
118 	 * GST_TAG_MERGE_REPLACE, GST_TAG_MERGE_REPLACE_ALL, or
119 	 * GST_TAG_MERGE_PREPEND is used as merge mode, in which case the new
120 	 * value will replace the old one in the list).
121 	 * The merge function will be called from gst_tag_list_copy_value() when
122 	 * it is required that one or more values for a tag be condensed into
123 	 * one single value. This may happen from gst_tag_list_get_string(),
124 	 * gst_tag_list_get_int(), gst_tag_list_get_double() etc. What will happen
125 	 * exactly in that case depends on how the tag was registered and if a
126 	 * merge function was supplied and if so which one.
127 	 * Two default merge functions are provided: gst_tag_merge_use_first() and
128 	 * gst_tag_merge_strings_with_commas().
129 	 * Params:
130 	 * name = the name or identifier string
131 	 * flag = a flag describing the type of tag info
132 	 * type = the type this data is in
133 	 * nick = human-readable name
134 	 * blurb = a human-readable description about this tag
135 	 * func = function for merging multiple values of this tag, or NULL
136 	 */
137 	public static void register(string name, GstTagFlag flag, GType type, string nick, string blurb, GstTagMergeFunc func)
138 	{
139 		// void gst_tag_register (const gchar *name,  GstTagFlag flag,  GType type,  const gchar *nick,  const gchar *blurb,  GstTagMergeFunc func);
140 		gst_tag_register(Str.toStringz(name), flag, type, Str.toStringz(nick), Str.toStringz(blurb), func);
141 	}
142 	
143 	/**
144 	 * This is a convenience function for the func argument of gst_tag_register().
145 	 * It creates a copy of the first value from the list.
146 	 * Params:
147 	 * dest = uninitialized GValue to store result in
148 	 * src = GValue to copy from
149 	 */
150 	public static void mergeUseFirst(Value dest, Value src)
151 	{
152 		// void gst_tag_merge_use_first (GValue *dest,  const GValue *src);
153 		gst_tag_merge_use_first((dest is null) ? null : dest.getValueStruct(), (src is null) ? null : src.getValueStruct());
154 	}
155 	
156 	/**
157 	 * This is a convenience function for the func argument of gst_tag_register().
158 	 * It concatenates all given strings using a comma. The tag must be registered
159 	 * as a G_TYPE_STRING or this function will fail.
160 	 * Params:
161 	 * dest = uninitialized GValue to store result in
162 	 * src = GValue to copy from
163 	 */
164 	public static void mergeStringsWithComma(Value dest, Value src)
165 	{
166 		// void gst_tag_merge_strings_with_comma (GValue *dest,  const GValue *src);
167 		gst_tag_merge_strings_with_comma((dest is null) ? null : dest.getValueStruct(), (src is null) ? null : src.getValueStruct());
168 	}
169 	
170 	/**
171 	 * Checks if the given type is already registered.
172 	 * Params:
173 	 * tag = name of the tag
174 	 * Returns: TRUE if the type is already registered
175 	 */
176 	public static int exists(string tag)
177 	{
178 		// gboolean gst_tag_exists (const gchar *tag);
179 		return gst_tag_exists(Str.toStringz(tag));
180 	}
181 	
182 	/**
183 	 * Gets the GType used for this tag.
184 	 * Params:
185 	 * tag = the tag
186 	 * Returns: the GType of this tag
187 	 */
188 	public static GType getType(string tag)
189 	{
190 		// GType gst_tag_get_type (const gchar *tag);
191 		return gst_tag_get_type(Str.toStringz(tag));
192 	}
193 	
194 	/**
195 	 * Returns the human-readable name of this tag, You must not change or free
196 	 * this string.
197 	 * Params:
198 	 * tag = the tag
199 	 * Returns: the human-readable name of this tag
200 	 */
201 	public static string getNick(string tag)
202 	{
203 		// const gchar* gst_tag_get_nick (const gchar *tag);
204 		return Str.toString(gst_tag_get_nick(Str.toStringz(tag)));
205 	}
206 	
207 	/**
208 	 * Returns the human-readable description of this tag, You must not change or
209 	 * free this string.
210 	 * Params:
211 	 * tag = the tag
212 	 * Returns: the human-readable description of this tag
213 	 */
214 	public static string getDescription(string tag)
215 	{
216 		// const gchar* gst_tag_get_description (const gchar *tag);
217 		return Str.toString(gst_tag_get_description(Str.toStringz(tag)));
218 	}
219 	
220 	/**
221 	 * Gets the flag of tag.
222 	 * Params:
223 	 * tag = the tag
224 	 * Returns: the flag of this tag.
225 	 */
226 	public static GstTagFlag getFlag(string tag)
227 	{
228 		// GstTagFlag gst_tag_get_flag (const gchar *tag);
229 		return gst_tag_get_flag(Str.toStringz(tag));
230 	}
231 	
232 	/**
233 	 * Checks if the given tag is fixed. A fixed tag can only contain one value.
234 	 * Unfixed tags can contain lists of values.
235 	 * Params:
236 	 * tag = tag to check
237 	 * Returns: TRUE, if the given tag is fixed.
238 	 */
239 	public static int isFixed(string tag)
240 	{
241 		// gboolean gst_tag_is_fixed (const gchar *tag);
242 		return gst_tag_is_fixed(Str.toStringz(tag));
243 	}
244 	
245 	/**
246 	 * Creates a new empty GstTagList.
247 	 * Throws: ConstructionException GTK+ fails to create the object.
248 	 */
249 	public this ()
250 	{
251 		// GstTagList* gst_tag_list_new (void);
252 		auto p = gst_tag_list_new();
253 		if(p is null)
254 		{
255 			throw new ConstructionException("null returned by gst_tag_list_new()");
256 		}
257 		this(cast(GstTagList*) p);
258 	}
259 	
260 	/**
261 	 * Checks if the given pointer is a taglist.
262 	 * Params:
263 	 * p = Object that might be a taglist
264 	 * Returns: TRUE, if the given pointer is a taglist
265 	 */
266 	public static int gstIsTagList(void* p)
267 	{
268 		// gboolean gst_is_tag_list (gconstpointer p);
269 		return gst_is_tag_list(p);
270 	}
271 	
272 	/**
273 	 * Checks if the given taglist is empty.
274 	 * Returns: TRUE if the taglist is empty, otherwise FALSE. Since 0.10.11
275 	 */
276 	public int isEmpty()
277 	{
278 		// gboolean gst_tag_list_is_empty (const GstTagList *list);
279 		return gst_tag_list_is_empty(gstTagList);
280 	}
281 	
282 	/**
283 	 * Copies a given GstTagList.
284 	 * Returns: copy of the given list
285 	 */
286 	public TagList copy()
287 	{
288 		// GstTagList* gst_tag_list_copy (const GstTagList *list);
289 		auto p = gst_tag_list_copy(gstTagList);
290 		
291 		if(p is null)
292 		{
293 			return null;
294 		}
295 		
296 		return ObjectG.getDObject!(TagList)(cast(GstTagList*) p);
297 	}
298 	
299 	/**
300 	 * Inserts the tags of the second list into the first list using the given mode.
301 	 * Params:
302 	 * from = list to merge from
303 	 * mode = the mode to use
304 	 */
305 	public void insert(TagList from, GstTagMergeMode mode)
306 	{
307 		// void gst_tag_list_insert (GstTagList *into,  const GstTagList *from,  GstTagMergeMode mode);
308 		gst_tag_list_insert(gstTagList, (from is null) ? null : from.getTagListStruct(), mode);
309 	}
310 	
311 	/**
312 	 * Merges the two given lists into a new list. If one of the lists is NULL, a
313 	 * copy of the other is returned. If both lists are NULL, NULL is returned.
314 	 * Params:
315 	 * list2 = second list to merge
316 	 * mode = the mode to use
317 	 * Returns: the new list
318 	 */
319 	public TagList merge(TagList list2, GstTagMergeMode mode)
320 	{
321 		// GstTagList* gst_tag_list_merge (const GstTagList *list1,  const GstTagList *list2,  GstTagMergeMode mode);
322 		auto p = gst_tag_list_merge(gstTagList, (list2 is null) ? null : list2.getTagListStruct(), mode);
323 		
324 		if(p is null)
325 		{
326 			return null;
327 		}
328 		
329 		return ObjectG.getDObject!(TagList)(cast(GstTagList*) p);
330 	}
331 	
332 	/**
333 	 * Frees the given list and all associated values.
334 	 */
335 	public void free()
336 	{
337 		// void gst_tag_list_free (GstTagList *list);
338 		gst_tag_list_free(gstTagList);
339 	}
340 	
341 	/**
342 	 * Checks how many value are stored in this tag list for the given tag.
343 	 * Params:
344 	 * tag = the tag to query
345 	 * Returns: The number of tags stored
346 	 */
347 	public uint getTagSize(string tag)
348 	{
349 		// guint gst_tag_list_get_tag_size (const GstTagList *list,  const gchar *tag);
350 		return gst_tag_list_get_tag_size(gstTagList, Str.toStringz(tag));
351 	}
352 	
353 	/**
354 	 * Sets the values for the given tags using the specified mode.
355 	 * Params:
356 	 * list = list to set tags in
357 	 * mode = the mode to use
358 	 * tag = tag
359 	 * varArgs = tag / value pairs to set
360 	 */
361 	public void addValist(GstTagMergeMode mode, string tag, void* varArgs)
362 	{
363 		// void gst_tag_list_add_valist (GstTagList *list,  GstTagMergeMode mode,  const gchar *tag,  va_list var_args);
364 		gst_tag_list_add_valist(gstTagList, mode, Str.toStringz(tag), varArgs);
365 	}
366 	
367 	/**
368 	 * Sets the GValues for the given tags using the specified mode.
369 	 * Params:
370 	 * list = list to set tags in
371 	 * mode = the mode to use
372 	 * tag = tag
373 	 * varArgs = tag / GValue pairs to set
374 	 */
375 	public void addValistValues(GstTagMergeMode mode, string tag, void* varArgs)
376 	{
377 		// void gst_tag_list_add_valist_values (GstTagList *list,  GstTagMergeMode mode,  const gchar *tag,  va_list var_args);
378 		gst_tag_list_add_valist_values(gstTagList, mode, Str.toStringz(tag), varArgs);
379 	}
380 	
381 	/**
382 	 * Removes the given tag from the taglist.
383 	 * Params:
384 	 * tag = tag to remove
385 	 */
386 	public void removeTag(string tag)
387 	{
388 		// void gst_tag_list_remove_tag (GstTagList *list,  const gchar *tag);
389 		gst_tag_list_remove_tag(gstTagList, Str.toStringz(tag));
390 	}
391 	
392 	/**
393 	 * Calls the given function for each tag inside the tag list. Note that if there
394 	 * is no tag, the function won't be called at all.
395 	 * Params:
396 	 * func = function to be called for each tag
397 	 * userData = user specified data
398 	 */
399 	public void foreac(GstTagForeachFunc func, void* userData)
400 	{
401 		// void gst_tag_list_foreach (const GstTagList *list,  GstTagForeachFunc func,  gpointer user_data);
402 		gst_tag_list_foreach(gstTagList, func, userData);
403 	}
404 	
405 	/**
406 	 * Gets the value that is at the given index for the given tag in the given
407 	 * list.
408 	 * Params:
409 	 * tag = tag to read out
410 	 * index = number of entry to read out
411 	 * Returns: The GValue for the specified entry or NULL if the tag wasn't available or the tag doesn't have as many entries
412 	 */
413 	public Value getValueIndex(string tag, uint index)
414 	{
415 		// const GValue* gst_tag_list_get_value_index (const GstTagList *list,  const gchar *tag,  guint index);
416 		auto p = gst_tag_list_get_value_index(gstTagList, Str.toStringz(tag), index);
417 		
418 		if(p is null)
419 		{
420 			return null;
421 		}
422 		
423 		return ObjectG.getDObject!(Value)(cast(GValue*) p);
424 	}
425 	
426 	/**
427 	 * Copies the contents for the given tag into the value,
428 	 * merging multiple values into one if multiple values are associated
429 	 * with the tag.
430 	 * You must g_value_unset() the value after use.
431 	 * Params:
432 	 * dest = uninitialized GValue to copy into
433 	 * list = list to get the tag from
434 	 * tag = tag to read out
435 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
436 	 */
437 	public static int copyValue(Value dest, TagList list, string tag)
438 	{
439 		// gboolean gst_tag_list_copy_value (GValue *dest,  const GstTagList *list,  const gchar *tag);
440 		return gst_tag_list_copy_value((dest is null) ? null : dest.getValueStruct(), (list is null) ? null : list.getTagListStruct(), Str.toStringz(tag));
441 	}
442 	
443 	/**
444 	 * Copies the contents for the given tag into the value, merging multiple values
445 	 * into one if multiple values are associated with the tag.
446 	 * Params:
447 	 * tag = tag to read out
448 	 * value = location for the result
449 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
450 	 */
451 	public int getChar(string tag, string value)
452 	{
453 		// gboolean gst_tag_list_get_char (const GstTagList *list,  const gchar *tag,  gchar *value);
454 		return gst_tag_list_get_char(gstTagList, Str.toStringz(tag), Str.toStringz(value));
455 	}
456 	
457 	/**
458 	 * Gets the value that is at the given index for the given tag in the given
459 	 * list.
460 	 * Params:
461 	 * tag = tag to read out
462 	 * index = number of entry to read out
463 	 * value = location for the result
464 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
465 	 */
466 	public int getCharIndex(string tag, uint index, string value)
467 	{
468 		// gboolean gst_tag_list_get_char_index (const GstTagList *list,  const gchar *tag,  guint index,  gchar *value);
469 		return gst_tag_list_get_char_index(gstTagList, Str.toStringz(tag), index, Str.toStringz(value));
470 	}
471 	
472 	/**
473 	 * Copies the contents for the given tag into the value, merging multiple values
474 	 * into one if multiple values are associated with the tag.
475 	 * Params:
476 	 * tag = tag to read out
477 	 * value = location for the result
478 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
479 	 */
480 	public int getUchar(string tag, ref char value)
481 	{
482 		// gboolean gst_tag_list_get_uchar (const GstTagList *list,  const gchar *tag,  guchar *value);
483 		return gst_tag_list_get_uchar(gstTagList, Str.toStringz(tag), &value);
484 	}
485 	
486 	/**
487 	 * Gets the value that is at the given index for the given tag in the given
488 	 * list.
489 	 * Params:
490 	 * tag = tag to read out
491 	 * index = number of entry to read out
492 	 * value = location for the result
493 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
494 	 */
495 	public int getUcharIndex(string tag, uint index, ref char value)
496 	{
497 		// gboolean gst_tag_list_get_uchar_index (const GstTagList *list,  const gchar *tag,  guint index,  guchar *value);
498 		return gst_tag_list_get_uchar_index(gstTagList, Str.toStringz(tag), index, &value);
499 	}
500 	
501 	/**
502 	 * Copies the contents for the given tag into the value, merging multiple values
503 	 * into one if multiple values are associated with the tag.
504 	 * Params:
505 	 * tag = tag to read out
506 	 * value = location for the result
507 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
508 	 */
509 	public int getBoolean(string tag, ref int value)
510 	{
511 		// gboolean gst_tag_list_get_boolean (const GstTagList *list,  const gchar *tag,  gboolean *value);
512 		return gst_tag_list_get_boolean(gstTagList, Str.toStringz(tag), &value);
513 	}
514 	
515 	/**
516 	 * Gets the value that is at the given index for the given tag in the given
517 	 * list.
518 	 * Params:
519 	 * tag = tag to read out
520 	 * index = number of entry to read out
521 	 * value = location for the result
522 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
523 	 */
524 	public int getBooleanIndex(string tag, uint index, ref int value)
525 	{
526 		// gboolean gst_tag_list_get_boolean_index (const GstTagList *list,  const gchar *tag,  guint index,  gboolean *value);
527 		return gst_tag_list_get_boolean_index(gstTagList, Str.toStringz(tag), index, &value);
528 	}
529 	
530 	/**
531 	 * Copies the contents for the given tag into the value, merging multiple values
532 	 * into one if multiple values are associated with the tag.
533 	 * Params:
534 	 * tag = tag to read out
535 	 * value = location for the result
536 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
537 	 */
538 	public int getInt(string tag, ref int value)
539 	{
540 		// gboolean gst_tag_list_get_int (const GstTagList *list,  const gchar *tag,  gint *value);
541 		return gst_tag_list_get_int(gstTagList, Str.toStringz(tag), &value);
542 	}
543 	
544 	/**
545 	 * Gets the value that is at the given index for the given tag in the given
546 	 * list.
547 	 * Params:
548 	 * tag = tag to read out
549 	 * index = number of entry to read out
550 	 * value = location for the result
551 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
552 	 */
553 	public int getIntIndex(string tag, uint index, ref int value)
554 	{
555 		// gboolean gst_tag_list_get_int_index (const GstTagList *list,  const gchar *tag,  guint index,  gint *value);
556 		return gst_tag_list_get_int_index(gstTagList, Str.toStringz(tag), index, &value);
557 	}
558 	
559 	/**
560 	 * Copies the contents for the given tag into the value, merging multiple values
561 	 * into one if multiple values are associated with the tag.
562 	 * Params:
563 	 * tag = tag to read out
564 	 * value = location for the result
565 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
566 	 */
567 	public int getUint(string tag, ref uint value)
568 	{
569 		// gboolean gst_tag_list_get_uint (const GstTagList *list,  const gchar *tag,  guint *value);
570 		return gst_tag_list_get_uint(gstTagList, Str.toStringz(tag), &value);
571 	}
572 	
573 	/**
574 	 * Gets the value that is at the given index for the given tag in the given
575 	 * list.
576 	 * Params:
577 	 * tag = tag to read out
578 	 * index = number of entry to read out
579 	 * value = location for the result
580 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
581 	 */
582 	public int getUintIndex(string tag, uint index, ref uint value)
583 	{
584 		// gboolean gst_tag_list_get_uint_index (const GstTagList *list,  const gchar *tag,  guint index,  guint *value);
585 		return gst_tag_list_get_uint_index(gstTagList, Str.toStringz(tag), index, &value);
586 	}
587 	
588 	/**
589 	 * Copies the contents for the given tag into the value, merging multiple values
590 	 * into one if multiple values are associated with the tag.
591 	 * Params:
592 	 * tag = tag to read out
593 	 * value = location for the result
594 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
595 	 */
596 	public int getLong(string tag, ref glong value)
597 	{
598 		// gboolean gst_tag_list_get_long (const GstTagList *list,  const gchar *tag,  glong *value);
599 		return gst_tag_list_get_long(gstTagList, Str.toStringz(tag), &value);
600 	}
601 	
602 	/**
603 	 * Gets the value that is at the given index for the given tag in the given
604 	 * list.
605 	 * Params:
606 	 * tag = tag to read out
607 	 * index = number of entry to read out
608 	 * value = location for the result
609 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
610 	 */
611 	public int getLongIndex(string tag, uint index, ref glong value)
612 	{
613 		// gboolean gst_tag_list_get_long_index (const GstTagList *list,  const gchar *tag,  guint index,  glong *value);
614 		return gst_tag_list_get_long_index(gstTagList, Str.toStringz(tag), index, &value);
615 	}
616 	
617 	/**
618 	 * Copies the contents for the given tag into the value, merging multiple values
619 	 * into one if multiple values are associated with the tag.
620 	 * Params:
621 	 * tag = tag to read out
622 	 * value = location for the result
623 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
624 	 */
625 	public int getUlong(string tag, ref gulong value)
626 	{
627 		// gboolean gst_tag_list_get_ulong (const GstTagList *list,  const gchar *tag,  gulong *value);
628 		return gst_tag_list_get_ulong(gstTagList, Str.toStringz(tag), &value);
629 	}
630 	
631 	/**
632 	 * Gets the value that is at the given index for the given tag in the given
633 	 * list.
634 	 * Params:
635 	 * tag = tag to read out
636 	 * index = number of entry to read out
637 	 * value = location for the result
638 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
639 	 */
640 	public int getUlongIndex(string tag, uint index, ref gulong value)
641 	{
642 		// gboolean gst_tag_list_get_ulong_index (const GstTagList *list,  const gchar *tag,  guint index,  gulong *value);
643 		return gst_tag_list_get_ulong_index(gstTagList, Str.toStringz(tag), index, &value);
644 	}
645 	
646 	/**
647 	 * Copies the contents for the given tag into the value, merging multiple values
648 	 * into one if multiple values are associated with the tag.
649 	 * Params:
650 	 * tag = tag to read out
651 	 * value = location for the result
652 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
653 	 */
654 	public int getInt64(string tag, ref long value)
655 	{
656 		// gboolean gst_tag_list_get_int64 (const GstTagList *list,  const gchar *tag,  gint64 *value);
657 		return gst_tag_list_get_int64(gstTagList, Str.toStringz(tag), &value);
658 	}
659 	
660 	/**
661 	 * Gets the value that is at the given index for the given tag in the given
662 	 * list.
663 	 * Params:
664 	 * tag = tag to read out
665 	 * index = number of entry to read out
666 	 * value = location for the result
667 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
668 	 */
669 	public int getInt64_Index(string tag, uint index, ref long value)
670 	{
671 		// gboolean gst_tag_list_get_int64_index (const GstTagList *list,  const gchar *tag,  guint index,  gint64 *value);
672 		return gst_tag_list_get_int64_index(gstTagList, Str.toStringz(tag), index, &value);
673 	}
674 	
675 	/**
676 	 * Copies the contents for the given tag into the value, merging multiple values
677 	 * into one if multiple values are associated with the tag.
678 	 * Params:
679 	 * tag = tag to read out
680 	 * value = location for the result
681 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
682 	 */
683 	public int getUint64(string tag, ref ulong value)
684 	{
685 		// gboolean gst_tag_list_get_uint64 (const GstTagList *list,  const gchar *tag,  guint64 *value);
686 		return gst_tag_list_get_uint64(gstTagList, Str.toStringz(tag), &value);
687 	}
688 	
689 	/**
690 	 * Gets the value that is at the given index for the given tag in the given
691 	 * list.
692 	 * Params:
693 	 * tag = tag to read out
694 	 * index = number of entry to read out
695 	 * value = location for the result
696 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
697 	 */
698 	public int getUint64_Index(string tag, uint index, ref ulong value)
699 	{
700 		// gboolean gst_tag_list_get_uint64_index (const GstTagList *list,  const gchar *tag,  guint index,  guint64 *value);
701 		return gst_tag_list_get_uint64_index(gstTagList, Str.toStringz(tag), index, &value);
702 	}
703 	
704 	/**
705 	 * Copies the contents for the given tag into the value, merging multiple values
706 	 * into one if multiple values are associated with the tag.
707 	 * Params:
708 	 * tag = tag to read out
709 	 * value = location for the result
710 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
711 	 */
712 	public int getFloat(string tag, ref float value)
713 	{
714 		// gboolean gst_tag_list_get_float (const GstTagList *list,  const gchar *tag,  gfloat *value);
715 		return gst_tag_list_get_float(gstTagList, Str.toStringz(tag), &value);
716 	}
717 	
718 	/**
719 	 * Gets the value that is at the given index for the given tag in the given
720 	 * list.
721 	 * Params:
722 	 * tag = tag to read out
723 	 * index = number of entry to read out
724 	 * value = location for the result
725 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
726 	 */
727 	public int getFloatIndex(string tag, uint index, ref float value)
728 	{
729 		// gboolean gst_tag_list_get_float_index (const GstTagList *list,  const gchar *tag,  guint index,  gfloat *value);
730 		return gst_tag_list_get_float_index(gstTagList, Str.toStringz(tag), index, &value);
731 	}
732 	
733 	/**
734 	 * Copies the contents for the given tag into the value, merging multiple values
735 	 * into one if multiple values are associated with the tag.
736 	 * Params:
737 	 * tag = tag to read out
738 	 * value = location for the result
739 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
740 	 */
741 	public int getDouble(string tag, ref double value)
742 	{
743 		// gboolean gst_tag_list_get_double (const GstTagList *list,  const gchar *tag,  gdouble *value);
744 		return gst_tag_list_get_double(gstTagList, Str.toStringz(tag), &value);
745 	}
746 	
747 	/**
748 	 * Gets the value that is at the given index for the given tag in the given
749 	 * list.
750 	 * Params:
751 	 * tag = tag to read out
752 	 * index = number of entry to read out
753 	 * value = location for the result
754 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
755 	 */
756 	public int getDoubleIndex(string tag, uint index, ref double value)
757 	{
758 		// gboolean gst_tag_list_get_double_index (const GstTagList *list,  const gchar *tag,  guint index,  gdouble *value);
759 		return gst_tag_list_get_double_index(gstTagList, Str.toStringz(tag), index, &value);
760 	}
761 	
762 	/**
763 	 * Copies the contents for the given tag into the value, possibly merging
764 	 * multiple values into one if multiple values are associated with the tag.
765 	 * Use gst_tag_list_get_string_index (list, tag, 0, value) if you want
766 	 * to retrieve the first string associated with this tag unmodified.
767 	 * The resulting string in value should be freed by the caller using g_free
768 	 * when no longer needed
769 	 * Params:
770 	 * tag = tag to read out
771 	 * value = location for the result
772 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
773 	 */
774 	public int getString(string tag, ref string value)
775 	{
776 		// gboolean gst_tag_list_get_string (const GstTagList *list,  const gchar *tag,  gchar **value);
777 		char* outvalue = Str.toStringz(value);
778 		
779 		auto p = gst_tag_list_get_string(gstTagList, Str.toStringz(tag), &outvalue);
780 		
781 		value = Str.toString(outvalue);
782 		return p;
783 	}
784 	
785 	/**
786 	 * Gets the value that is at the given index for the given tag in the given
787 	 * list.
788 	 * The resulting string in value should be freed by the caller using g_free
789 	 * when no longer needed
790 	 * Params:
791 	 * tag = tag to read out
792 	 * index = number of entry to read out
793 	 * value = location for the result
794 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
795 	 */
796 	public int getStringIndex(string tag, uint index, ref string value)
797 	{
798 		// gboolean gst_tag_list_get_string_index (const GstTagList *list,  const gchar *tag,  guint index,  gchar **value);
799 		char* outvalue = Str.toStringz(value);
800 		
801 		auto p = gst_tag_list_get_string_index(gstTagList, Str.toStringz(tag), index, &outvalue);
802 		
803 		value = Str.toString(outvalue);
804 		return p;
805 	}
806 	
807 	/**
808 	 * Copies the contents for the given tag into the value, merging multiple values
809 	 * into one if multiple values are associated with the tag.
810 	 * Params:
811 	 * tag = tag to read out
812 	 * value = location for the result
813 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
814 	 */
815 	public int getPointer(string tag, void** value)
816 	{
817 		// gboolean gst_tag_list_get_pointer (const GstTagList *list,  const gchar *tag,  gpointer *value);
818 		return gst_tag_list_get_pointer(gstTagList, Str.toStringz(tag), value);
819 	}
820 	
821 	/**
822 	 * Gets the value that is at the given index for the given tag in the given
823 	 * list.
824 	 * Params:
825 	 * tag = tag to read out
826 	 * index = number of entry to read out
827 	 * value = location for the result
828 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list.
829 	 */
830 	public int getPointerIndex(string tag, uint index, void** value)
831 	{
832 		// gboolean gst_tag_list_get_pointer_index (const GstTagList *list,  const gchar *tag,  guint index,  gpointer *value);
833 		return gst_tag_list_get_pointer_index(gstTagList, Str.toStringz(tag), index, value);
834 	}
835 	
836 	/**
837 	 * Copies the contents for the given tag into the value, merging multiple values
838 	 * into one if multiple values are associated with the tag.
839 	 * Params:
840 	 * tag = tag to read out
841 	 * value = location for the result
842 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list or if it was NULL.
843 	 */
844 	public int getDate(string tag, ref Date value)
845 	{
846 		// gboolean gst_tag_list_get_date (const GstTagList *list,  const gchar *tag,  GDate **value);
847 		GDate* outvalue = (value is null) ? null : value.getDateStruct();
848 		
849 		auto p = gst_tag_list_get_date(gstTagList, Str.toStringz(tag), &outvalue);
850 		
851 		value = ObjectG.getDObject!(Date)(outvalue);
852 		return p;
853 	}
854 	
855 	/**
856 	 * Gets the value that is at the given index for the given tag in the given
857 	 * list.
858 	 * Params:
859 	 * tag = tag to read out
860 	 * index = number of entry to read out
861 	 * value = location for the result
862 	 * Returns: TRUE, if a value was copied, FALSE if the tag didn't exist in the given list or if it was NULL.
863 	 */
864 	public int getDateIndex(string tag, uint index, ref Date value)
865 	{
866 		// gboolean gst_tag_list_get_date_index (const GstTagList *list,  const gchar *tag,  guint index,  GDate **value);
867 		GDate* outvalue = (value is null) ? null : value.getDateStruct();
868 		
869 		auto p = gst_tag_list_get_date_index(gstTagList, Str.toStringz(tag), index, &outvalue);
870 		
871 		value = ObjectG.getDObject!(Date)(outvalue);
872 		return p;
873 	}
874 }