1 /* GStreamer

     2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

     3  *                    2000 Wim Taymans <wtay@chello.be>

     4  *                    2002 Thomas Vander Stichele <thomas@apestaart.org>

     5  *

     6  * gstutils.c: Utility functions: gtk_get_property stuff, etc.

     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:gstutils

    26  * @short_description: Various utility functions

    27  *

    28  * When defining own plugins, use the GST_BOILERPLATE ease gobject creation.

    29  */

    30 

    31 #include "gst_private.h"

    32 #include <stdio.h>

    33 #include <string.h>

    34 

    35 #include "gstghostpad.h"

    36 #include "gstutils.h"

    37 #include "gsterror.h"

    38 #include "gstinfo.h"

    39 #include "gstparse.h"

    40 #include "gst-i18n-lib.h"

    41 

    42 #ifdef __SYMBIAN32__

    43 #include <glib_global.h>

    44 #include <gobject_global.h>

    45 #endif

    46 

    47 

    48 /**

    49  * gst_util_dump_mem:

    50  * @mem: a pointer to the memory to dump

    51  * @size: the size of the memory block to dump

    52  *

    53  * Dumps the memory block into a hex representation. Useful for debugging.

    54  */

    55 #ifdef __SYMBIAN32__

    56 EXPORT_C

    57 #endif

    58 

    59 void

    60 gst_util_dump_mem (const guchar * mem, guint size)

    61 {

    62   guint i, j;

    63   GString *string = g_string_sized_new (50);

    64   GString *chars = g_string_sized_new (18);

    65 

    66   i = j = 0;

    67   while (i < size) {

    68     if (g_ascii_isprint (mem[i]))

    69       g_string_append_c (chars, mem[i]);

    70     else

    71       g_string_append_c (chars, '.');

    72 

    73     g_string_append_printf (string, "%02x ", mem[i]);

    74 

    75     j++;

    76     i++;

    77 

    78     if (j == 16 || i == size) {

    79       g_print ("%08x (%p): %-48.48s %-16.16s\n", i - j, mem + i - j,

    80           string->str, chars->str);

    81       g_string_set_size (string, 0);

    82       g_string_set_size (chars, 0);

    83       j = 0;

    84     }

    85   }

    86   g_string_free (string, TRUE);

    87   g_string_free (chars, TRUE);

    88 }

    89 

    90 

    91 /**

    92  * gst_util_set_value_from_string:

    93  * @value: the value to set

    94  * @value_str: the string to get the value from

    95  *

    96  * Converts the string to the type of the value and

    97  * sets the value with it.

    98  */

    99 #ifdef __SYMBIAN32__

   100 EXPORT_C

   101 #endif

   102 

   103 void

   104 gst_util_set_value_from_string (GValue * value, const gchar * value_str)

   105 {

   106   gint sscanf_ret;

   107 

   108   g_return_if_fail (value != NULL);

   109   g_return_if_fail (value_str != NULL);

   110 

   111   GST_CAT_DEBUG (GST_CAT_PARAMS, "parsing '%s' to type %s", value_str,

   112       g_type_name (G_VALUE_TYPE (value)));

   113 

   114   switch (G_VALUE_TYPE (value)) {

   115     case G_TYPE_STRING:

   116       g_value_set_string (value, value_str);

   117       break;

   118     case G_TYPE_ENUM:

   119     case G_TYPE_INT:{

   120       gint i;

   121 

   122       sscanf_ret = sscanf (value_str, "%d", &i);

   123       g_return_if_fail (sscanf_ret == 1);

   124       g_value_set_int (value, i);

   125       break;

   126     }

   127     case G_TYPE_UINT:{

   128       guint i;

   129 

   130       sscanf_ret = sscanf (value_str, "%u", &i);

   131       g_return_if_fail (sscanf_ret == 1);

   132       g_value_set_uint (value, i);

   133       break;

   134     }

   135     case G_TYPE_LONG:{

   136       glong i;

   137 

   138       sscanf_ret = sscanf (value_str, "%ld", &i);

   139       g_return_if_fail (sscanf_ret == 1);

   140       g_value_set_long (value, i);

   141       break;

   142     }

   143     case G_TYPE_ULONG:{

   144       gulong i;

   145 

   146       sscanf_ret = sscanf (value_str, "%lu", &i);

   147       g_return_if_fail (sscanf_ret == 1);

   148       g_value_set_ulong (value, i);

   149       break;

   150     }

   151     case G_TYPE_BOOLEAN:{

   152       gboolean i = FALSE;

   153 

   154       if (!g_ascii_strncasecmp ("true", value_str, 4))

   155         i = TRUE;

   156       g_value_set_boolean (value, i);

   157       break;

   158     }

   159     case G_TYPE_CHAR:{

   160       gchar i;

   161 

   162       sscanf_ret = sscanf (value_str, "%c", &i);

   163       g_return_if_fail (sscanf_ret == 1);

   164       g_value_set_char (value, i);

   165       break;

   166     }

   167     case G_TYPE_UCHAR:{

   168       guchar i;

   169 

   170       sscanf_ret = sscanf (value_str, "%c", &i);

   171       g_return_if_fail (sscanf_ret == 1);

   172       g_value_set_uchar (value, i);

   173       break;

   174     }

   175     case G_TYPE_FLOAT:{

   176       gfloat i;

   177 

   178       sscanf_ret = sscanf (value_str, "%f", &i);

   179       g_return_if_fail (sscanf_ret == 1);

   180       g_value_set_float (value, i);

   181       break;

   182     }

   183     case G_TYPE_DOUBLE:{

   184       gfloat i;

   185 

   186       sscanf_ret = sscanf (value_str, "%g", &i);

   187       g_return_if_fail (sscanf_ret == 1);

   188       g_value_set_double (value, (gdouble) i);

   189       break;

   190     }

   191     default:

   192       break;

   193   }

   194 }

   195 

   196 /**

   197  * gst_util_set_object_arg:

   198  * @object: the object to set the argument of

   199  * @name: the name of the argument to set

   200  * @value: the string value to set

   201  *

   202  * Convertes the string value to the type of the objects argument and

   203  * sets the argument with it.

   204  */

   205 #ifdef __SYMBIAN32__

   206 EXPORT_C

   207 #endif

   208 

   209 void

   210 gst_util_set_object_arg (GObject * object, const gchar * name,

   211     const gchar * value)

   212 {

   213   gboolean sscanf_ret;

   214 

   215   if (name && value) {

   216     GParamSpec *paramspec;

   217 

   218     paramspec =

   219         g_object_class_find_property (G_OBJECT_GET_CLASS (object), name);

   220 

   221     if (!paramspec) {

   222       return;

   223     }

   224 

   225     GST_DEBUG ("paramspec->flags is %d, paramspec->value_type is %d",

   226         paramspec->flags, (gint) paramspec->value_type);

   227 

   228     if (paramspec->flags & G_PARAM_WRITABLE) {

   229       switch (paramspec->value_type) {

   230         case G_TYPE_STRING:

   231           g_object_set (G_OBJECT (object), name, value, NULL);

   232           break;

   233         case G_TYPE_ENUM:

   234         case G_TYPE_INT:{

   235           gint i;

   236 

   237           sscanf_ret = sscanf (value, "%d", &i);

   238           g_return_if_fail (sscanf_ret == 1);

   239           g_object_set (G_OBJECT (object), name, i, NULL);

   240           break;

   241         }

   242         case G_TYPE_UINT:{

   243           guint i;

   244 

   245           sscanf_ret = sscanf (value, "%u", &i);

   246           g_return_if_fail (sscanf_ret == 1);

   247           g_object_set (G_OBJECT (object), name, i, NULL);

   248           break;

   249         }

   250         case G_TYPE_LONG:{

   251           glong i;

   252 

   253           sscanf_ret = sscanf (value, "%ld", &i);

   254           g_return_if_fail (sscanf_ret == 1);

   255           g_object_set (G_OBJECT (object), name, i, NULL);

   256           break;

   257         }

   258         case G_TYPE_ULONG:{

   259           gulong i;

   260 

   261           sscanf_ret = sscanf (value, "%lu", &i);

   262           g_return_if_fail (sscanf_ret == 1);

   263           g_object_set (G_OBJECT (object), name, i, NULL);

   264           break;

   265         }

   266         case G_TYPE_BOOLEAN:{

   267           gboolean i = FALSE;

   268 

   269           if (!g_ascii_strncasecmp ("true", value, 4))

   270             i = TRUE;

   271           g_object_set (G_OBJECT (object), name, i, NULL);

   272           break;

   273         }

   274         case G_TYPE_CHAR:{

   275           gchar i;

   276 

   277           sscanf_ret = sscanf (value, "%c", &i);

   278           g_return_if_fail (sscanf_ret == 1);

   279           g_object_set (G_OBJECT (object), name, i, NULL);

   280           break;

   281         }

   282         case G_TYPE_UCHAR:{

   283           guchar i;

   284 

   285           sscanf_ret = sscanf (value, "%c", &i);

   286           g_return_if_fail (sscanf_ret == 1);

   287           g_object_set (G_OBJECT (object), name, i, NULL);

   288           break;

   289         }

   290         case G_TYPE_FLOAT:{

   291           gfloat i;

   292 

   293           sscanf_ret = sscanf (value, "%f", &i);

   294           g_return_if_fail (sscanf_ret == 1);

   295           g_object_set (G_OBJECT (object), name, i, NULL);

   296           break;

   297         }

   298         case G_TYPE_DOUBLE:{

   299           gfloat i;

   300 

   301           sscanf_ret = sscanf (value, "%g", &i);

   302           g_return_if_fail (sscanf_ret == 1);

   303           g_object_set (G_OBJECT (object), name, (gdouble) i, NULL);

   304           break;

   305         }

   306         default:

   307           if (G_IS_PARAM_SPEC_ENUM (paramspec)) {

   308             gint i;

   309 

   310             sscanf_ret = sscanf (value, "%d", &i);

   311             g_return_if_fail (sscanf_ret == 1);

   312             g_object_set (G_OBJECT (object), name, i, NULL);

   313           }

   314           break;

   315       }

   316     }

   317   }

   318 }

   319 

   320 /* work around error C2520: conversion from unsigned __int64 to double

   321  * not implemented, use signed __int64

   322  *

   323  * These are implemented as functions because on some platforms a 64bit int to

   324  * double conversion is not defined/implemented.

   325  */

   326 #ifdef __SYMBIAN32__

   327 EXPORT_C

   328 #endif

   329 

   330 

   331 gdouble

   332 gst_util_guint64_to_gdouble (guint64 value)

   333 {

   334   if (value & G_GINT64_CONSTANT (0x8000000000000000))

   335     return (gdouble) ((gint64) value) + (gdouble) 18446744073709551616.;

   336   else

   337     return (gdouble) ((gint64) value);

   338 }

   339 #ifdef __SYMBIAN32__

   340 EXPORT_C

   341 #endif

   342 

   343 

   344 guint64

   345 gst_util_gdouble_to_guint64 (gdouble value)

   346 {

   347   if (value < (gdouble) 9223372036854775808.)   /* 1 << 63 */

   348     return ((guint64) ((gint64) value));

   349 

   350   value -= (gdouble) 18446744073709551616.;

   351   return ((guint64) ((gint64) value));

   352 }

   353 

   354 /* convenience struct for getting high and low uint32 parts of

   355  * a guint64 */

   356 typedef union

   357 {

   358   guint64 ll;

   359   struct

   360   {

   361 #if G_BYTE_ORDER == G_BIG_ENDIAN

   362     guint32 high, low;

   363 #else

   364     guint32 low, high;

   365 #endif

   366   } l;

   367 } GstUInt64;

   368 

   369 /* based on Hacker's Delight p152 */

   370 static guint64

   371 gst_util_div128_64 (GstUInt64 c1, GstUInt64 c0, guint64 denom)

   372 {

   373   GstUInt64 q1, q0, rhat;

   374   GstUInt64 v, cmp1, cmp2;

   375   guint s;

   376 

   377   v.ll = denom;

   378 

   379   /* count number of leading zeroes, we know they must be in the high

   380    * part of denom since denom > G_MAXUINT32. */

   381   s = v.l.high | (v.l.high >> 1);

   382   s |= (s >> 2);

   383   s |= (s >> 4);

   384   s |= (s >> 8);

   385   s = ~(s | (s >> 16));

   386   s = s - ((s >> 1) & 0x55555555);

   387   s = (s & 0x33333333) + ((s >> 2) & 0x33333333);

   388   s = (s + (s >> 4)) & 0x0f0f0f0f;

   389   s += (s >> 8);

   390   s = (s + (s >> 16)) & 0x3f;

   391 

   392   if (s > 0) {

   393     /* normalize divisor and dividend */

   394     v.ll <<= s;

   395     c1.ll = (c1.ll << s) | (c0.l.high >> (32 - s));

   396     c0.ll <<= s;

   397   }

   398 

   399   q1.ll = c1.ll / v.l.high;

   400   rhat.ll = c1.ll - q1.ll * v.l.high;

   401 

   402   cmp1.l.high = rhat.l.low;

   403   cmp1.l.low = c0.l.high;

   404   cmp2.ll = q1.ll * v.l.low;

   405 

   406   while (q1.l.high || cmp2.ll > cmp1.ll) {

   407     q1.ll--;

   408     rhat.ll += v.l.high;

   409     if (rhat.l.high)

   410       break;

   411     cmp1.l.high = rhat.l.low;

   412     cmp2.ll -= v.l.low;

   413   }

   414   c1.l.high = c1.l.low;

   415   c1.l.low = c0.l.high;

   416   c1.ll -= q1.ll * v.ll;

   417   q0.ll = c1.ll / v.l.high;

   418   rhat.ll = c1.ll - q0.ll * v.l.high;

   419 

   420   cmp1.l.high = rhat.l.low;

   421   cmp1.l.low = c0.l.low;

   422   cmp2.ll = q0.ll * v.l.low;

   423 

   424   while (q0.l.high || cmp2.ll > cmp1.ll) {

   425     q0.ll--;

   426     rhat.ll += v.l.high;

   427     if (rhat.l.high)

   428       break;

   429     cmp1.l.high = rhat.l.low;

   430     cmp2.ll -= v.l.low;

   431   }

   432   q0.l.high += q1.l.low;

   433 

   434   return q0.ll;

   435 }

   436 

   437 static guint64

   438 gst_util_uint64_scale_int64 (guint64 val, guint64 num, guint64 denom)

   439 {

   440   GstUInt64 a0, a1, b0, b1, c0, ct, c1, result;

   441   GstUInt64 v, n;

   442 

   443   /* prepare input */

   444   v.ll = val;

   445   n.ll = num;

   446 

   447   /* do 128 bits multiply

   448    *                   nh   nl

   449    *                *  vh   vl

   450    *                ----------

   451    * a0 =              vl * nl

   452    * a1 =         vl * nh

   453    * b0 =         vh * nl

   454    * b1 =  + vh * nh

   455    *       -------------------

   456    * c1,c0

   457    */

   458   a0.ll = (guint64) v.l.low * n.l.low;

   459   a1.ll = (guint64) v.l.low * n.l.high;

   460   b0.ll = (guint64) v.l.high * n.l.low;

   461   b1.ll = (guint64) v.l.high * n.l.high;

   462 

   463   /* and sum together with carry into 128 bits c1, c0 */

   464   c0.l.low = a0.l.low;

   465   ct.ll = (guint64) a0.l.high + a1.l.low + b0.l.low;

   466   c0.l.high = ct.l.low;

   467   c1.ll = (guint64) a1.l.high + b0.l.high + ct.l.high + b1.ll;

   468 

   469   /* if high bits bigger than denom, we overflow */

   470   if (c1.ll >= denom)

   471     goto overflow;

   472 

   473   /* shortcut for division by 1, c1.ll should be 0 because of the

   474    * overflow check above. */

   475   if (denom == 1)

   476     return c0.ll;

   477 

   478   /* and 128/64 bits division, result fits 64 bits */

   479   if (denom <= G_MAXUINT32) {

   480     guint32 den = (guint32) denom;

   481 

   482     /* easy case, (c1,c0)128/(den)32 division */

   483     c1.l.high %= den;

   484     c1.l.high = c1.ll % den;

   485     c1.l.low = c0.l.high;

   486     c0.l.high = c1.ll % den;

   487     result.l.high = c1.ll / den;

   488     result.l.low = c0.ll / den;

   489   } else {

   490     result.ll = gst_util_div128_64 (c1, c0, denom);

   491   }

   492   return result.ll;

   493 

   494 overflow:

   495   {

   496     return G_MAXUINT64;

   497   }

   498 }

   499 

   500 /**

   501  * gst_util_uint64_scale:

   502  * @val: the number to scale

   503  * @num: the numerator of the scale ratio

   504  * @denom: the denominator of the scale ratio

   505  *

   506  * Scale @val by @num / @denom, trying to avoid overflows.

   507  *

   508  * This function can potentially be very slow if denom > G_MAXUINT32.

   509  *

   510  * Returns: @val * @num / @denom, trying to avoid overflows.

   511  * In the case of an overflow, this function returns G_MAXUINT64.

   512  */

   513 #ifdef __SYMBIAN32__

   514 EXPORT_C

   515 #endif

   516 

   517 guint64

   518 gst_util_uint64_scale (guint64 val, guint64 num, guint64 denom)

   519 {

   520   g_return_val_if_fail (denom != 0, G_MAXUINT64);

   521 

   522   if (num == 0)

   523     return 0;

   524 

   525   if (num == 1 && denom == 1)

   526     return val;

   527 

   528   /* if the denom is high, we need to do a 64 muldiv */

   529   if (denom > G_MAXINT32)

   530     goto do_int64;

   531 

   532   /* if num and denom are low we can do a 32 bit muldiv */

   533   if (num <= G_MAXINT32)

   534     goto do_int32;

   535 

   536   /* val and num are high, we need 64 muldiv */

   537   if (val > G_MAXINT32)

   538     goto do_int64;

   539 

   540   /* val is low and num is high, we can swap them and do 32 muldiv */

   541   return gst_util_uint64_scale_int (num, (gint) val, (gint) denom);

   542 

   543 do_int32:

   544   return gst_util_uint64_scale_int (val, (gint) num, (gint) denom);

   545 

   546 do_int64:

   547   /* to the more heavy implementations... */

   548   return gst_util_uint64_scale_int64 (val, num, denom);

   549 }

   550 

   551 /**

   552  * gst_util_uint64_scale_int:

   553  * @val: guint64 (such as a #GstClockTime) to scale.

   554  * @num: numerator of the scale factor.

   555  * @denom: denominator of the scale factor.

   556  *

   557  * Scale a guint64 by a factor expressed as a fraction (num/denom), avoiding

   558  * overflows and loss of precision.

   559  *

   560  * @num and @denom must be positive integers. @denom cannot be 0.

   561  *

   562  * Returns: @val * @num / @denom, avoiding overflow and loss of precision.

   563  * In the case of an overflow, this function returns G_MAXUINT64.

   564  */

   565 #ifdef __SYMBIAN32__

   566 EXPORT_C

   567 #endif

   568 

   569 guint64

   570 gst_util_uint64_scale_int (guint64 val, gint num, gint denom)

   571 {

   572   GstUInt64 result;

   573   GstUInt64 low, high;

   574 

   575   g_return_val_if_fail (denom > 0, G_MAXUINT64);

   576   g_return_val_if_fail (num >= 0, G_MAXUINT64);

   577 

   578   if (num == 0)

   579     return 0;

   580 

   581   if (num == 1 && denom == 1)

   582     return val;

   583 

   584   if (val <= G_MAXUINT32)

   585     /* simple case */

   586     return val * num / denom;

   587 

   588   /* do 96 bits mult/div */

   589   low.ll = val;

   590   result.ll = ((guint64) low.l.low) * num;

   591   high.ll = ((guint64) low.l.high) * num + (result.l.high);

   592 

   593   low.ll = high.ll / denom;

   594   result.l.high = high.ll % denom;

   595   result.ll /= denom;

   596 

   597   /* avoid overflow */

   598   if (low.ll + result.l.high > G_MAXUINT32)

   599     goto overflow;

   600 

   601   result.l.high += low.l.low;

   602 

   603   return result.ll;

   604 

   605 overflow:

   606   {

   607     return G_MAXUINT64;

   608   }

   609 }

   610 

   611 /* -----------------------------------------------------

   612  *

   613  *  The following code will be moved out of the main

   614  * gstreamer library someday.

   615  */

   616 

   617 #include "gstpad.h"

   618 

   619 static void

   620 string_append_indent (GString * str, gint count)

   621 {

   622   gint xx;

   623 

   624   for (xx = 0; xx < count; xx++)

   625     g_string_append_c (str, ' ');

   626 }

   627 

   628 /**

   629  * gst_print_pad_caps:

   630  * @buf: the buffer to print the caps in

   631  * @indent: initial indentation

   632  * @pad: the pad to print the caps from

   633  *

   634  * Write the pad capabilities in a human readable format into

   635  * the given GString.

   636  */

   637 #ifdef __SYMBIAN32__

   638 EXPORT_C

   639 #endif

   640 

   641 void

   642 gst_print_pad_caps (GString * buf, gint indent, GstPad * pad)

   643 {

   644   GstCaps *caps;

   645 

   646   caps = pad->caps;

   647 

   648   if (!caps) {

   649     string_append_indent (buf, indent);

   650     g_string_printf (buf, "%s:%s has no capabilities",

   651         GST_DEBUG_PAD_NAME (pad));

   652   } else {

   653     char *s;

   654 

   655     s = gst_caps_to_string (caps);

   656     g_string_append (buf, s);

   657     g_free (s);

   658   }

   659 }

   660 

   661 /**

   662  * gst_print_element_args:

   663  * @buf: the buffer to print the args in

   664  * @indent: initial indentation

   665  * @element: the element to print the args of

   666  *

   667  * Print the element argument in a human readable format in the given

   668  * GString.

   669  */

   670 #ifdef __SYMBIAN32__

   671 EXPORT_C

   672 #endif

   673 

   674 void

   675 gst_print_element_args (GString * buf, gint indent, GstElement * element)

   676 {

   677   guint width;

   678   GValue value = { 0, };        /* the important thing is that value.type = 0 */

   679   gchar *str = NULL;

   680   GParamSpec *spec, **specs, **walk;

   681 

   682   specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (element), NULL);

   683 

   684   width = 0;

   685   for (walk = specs; *walk; walk++) {

   686     spec = *walk;

   687     if (width < strlen (spec->name))

   688       width = strlen (spec->name);

   689   }

   690 

   691   for (walk = specs; *walk; walk++) {

   692     spec = *walk;

   693 

   694     if (spec->flags & G_PARAM_READABLE) {

   695       g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (spec));

   696       g_object_get_property (G_OBJECT (element), spec->name, &value);

   697       str = g_strdup_value_contents (&value);

   698       g_value_unset (&value);

   699     } else {

   700       str = g_strdup ("Parameter not readable.");

   701     }

   702 

   703     string_append_indent (buf, indent);

   704     g_string_append (buf, spec->name);

   705     string_append_indent (buf, 2 + width - strlen (spec->name));

   706     g_string_append (buf, str);

   707     g_string_append_c (buf, '\n');

   708 

   709     g_free (str);

   710   }

   711 

   712   g_free (specs);

   713 }

   714 

   715 /**

   716  * gst_element_create_all_pads:

   717  * @element: a #GstElement to create pads for

   718  *

   719  * Creates a pad for each pad template that is always available.

   720  * This function is only useful during object intialization of

   721  * subclasses of #GstElement.

   722  */

   723 #ifdef __SYMBIAN32__

   724 EXPORT_C

   725 #endif

   726 

   727 void

   728 gst_element_create_all_pads (GstElement * element)

   729 {

   730   GList *padlist;

   731 

   732   /* FIXME: lock element */

   733 

   734   padlist =

   735       gst_element_class_get_pad_template_list (GST_ELEMENT_CLASS

   736       (G_OBJECT_GET_CLASS (element)));

   737 

   738   while (padlist) {

   739     GstPadTemplate *padtempl = (GstPadTemplate *) padlist->data;

   740 

   741     if (padtempl->presence == GST_PAD_ALWAYS) {

   742       GstPad *pad;

   743 

   744       pad = gst_pad_new_from_template (padtempl, padtempl->name_template);

   745 

   746       gst_element_add_pad (element, pad);

   747     }

   748     padlist = padlist->next;

   749   }

   750 }

   751 

   752 /**

   753  * gst_element_get_compatible_pad_template:

   754  * @element: a #GstElement to get a compatible pad template for.

   755  * @compattempl: the #GstPadTemplate to find a compatible template for.

   756  *

   757  * Retrieves a pad template from @element that is compatible with @compattempl.

   758  * Pads from compatible templates can be linked together.

   759  *

   760  * Returns: a compatible #GstPadTemplate, or NULL if none was found. No

   761  * unreferencing is necessary.

   762  */

   763 #ifdef __SYMBIAN32__

   764 EXPORT_C

   765 #endif

   766 

   767 GstPadTemplate *

   768 gst_element_get_compatible_pad_template (GstElement * element,

   769     GstPadTemplate * compattempl)

   770 {

   771   GstPadTemplate *newtempl = NULL;

   772   GList *padlist;

   773   GstElementClass *class;

   774 

   775   g_return_val_if_fail (element != NULL, NULL);

   776   g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

   777   g_return_val_if_fail (compattempl != NULL, NULL);

   778 

   779   class = GST_ELEMENT_GET_CLASS (element);

   780 

   781   padlist = gst_element_class_get_pad_template_list (class);

   782 

   783   GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,

   784       "Looking for a suitable pad template in %s out of %d templates...",

   785       GST_ELEMENT_NAME (element), g_list_length (padlist));

   786 

   787   while (padlist) {

   788     GstPadTemplate *padtempl = (GstPadTemplate *) padlist->data;

   789     GstCaps *intersection;

   790 

   791     /* Ignore name

   792      * Ignore presence

   793      * Check direction (must be opposite)

   794      * Check caps

   795      */

   796     GST_CAT_LOG (GST_CAT_CAPS,

   797         "checking pad template %s", padtempl->name_template);

   798     if (padtempl->direction != compattempl->direction) {

   799       GST_CAT_DEBUG (GST_CAT_CAPS,

   800           "compatible direction: found %s pad template \"%s\"",

   801           padtempl->direction == GST_PAD_SRC ? "src" : "sink",

   802           padtempl->name_template);

   803 

   804       GST_CAT_DEBUG (GST_CAT_CAPS,

   805           "intersecting %" GST_PTR_FORMAT, GST_PAD_TEMPLATE_CAPS (compattempl));

   806       GST_CAT_DEBUG (GST_CAT_CAPS,

   807           "..and %" GST_PTR_FORMAT, GST_PAD_TEMPLATE_CAPS (padtempl));

   808 

   809       intersection = gst_caps_intersect (GST_PAD_TEMPLATE_CAPS (compattempl),

   810           GST_PAD_TEMPLATE_CAPS (padtempl));

   811 

   812       GST_CAT_DEBUG (GST_CAT_CAPS, "caps are %scompatible %" GST_PTR_FORMAT,

   813           (intersection ? "" : "not "), intersection);

   814 

   815       if (!gst_caps_is_empty (intersection))

   816         newtempl = padtempl;

   817       gst_caps_unref (intersection);

   818       if (newtempl)

   819         break;

   820     }

   821 

   822     padlist = g_list_next (padlist);

   823   }

   824   if (newtempl)

   825     GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,

   826         "Returning new pad template %p", newtempl);

   827   else

   828     GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "No compatible pad template found");

   829 

   830   return newtempl;

   831 }

   832 

   833 static GstPad *

   834 gst_element_request_pad (GstElement * element, GstPadTemplate * templ,

   835     const gchar * name)

   836 {

   837   GstPad *newpad = NULL;

   838   GstElementClass *oclass;

   839 

   840   oclass = GST_ELEMENT_GET_CLASS (element);

   841 

   842   if (oclass->request_new_pad)

   843     newpad = (oclass->request_new_pad) (element, templ, name);

   844 

   845   if (newpad)

   846     gst_object_ref (newpad);

   847 

   848   return newpad;

   849 }

   850 

   851 

   852 

   853 /**

   854  * gst_element_get_pad_from_template:

   855  * @element: a #GstElement.

   856  * @templ: a #GstPadTemplate belonging to @element.

   857  *

   858  * Gets a pad from @element described by @templ. If the presence of @templ is

   859  * #GST_PAD_REQUEST, requests a new pad. Can return %NULL for #GST_PAD_SOMETIMES

   860  * templates.

   861  *

   862  * Returns: the #GstPad, or NULL if one could not be found or created.

   863  */

   864 static GstPad *

   865 gst_element_get_pad_from_template (GstElement * element, GstPadTemplate * templ)

   866 {

   867   GstPad *ret = NULL;

   868   GstPadPresence presence;

   869 

   870   /* If this function is ever exported, we need check the validity of `element'

   871    * and `templ', and to make sure the template actually belongs to the

   872    * element. */

   873 

   874   presence = GST_PAD_TEMPLATE_PRESENCE (templ);

   875 

   876   switch (presence) {

   877     case GST_PAD_ALWAYS:

   878     case GST_PAD_SOMETIMES:

   879       ret = gst_element_get_static_pad (element, templ->name_template);

   880       if (!ret && presence == GST_PAD_ALWAYS)

   881         g_warning

   882             ("Element %s has an ALWAYS template %s, but no pad of the same name",

   883             GST_OBJECT_NAME (element), templ->name_template);

   884       break;

   885 

   886     case GST_PAD_REQUEST:

   887       ret = gst_element_request_pad (element, templ, NULL);

   888       break;

   889   }

   890 

   891   return ret;

   892 }

   893 

   894 /**

   895  * gst_element_request_compatible_pad:

   896  * @element: a #GstElement.

   897  * @templ: the #GstPadTemplate to which the new pad should be able to link.

   898  *

   899  * Requests a pad from @element. The returned pad should be unlinked and

   900  * compatible with @templ. Might return an existing pad, or request a new one.

   901  *

   902  * Returns: a #GstPad, or %NULL if one could not be found or created.

   903  */

   904 #ifdef __SYMBIAN32__

   905 EXPORT_C

   906 #endif

   907 

   908 GstPad *

   909 gst_element_request_compatible_pad (GstElement * element,

   910     GstPadTemplate * templ)

   911 {

   912   GstPadTemplate *templ_new;

   913   GstPad *pad = NULL;

   914 

   915   g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

   916   g_return_val_if_fail (GST_IS_PAD_TEMPLATE (templ), NULL);

   917 

   918   /* FIXME: should really loop through the templates, testing each for

   919    *      compatibility and pad availability. */

   920   templ_new = gst_element_get_compatible_pad_template (element, templ);

   921   if (templ_new)

   922     pad = gst_element_get_pad_from_template (element, templ_new);

   923 

   924   /* This can happen for non-request pads. No need to unref. */

   925   if (pad && GST_PAD_PEER (pad))

   926     pad = NULL;

   927 

   928   return pad;

   929 }

   930 

   931 /**

   932  * gst_element_get_compatible_pad:

   933  * @element: a #GstElement in which the pad should be found.

   934  * @pad: the #GstPad to find a compatible one for.

   935  * @caps: the #GstCaps to use as a filter.

   936  *

   937  * Looks for an unlinked pad to which the given pad can link. It is not

   938  * guaranteed that linking the pads will work, though it should work in most

   939  * cases.

   940  *

   941  * Returns: the #GstPad to which a link can be made, or %NULL if one cannot be

   942  * found. gst_object_unref() after usage.

   943  */

   944 #ifdef __SYMBIAN32__

   945 EXPORT_C

   946 #endif

   947 

   948 GstPad *

   949 gst_element_get_compatible_pad (GstElement * element, GstPad * pad,

   950     const GstCaps * caps)

   951 {

   952   GstIterator *pads;

   953   GstPadTemplate *templ;

   954   GstCaps *templcaps;

   955   GstPad *foundpad = NULL;

   956   gboolean done;

   957 

   958   /* FIXME check for caps compatibility */

   959 

   960   g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);

   961   g_return_val_if_fail (GST_IS_PAD (pad), NULL);

   962 

   963   GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,

   964       "finding pad in %s compatible with %s:%s",

   965       GST_ELEMENT_NAME (element), GST_DEBUG_PAD_NAME (pad));

   966 

   967   g_return_val_if_fail (GST_PAD_PEER (pad) == NULL, NULL);

   968 

   969   done = FALSE;

   970   /* try to get an existing unlinked pad */

   971   pads = gst_element_iterate_pads (element);

   972   while (!done) {

   973     gpointer padptr;

   974 

   975     switch (gst_iterator_next (pads, &padptr)) {

   976       case GST_ITERATOR_OK:

   977       {

   978         GstPad *peer;

   979         GstPad *current;

   980 

   981         current = GST_PAD (padptr);

   982 

   983         GST_CAT_LOG (GST_CAT_ELEMENT_PADS, "examining pad %s:%s",

   984             GST_DEBUG_PAD_NAME (current));

   985 

   986         peer = gst_pad_get_peer (current);

   987 

   988         if (peer == NULL && gst_pad_can_link (pad, current)) {

   989 

   990           GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,

   991               "found existing unlinked pad %s:%s",

   992               GST_DEBUG_PAD_NAME (current));

   993 

   994           gst_iterator_free (pads);

   995 

   996           return current;

   997         } else {

   998           GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "unreffing pads");

   999 

  1000           gst_object_unref (current);

  1001           if (peer)

  1002             gst_object_unref (peer);

  1003         }

  1004         break;

  1005       }

  1006       case GST_ITERATOR_DONE:

  1007         done = TRUE;

  1008         break;

  1009       case GST_ITERATOR_RESYNC:

  1010         gst_iterator_resync (pads);

  1011         break;

  1012       case GST_ITERATOR_ERROR:

  1013         g_assert_not_reached ();

  1014         break;

  1015     }

  1016   }

  1017   gst_iterator_free (pads);

  1018 

  1019   /* try to create a new one */

  1020   /* requesting is a little crazy, we need a template. Let's create one */

  1021   templcaps = gst_pad_get_caps (pad);

  1022 

  1023   templ = gst_pad_template_new ((gchar *) GST_PAD_NAME (pad),

  1024       GST_PAD_DIRECTION (pad), GST_PAD_ALWAYS, templcaps);

  1025   foundpad = gst_element_request_compatible_pad (element, templ);

  1026   gst_object_unref (templ);

  1027 

  1028   if (foundpad) {

  1029     GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,

  1030         "found existing request pad %s:%s", GST_DEBUG_PAD_NAME (foundpad));

  1031     return foundpad;

  1032   }

  1033 

  1034   GST_CAT_INFO_OBJECT (GST_CAT_ELEMENT_PADS, element,

  1035       "Could not find a compatible pad to link to %s:%s",

  1036       GST_DEBUG_PAD_NAME (pad));

  1037   return NULL;

  1038 }

  1039 

  1040 /**

  1041  * gst_element_state_get_name:

  1042  * @state: a #GstState to get the name of.

  1043  *

  1044  * Gets a string representing the given state.

  1045  *

  1046  * Returns: a string with the name of the state.

  1047  */

  1048 #ifdef __SYMBIAN32__

  1049 EXPORT_C

  1050 #endif

  1051 

  1052 G_CONST_RETURN gchar *

  1053 gst_element_state_get_name (GstState state)

  1054 {

  1055   switch (state) {

  1056 #ifdef GST_DEBUG_COLOR

  1057     case GST_STATE_VOID_PENDING:

  1058       return "VOID_PENDING";

  1059     case GST_STATE_NULL:

  1060       return "\033[01;34mNULL\033[00m";

  1061     case GST_STATE_READY:

  1062       return "\033[01;31mREADY\033[00m";

  1063     case GST_STATE_PLAYING:

  1064       return "\033[01;32mPLAYING\033[00m";

  1065     case GST_STATE_PAUSED:

  1066       return "\033[01;33mPAUSED\033[00m";

  1067     default:

  1068       /* This is a memory leak */

  1069       return g_strdup_printf ("\033[01;35;41mUNKNOWN!\033[00m(%d)", state);

  1070 #else

  1071     case GST_STATE_VOID_PENDING:

  1072       return "VOID_PENDING";

  1073     case GST_STATE_NULL:

  1074       return "NULL";

  1075     case GST_STATE_READY:

  1076       return "READY";

  1077     case GST_STATE_PLAYING:

  1078       return "PLAYING";

  1079     case GST_STATE_PAUSED:

  1080       return "PAUSED";

  1081     default:

  1082       /* This is a memory leak */

  1083       return g_strdup_printf ("UNKNOWN!(%d)", state);

  1084 #endif

  1085   }

  1086 }

  1087 

  1088 /**

  1089  * gst_element_state_change_return_get_name:

  1090  * @state_ret: a #GstStateChangeReturn to get the name of.

  1091  *

  1092  * Gets a string representing the given state change result.

  1093  *

  1094  * Returns: a string with the name of the state change result.

  1095  *

  1096  * Since: 0.10.11

  1097  */

  1098 #ifdef __SYMBIAN32__

  1099 EXPORT_C

  1100 #endif

  1101 

  1102 G_CONST_RETURN gchar *

  1103 gst_element_state_change_return_get_name (GstStateChangeReturn state_ret)

  1104 {

  1105   switch (state_ret) {

  1106 #ifdef GST_DEBUG_COLOR

  1107     case GST_STATE_CHANGE_FAILURE:

  1108       return "\033[01;31mFAILURE\033[00m";

  1109     case GST_STATE_CHANGE_SUCCESS:

  1110       return "\033[01;32mSUCCESS\033[00m";

  1111     case GST_STATE_CHANGE_ASYNC:

  1112       return "\033[01;33mASYNC\033[00m";

  1113     case GST_STATE_CHANGE_NO_PREROLL:

  1114       return "\033[01;34mNO_PREROLL\033[00m";

  1115     default:

  1116       /* This is a memory leak */

  1117       return g_strdup_printf ("\033[01;35;41mUNKNOWN!\033[00m(%d)", state_ret);

  1118 #else

  1119     case GST_STATE_CHANGE_FAILURE:

  1120       return "FAILURE";

  1121     case GST_STATE_CHANGE_SUCCESS:

  1122       return "SUCCESS";

  1123     case GST_STATE_CHANGE_ASYNC:

  1124       return "ASYNC";

  1125     case GST_STATE_CHANGE_NO_PREROLL:

  1126       return "NO PREROLL";

  1127     default:

  1128       /* This is a memory leak */

  1129       return g_strdup_printf ("UNKNOWN!(%d)", state_ret);

  1130 #endif

  1131   }

  1132 }

  1133 

  1134