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 }