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 module gstreamer.ValueGst;
26 
27 private import glib.Str;
28 private import gobject.ObjectG;
29 private import gobject.Value;
30 private import gstreamer.Caps;
31 private import gstreamer.CapsFeatures;
32 private import gstreamer.Structure;
33 private import gstreamerc.gstreamer;
34 public  import gstreamerc.gstreamertypes;
35 
36 
37 /** */
38 public struct ValueGst
39 {
40 
41 	/**
42 	 * Determines if @value1 and @value2 can be compared.
43 	 *
44 	 * Params:
45 	 *     value1 = a value to compare
46 	 *     value2 = another value to compare
47 	 *
48 	 * Return: %TRUE if the values can be compared
49 	 */
50 	public static bool canCompare(Value value1, Value value2)
51 	{
52 		return gst_value_can_compare((value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct()) != 0;
53 	}
54 
55 	/**
56 	 * Determines if intersecting two values will produce a valid result.
57 	 * Two values will produce a valid intersection if they have the same
58 	 * type.
59 	 *
60 	 * Params:
61 	 *     value1 = a value to intersect
62 	 *     value2 = another value to intersect
63 	 *
64 	 * Return: %TRUE if the values can intersect
65 	 */
66 	public static bool canIntersect(Value value1, Value value2)
67 	{
68 		return gst_value_can_intersect((value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct()) != 0;
69 	}
70 
71 	/**
72 	 * Checks if it's possible to subtract @subtrahend from @minuend.
73 	 *
74 	 * Params:
75 	 *     minuend = the value to subtract from
76 	 *     subtrahend = the value to subtract
77 	 *
78 	 * Return: %TRUE if a subtraction is possible
79 	 */
80 	public static bool canSubtract(Value minuend, Value subtrahend)
81 	{
82 		return gst_value_can_subtract((minuend is null) ? null : minuend.getValueStruct(), (subtrahend is null) ? null : subtrahend.getValueStruct()) != 0;
83 	}
84 
85 	/**
86 	 * Determines if @value1 and @value2 can be non-trivially unioned.
87 	 * Any two values can be trivially unioned by adding both of them
88 	 * to a GstValueList.  However, certain types have the possibility
89 	 * to be unioned in a simpler way.  For example, an integer range
90 	 * and an integer can be unioned if the integer is a subset of the
91 	 * integer range.  If there is the possibility that two values can
92 	 * be unioned, this function returns %TRUE.
93 	 *
94 	 * Params:
95 	 *     value1 = a value to union
96 	 *     value2 = another value to union
97 	 *
98 	 * Return: %TRUE if there is a function allowing the two values to
99 	 *     be unioned.
100 	 */
101 	public static bool canUnion(Value value1, Value value2)
102 	{
103 		return gst_value_can_union((value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct()) != 0;
104 	}
105 
106 	/**
107 	 * Compares @value1 and @value2.  If @value1 and @value2 cannot be
108 	 * compared, the function returns GST_VALUE_UNORDERED.  Otherwise,
109 	 * if @value1 is greater than @value2, GST_VALUE_GREATER_THAN is returned.
110 	 * If @value1 is less than @value2, GST_VALUE_LESS_THAN is returned.
111 	 * If the values are equal, GST_VALUE_EQUAL is returned.
112 	 *
113 	 * Params:
114 	 *     value1 = a value to compare
115 	 *     value2 = another value to compare
116 	 *
117 	 * Return: comparison result
118 	 */
119 	public static int compare(Value value1, Value value2)
120 	{
121 		return gst_value_compare((value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct());
122 	}
123 
124 	/**
125 	 * Tries to deserialize a string into the type specified by the given GValue.
126 	 * If the operation succeeds, %TRUE is returned, %FALSE otherwise.
127 	 *
128 	 * Params:
129 	 *     dest = #GValue to fill with contents of
130 	 *         deserialization
131 	 *     src = string to deserialize
132 	 *
133 	 * Return: %TRUE on success
134 	 */
135 	public static bool deserialize(out Value dest, string src)
136 	{
137 		GValue* outdest = gMalloc!GValue();
138 		
139 		auto p = gst_value_deserialize(outdest, Str.toStringz(src)) != 0;
140 		
141 		dest = ObjectG.getDObject!(Value)(outdest, true);
142 		
143 		return p;
144 	}
145 
146 	/**
147 	 * Fixate @src into a new value @dest.
148 	 * For ranges, the first element is taken. For lists and arrays, the
149 	 * first item is fixated and returned.
150 	 * If @src is already fixed, this function returns %FALSE.
151 	 *
152 	 * Params:
153 	 *     dest = the #GValue destination
154 	 *     src = the #GValue to fixate
155 	 *
156 	 * Return: %TRUE if @dest contains a fixated version of @src.
157 	 */
158 	public static bool fixate(Value dest, Value src)
159 	{
160 		return gst_value_fixate((dest is null) ? null : dest.getValueStruct(), (src is null) ? null : src.getValueStruct()) != 0;
161 	}
162 
163 	/**
164 	 * Multiplies the two #GValue items containing a #GST_TYPE_FRACTION and sets
165 	 * @product to the product of the two fractions.
166 	 *
167 	 * Params:
168 	 *     product = a GValue initialized to #GST_TYPE_FRACTION
169 	 *     factor1 = a GValue initialized to #GST_TYPE_FRACTION
170 	 *     factor2 = a GValue initialized to #GST_TYPE_FRACTION
171 	 *
172 	 * Return: %FALSE in case of an error (like integer overflow), %TRUE otherwise.
173 	 */
174 	public static bool fractionMultiply(Value product, Value factor1, Value factor2)
175 	{
176 		return gst_value_fraction_multiply((product is null) ? null : product.getValueStruct(), (factor1 is null) ? null : factor1.getValueStruct(), (factor2 is null) ? null : factor2.getValueStruct()) != 0;
177 	}
178 
179 	/**
180 	 * Subtracts the @subtrahend from the @minuend and sets @dest to the result.
181 	 *
182 	 * Params:
183 	 *     dest = a GValue initialized to #GST_TYPE_FRACTION
184 	 *     minuend = a GValue initialized to #GST_TYPE_FRACTION
185 	 *     subtrahend = a GValue initialized to #GST_TYPE_FRACTION
186 	 *
187 	 * Return: %FALSE in case of an error (like integer overflow), %TRUE otherwise.
188 	 */
189 	public static bool fractionSubtract(Value dest, Value minuend, Value subtrahend)
190 	{
191 		return gst_value_fraction_subtract((dest is null) ? null : dest.getValueStruct(), (minuend is null) ? null : minuend.getValueStruct(), (subtrahend is null) ? null : subtrahend.getValueStruct()) != 0;
192 	}
193 
194 	/**
195 	 * Gets the bitmask specified by @value.
196 	 *
197 	 * Params:
198 	 *     value = a GValue initialized to #GST_TYPE_BITMASK
199 	 *
200 	 * Return: the bitmask.
201 	 */
202 	public static ulong getBitmask(Value value)
203 	{
204 		return gst_value_get_bitmask((value is null) ? null : value.getValueStruct());
205 	}
206 
207 	/**
208 	 * Gets the contents of @value. The reference count of the returned
209 	 * #GstCaps will not be modified, therefore the caller must take one
210 	 * before getting rid of the @value.
211 	 *
212 	 * Params:
213 	 *     value = a GValue initialized to GST_TYPE_CAPS
214 	 *
215 	 * Return: the contents of @value
216 	 */
217 	public static Caps getCaps(Value value)
218 	{
219 		auto p = gst_value_get_caps((value is null) ? null : value.getValueStruct());
220 		
221 		if(p is null)
222 		{
223 			return null;
224 		}
225 		
226 		return ObjectG.getDObject!(Caps)(cast(GstCaps*) p);
227 	}
228 
229 	/**
230 	 * Gets the contents of @value.
231 	 *
232 	 * Params:
233 	 *     value = a GValue initialized to GST_TYPE_CAPS_FEATURES
234 	 *
235 	 * Return: the contents of @value
236 	 */
237 	public static CapsFeatures getCapsFeatures(Value value)
238 	{
239 		auto p = gst_value_get_caps_features((value is null) ? null : value.getValueStruct());
240 		
241 		if(p is null)
242 		{
243 			return null;
244 		}
245 		
246 		return ObjectG.getDObject!(CapsFeatures)(cast(GstCapsFeatures*) p);
247 	}
248 
249 	/**
250 	 * Gets the maximum of the range specified by @value.
251 	 *
252 	 * Params:
253 	 *     value = a GValue initialized to GST_TYPE_DOUBLE_RANGE
254 	 *
255 	 * Return: the maximum of the range
256 	 */
257 	public static double getDoubleRangeMax(Value value)
258 	{
259 		return gst_value_get_double_range_max((value is null) ? null : value.getValueStruct());
260 	}
261 
262 	/**
263 	 * Gets the minimum of the range specified by @value.
264 	 *
265 	 * Params:
266 	 *     value = a GValue initialized to GST_TYPE_DOUBLE_RANGE
267 	 *
268 	 * Return: the minimum of the range
269 	 */
270 	public static double getDoubleRangeMin(Value value)
271 	{
272 		return gst_value_get_double_range_min((value is null) ? null : value.getValueStruct());
273 	}
274 
275 	/**
276 	 * Retrieve the flags field of a GstFlagSet @value.
277 	 *
278 	 * Params:
279 	 *     value = a GValue initialized to #GST_TYPE_FLAG_SET
280 	 *
281 	 * Return: the flags field of the flagset instance.
282 	 *
283 	 * Since: 1.6
284 	 */
285 	public static uint getFlagsetFlags(Value value)
286 	{
287 		return gst_value_get_flagset_flags((value is null) ? null : value.getValueStruct());
288 	}
289 
290 	/**
291 	 * Retrieve the mask field of a GstFlagSet @value.
292 	 *
293 	 * Params:
294 	 *     value = a GValue initialized to #GST_TYPE_FLAG_SET
295 	 *
296 	 * Return: the mask field of the flagset instance.
297 	 *
298 	 * Since: 1.6
299 	 */
300 	public static uint getFlagsetMask(Value value)
301 	{
302 		return gst_value_get_flagset_mask((value is null) ? null : value.getValueStruct());
303 	}
304 
305 	/**
306 	 * Sets @value to the flags and mask values provided in @flags and @mask.
307 	 * The @flags value indicates the values of flags, the @mask represents
308 	 * which bits in the flag value have been set, and which are "don't care"
309 	 *
310 	 * Params:
311 	 *     value = a GValue initialized to %GST_TYPE_FLAG_SET
312 	 *     flags = The value of the flags set or unset
313 	 *     mask = The mask indicate which flags bits must match for comparisons
314 	 *
315 	 * Since: 1.6
316 	 */
317 	public static void setFlagset(Value value, uint flags, uint mask)
318 	{
319 		gst_value_set_flagset((value is null) ? null : value.getValueStruct(), flags, mask);
320 	}
321 
322 	/**
323 	 * Gets the denominator of the fraction specified by @value.
324 	 *
325 	 * Params:
326 	 *     value = a GValue initialized to #GST_TYPE_FRACTION
327 	 *
328 	 * Return: the denominator of the fraction.
329 	 */
330 	public static int getFractionDenominator(Value value)
331 	{
332 		return gst_value_get_fraction_denominator((value is null) ? null : value.getValueStruct());
333 	}
334 
335 	/**
336 	 * Gets the numerator of the fraction specified by @value.
337 	 *
338 	 * Params:
339 	 *     value = a GValue initialized to #GST_TYPE_FRACTION
340 	 *
341 	 * Return: the numerator of the fraction.
342 	 */
343 	public static int getFractionNumerator(Value value)
344 	{
345 		return gst_value_get_fraction_numerator((value is null) ? null : value.getValueStruct());
346 	}
347 
348 	/**
349 	 * Gets the maximum of the range specified by @value.
350 	 *
351 	 * Params:
352 	 *     value = a GValue initialized to GST_TYPE_FRACTION_RANGE
353 	 *
354 	 * Return: the maximum of the range
355 	 */
356 	public static Value getFractionRangeMax(Value value)
357 	{
358 		auto p = gst_value_get_fraction_range_max((value is null) ? null : value.getValueStruct());
359 		
360 		if(p is null)
361 		{
362 			return null;
363 		}
364 		
365 		return ObjectG.getDObject!(Value)(cast(GValue*) p);
366 	}
367 
368 	/**
369 	 * Gets the minimum of the range specified by @value.
370 	 *
371 	 * Params:
372 	 *     value = a GValue initialized to GST_TYPE_FRACTION_RANGE
373 	 *
374 	 * Return: the minimum of the range
375 	 */
376 	public static Value getFractionRangeMin(Value value)
377 	{
378 		auto p = gst_value_get_fraction_range_min((value is null) ? null : value.getValueStruct());
379 		
380 		if(p is null)
381 		{
382 			return null;
383 		}
384 		
385 		return ObjectG.getDObject!(Value)(cast(GValue*) p);
386 	}
387 
388 	/**
389 	 * Gets the maximum of the range specified by @value.
390 	 *
391 	 * Params:
392 	 *     value = a GValue initialized to GST_TYPE_INT64_RANGE
393 	 *
394 	 * Return: the maximum of the range
395 	 */
396 	public static long getInt64RangeMax(Value value)
397 	{
398 		return gst_value_get_int64_range_max((value is null) ? null : value.getValueStruct());
399 	}
400 
401 	/**
402 	 * Gets the minimum of the range specified by @value.
403 	 *
404 	 * Params:
405 	 *     value = a GValue initialized to GST_TYPE_INT64_RANGE
406 	 *
407 	 * Return: the minimum of the range
408 	 */
409 	public static long getInt64RangeMin(Value value)
410 	{
411 		return gst_value_get_int64_range_min((value is null) ? null : value.getValueStruct());
412 	}
413 
414 	/**
415 	 * Gets the step of the range specified by @value.
416 	 *
417 	 * Params:
418 	 *     value = a GValue initialized to GST_TYPE_INT64_RANGE
419 	 *
420 	 * Return: the step of the range
421 	 */
422 	public static long getInt64RangeStep(Value value)
423 	{
424 		return gst_value_get_int64_range_step((value is null) ? null : value.getValueStruct());
425 	}
426 
427 	/**
428 	 * Gets the maximum of the range specified by @value.
429 	 *
430 	 * Params:
431 	 *     value = a GValue initialized to GST_TYPE_INT_RANGE
432 	 *
433 	 * Return: the maximum of the range
434 	 */
435 	public static int getIntRangeMax(Value value)
436 	{
437 		return gst_value_get_int_range_max((value is null) ? null : value.getValueStruct());
438 	}
439 
440 	/**
441 	 * Gets the minimum of the range specified by @value.
442 	 *
443 	 * Params:
444 	 *     value = a GValue initialized to GST_TYPE_INT_RANGE
445 	 *
446 	 * Return: the minimum of the range
447 	 */
448 	public static int getIntRangeMin(Value value)
449 	{
450 		return gst_value_get_int_range_min((value is null) ? null : value.getValueStruct());
451 	}
452 
453 	/**
454 	 * Gets the step of the range specified by @value.
455 	 *
456 	 * Params:
457 	 *     value = a GValue initialized to GST_TYPE_INT_RANGE
458 	 *
459 	 * Return: the step of the range
460 	 */
461 	public static int getIntRangeStep(Value value)
462 	{
463 		return gst_value_get_int_range_step((value is null) ? null : value.getValueStruct());
464 	}
465 
466 	/**
467 	 * Gets the contents of @value.
468 	 *
469 	 * Params:
470 	 *     value = a GValue initialized to GST_TYPE_STRUCTURE
471 	 *
472 	 * Return: the contents of @value
473 	 */
474 	public static Structure getStructure(Value value)
475 	{
476 		auto p = gst_value_get_structure((value is null) ? null : value.getValueStruct());
477 		
478 		if(p is null)
479 		{
480 			return null;
481 		}
482 		
483 		return ObjectG.getDObject!(Structure)(cast(GstStructure*) p);
484 	}
485 
486 	/**
487 	 * Initialises the target value to be of the same type as source and then copies
488 	 * the contents from source to target.
489 	 *
490 	 * Params:
491 	 *     dest = the target value
492 	 *     src = the source value
493 	 */
494 	public static void initAndCopy(out Value dest, Value src)
495 	{
496 		GValue* outdest = gMalloc!GValue();
497 		
498 		gst_value_init_and_copy(outdest, (src is null) ? null : src.getValueStruct());
499 		
500 		dest = ObjectG.getDObject!(Value)(outdest, true);
501 	}
502 
503 	/**
504 	 * Calculates the intersection of two values.  If the values have
505 	 * a non-empty intersection, the value representing the intersection
506 	 * is placed in @dest, unless %NULL.  If the intersection is non-empty,
507 	 * @dest is not modified.
508 	 *
509 	 * Params:
510 	 *     dest = a uninitialized #GValue that will hold the calculated
511 	 *         intersection value. May be %NULL if the resulting set if not
512 	 *         needed.
513 	 *     value1 = a value to intersect
514 	 *     value2 = another value to intersect
515 	 *
516 	 * Return: %TRUE if the intersection is non-empty
517 	 */
518 	public static bool intersect(out Value dest, Value value1, Value value2)
519 	{
520 		GValue* outdest = gMalloc!GValue();
521 		
522 		auto p = gst_value_intersect(outdest, (value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct()) != 0;
523 		
524 		dest = ObjectG.getDObject!(Value)(outdest, true);
525 		
526 		return p;
527 	}
528 
529 	/**
530 	 * Tests if the given GValue, if available in a GstStructure (or any other
531 	 * container) contains a "fixed" (which means: one value) or an "unfixed"
532 	 * (which means: multiple possible values, such as data lists or data
533 	 * ranges) value.
534 	 *
535 	 * Params:
536 	 *     value = the #GValue to check
537 	 *
538 	 * Return: true if the value is "fixed".
539 	 */
540 	public static bool isFixed(Value value)
541 	{
542 		return gst_value_is_fixed((value is null) ? null : value.getValueStruct()) != 0;
543 	}
544 
545 	/**
546 	 * Check that @value1 is a subset of @value2.
547 	 *
548 	 * Params:
549 	 *     value1 = a #GValue
550 	 *     value2 = a #GValue
551 	 *
552 	 * Return: %TRUE is @value1 is a subset of @value2
553 	 */
554 	public static bool isSubset(Value value1, Value value2)
555 	{
556 		return gst_value_is_subset((value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct()) != 0;
557 	}
558 
559 	/**
560 	 * Registers functions to perform calculations on #GValue items of a given
561 	 * type. Each type can only be added once.
562 	 *
563 	 * Params:
564 	 *     table = structure containing functions to register
565 	 */
566 	public static void register(GstValueTable* table)
567 	{
568 		gst_value_register(table);
569 	}
570 
571 	/**
572 	 * tries to transform the given @value into a string representation that allows
573 	 * getting back this string later on using gst_value_deserialize().
574 	 *
575 	 * Free-function: g_free
576 	 *
577 	 * Params:
578 	 *     value = a #GValue to serialize
579 	 *
580 	 * Return: the serialization for @value
581 	 *     or %NULL if none exists
582 	 */
583 	public static string serialize(Value value)
584 	{
585 		auto retStr = gst_value_serialize((value is null) ? null : value.getValueStruct());
586 		
587 		scope(exit) Str.freeString(retStr);
588 		return Str.toString(retStr);
589 	}
590 
591 	/**
592 	 * Sets @value to the bitmask specified by @bitmask.
593 	 *
594 	 * Params:
595 	 *     value = a GValue initialized to #GST_TYPE_BITMASK
596 	 *     bitmask = the bitmask
597 	 */
598 	public static void setBitmask(Value value, ulong bitmask)
599 	{
600 		gst_value_set_bitmask((value is null) ? null : value.getValueStruct(), bitmask);
601 	}
602 
603 	/**
604 	 * Sets the contents of @value to @caps. A reference to the
605 	 * provided @caps will be taken by the @value.
606 	 *
607 	 * Params:
608 	 *     value = a GValue initialized to GST_TYPE_CAPS
609 	 *     caps = the caps to set the value to
610 	 */
611 	public static void setCaps(Value value, Caps caps)
612 	{
613 		gst_value_set_caps((value is null) ? null : value.getValueStruct(), (caps is null) ? null : caps.getCapsStruct());
614 	}
615 
616 	/**
617 	 * Sets the contents of @value to @features.
618 	 *
619 	 * Params:
620 	 *     value = a GValue initialized to GST_TYPE_CAPS_FEATURES
621 	 *     features = the features to set the value to
622 	 */
623 	public static void setCapsFeatures(Value value, CapsFeatures features)
624 	{
625 		gst_value_set_caps_features((value is null) ? null : value.getValueStruct(), (features is null) ? null : features.getCapsFeaturesStruct());
626 	}
627 
628 	/**
629 	 * Sets @value to the range specified by @start and @end.
630 	 *
631 	 * Params:
632 	 *     value = a GValue initialized to GST_TYPE_DOUBLE_RANGE
633 	 *     start = the start of the range
634 	 *     end = the end of the range
635 	 */
636 	public static void setDoubleRange(Value value, double start, double end)
637 	{
638 		gst_value_set_double_range((value is null) ? null : value.getValueStruct(), start, end);
639 	}
640 
641 	/**
642 	 * Sets @value to the fraction specified by @numerator over @denominator.
643 	 * The fraction gets reduced to the smallest numerator and denominator,
644 	 * and if necessary the sign is moved to the numerator.
645 	 *
646 	 * Params:
647 	 *     value = a GValue initialized to #GST_TYPE_FRACTION
648 	 *     numerator = the numerator of the fraction
649 	 *     denominator = the denominator of the fraction
650 	 */
651 	public static void setFraction(Value value, int numerator, int denominator)
652 	{
653 		gst_value_set_fraction((value is null) ? null : value.getValueStruct(), numerator, denominator);
654 	}
655 
656 	/**
657 	 * Sets @value to the range specified by @start and @end.
658 	 *
659 	 * Params:
660 	 *     value = a GValue initialized to GST_TYPE_FRACTION_RANGE
661 	 *     start = the start of the range (a GST_TYPE_FRACTION GValue)
662 	 *     end = the end of the range (a GST_TYPE_FRACTION GValue)
663 	 */
664 	public static void setFractionRange(Value value, Value start, Value end)
665 	{
666 		gst_value_set_fraction_range((value is null) ? null : value.getValueStruct(), (start is null) ? null : start.getValueStruct(), (end is null) ? null : end.getValueStruct());
667 	}
668 
669 	/**
670 	 * Sets @value to the range specified by @numerator_start/@denominator_start
671 	 * and @numerator_end/@denominator_end.
672 	 *
673 	 * Params:
674 	 *     value = a GValue initialized to GST_TYPE_FRACTION_RANGE
675 	 *     numeratorStart = the numerator start of the range
676 	 *     denominatorStart = the denominator start of the range
677 	 *     numeratorEnd = the numerator end of the range
678 	 *     denominatorEnd = the denominator end of the range
679 	 */
680 	public static void setFractionRangeFull(Value value, int numeratorStart, int denominatorStart, int numeratorEnd, int denominatorEnd)
681 	{
682 		gst_value_set_fraction_range_full((value is null) ? null : value.getValueStruct(), numeratorStart, denominatorStart, numeratorEnd, denominatorEnd);
683 	}
684 
685 	/**
686 	 * Sets @value to the range specified by @start and @end.
687 	 *
688 	 * Params:
689 	 *     value = a GValue initialized to GST_TYPE_INT64_RANGE
690 	 *     start = the start of the range
691 	 *     end = the end of the range
692 	 */
693 	public static void setInt64Range(Value value, long start, long end)
694 	{
695 		gst_value_set_int64_range((value is null) ? null : value.getValueStruct(), start, end);
696 	}
697 
698 	/**
699 	 * Sets @value to the range specified by @start, @end and @step.
700 	 *
701 	 * Params:
702 	 *     value = a GValue initialized to GST_TYPE_INT64_RANGE
703 	 *     start = the start of the range
704 	 *     end = the end of the range
705 	 *     step = the step of the range
706 	 */
707 	public static void setInt64RangeStep(Value value, long start, long end, long step)
708 	{
709 		gst_value_set_int64_range_step((value is null) ? null : value.getValueStruct(), start, end, step);
710 	}
711 
712 	/**
713 	 * Sets @value to the range specified by @start and @end.
714 	 *
715 	 * Params:
716 	 *     value = a GValue initialized to GST_TYPE_INT_RANGE
717 	 *     start = the start of the range
718 	 *     end = the end of the range
719 	 */
720 	public static void setIntRange(Value value, int start, int end)
721 	{
722 		gst_value_set_int_range((value is null) ? null : value.getValueStruct(), start, end);
723 	}
724 
725 	/**
726 	 * Sets @value to the range specified by @start, @end and @step.
727 	 *
728 	 * Params:
729 	 *     value = a GValue initialized to GST_TYPE_INT_RANGE
730 	 *     start = the start of the range
731 	 *     end = the end of the range
732 	 *     step = the step of the range
733 	 */
734 	public static void setIntRangeStep(Value value, int start, int end, int step)
735 	{
736 		gst_value_set_int_range_step((value is null) ? null : value.getValueStruct(), start, end, step);
737 	}
738 
739 	/**
740 	 * Sets the contents of @value to @structure.
741 	 *
742 	 * Params:
743 	 *     value = a GValue initialized to GST_TYPE_STRUCTURE
744 	 *     structure = the structure to set the value to
745 	 */
746 	public static void setStructure(Value value, Structure structure)
747 	{
748 		gst_value_set_structure((value is null) ? null : value.getValueStruct(), (structure is null) ? null : structure.getStructureStruct());
749 	}
750 
751 	/**
752 	 * Subtracts @subtrahend from @minuend and stores the result in @dest.
753 	 * Note that this means subtraction as in sets, not as in mathematics.
754 	 *
755 	 * Params:
756 	 *     dest = the destination value
757 	 *         for the result if the subtraction is not empty. May be %NULL,
758 	 *         in which case the resulting set will not be computed, which can
759 	 *         give a fair speedup.
760 	 *     minuend = the value to subtract from
761 	 *     subtrahend = the value to subtract
762 	 *
763 	 * Return: %TRUE if the subtraction is not empty
764 	 */
765 	public static bool subtract(out Value dest, Value minuend, Value subtrahend)
766 	{
767 		GValue* outdest = gMalloc!GValue();
768 		
769 		auto p = gst_value_subtract(outdest, (minuend is null) ? null : minuend.getValueStruct(), (subtrahend is null) ? null : subtrahend.getValueStruct()) != 0;
770 		
771 		dest = ObjectG.getDObject!(Value)(outdest, true);
772 		
773 		return p;
774 	}
775 
776 	/**
777 	 * Creates a GValue corresponding to the union of @value1 and @value2.
778 	 *
779 	 * Params:
780 	 *     dest = the destination value
781 	 *     value1 = a value to union
782 	 *     value2 = another value to union
783 	 *
784 	 * Return: %TRUE if the union succeeded.
785 	 */
786 	public static bool unio(out Value dest, Value value1, Value value2)
787 	{
788 		GValue* outdest = gMalloc!GValue();
789 		
790 		auto p = gst_value_union(outdest, (value1 is null) ? null : value1.getValueStruct(), (value2 is null) ? null : value2.getValueStruct()) != 0;
791 		
792 		dest = ObjectG.getDObject!(Value)(outdest, true);
793 		
794 		return p;
795 	}
796 }