gstreamer/gst/gstutils.c

541 lines
13 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstutils.c: Utility functions: gtk_get_property stuff, etc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <string.h>
#include "gst_private.h"
#include "gstutils.h"
#include "gstextratypes.h"
#define ZERO(mem) memset(&mem, 0, sizeof(mem))
/**
* gst_util_get_int_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as an integer.
*
* Returns: the property of the object
*/
gint
gst_util_get_int_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_INT);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_int(&value);
}
/**
* gst_util_get_bool_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a boolean.
*
* Returns: the property of the object
*/
gint
gst_util_get_bool_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_BOOLEAN);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_boolean(&value);
}
/**
* gst_util_get_long_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a long.
*
* Returns: the property of the object
*/
glong
gst_util_get_long_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_LONG);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_long(&value);
}
/**
* gst_util_get_float_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a float.
*
* Returns: the property of the object
*/
gfloat
gst_util_get_float_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_FLOAT);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_float(&value);
}
/**
* gst_util_get_double_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a double.
*
* Returns: the property of the object
*/
gdouble
gst_util_get_double_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_DOUBLE);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_double(&value);
}
/**
* gst_util_get_string_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a string.
*
* Returns: the property of the object
*/
const gchar*
gst_util_get_string_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_STRING);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_string(&value); // memleak?
}
/**
* gst_util_get_pointer_arg:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a pointer.
*
* Returns: the property of the object
*/
gpointer
gst_util_get_pointer_arg (GObject *object, const gchar *argname)
{
GValue value;
ZERO (value);
g_value_init (&value, G_TYPE_POINTER);
g_object_get_property(G_OBJECT(object),argname,&value);
return g_value_get_pointer(&value);
}
/**
* gst_util_get_widget_property:
* @object: the object to query
* @argname: the name of the argument
*
* Retrieves a property of an object as a widget.
*
* Returns: the property of the object
*/
/* COMMENTED OUT BECAUSE WE HAVE NO MORE gtk.h
GtkWidget*
gst_util_get_widget_property (GObject *object, const gchar *argname)
{
GtkArg arg;
arg.name = argname;
gtk_object_getv(G_OBJECT(object),1,&arg);
return GTK_WIDGET(G_VALUE_OBJECT(arg));
}
*/
/**
* gst_util_dump_mem:
* @mem: a pointer to the memory to dump
* @size: the size of the memory block to dump
*
* Dumps the memory block into a hex representation. Useful for debugging.
*/
void
gst_util_dump_mem (guchar *mem, guint size)
{
guint i, j;
i = j =0;
while (i<size) {
if (j == 0) {
g_print("\n%08x : ", i);
j = 15;
}
else {
j--;
}
g_print("%02x ", mem[i]);
i++;
}
g_print("\n");
}
/**
* gst_util_set_object_arg:
* @object: the object to set the argument of
* @name: the name of the argument to set
* @value: the string value to set
*
* Convertes the string value to the type of the objects argument and
* sets the argument with it.
*/
void
gst_util_set_object_arg (GObject *object, const gchar *name, const gchar *value)
{
if (name && value) {
GParamSpec *paramspec;
paramspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object),name);
if (!paramspec) {
return;
}
GST_DEBUG(0,"paramspec->flags is %d, paramspec->value_type is %d\n",
paramspec->flags,paramspec->value_type);
if (paramspec->flags & G_PARAM_WRITABLE) {
switch (paramspec->value_type) {
case G_TYPE_STRING:
g_object_set (G_OBJECT (object), name, value, NULL);
break;
case G_TYPE_ENUM:
case G_TYPE_INT: {
gint i;
sscanf (value, "%d", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_UINT: {
guint i;
sscanf (value, "%u", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_LONG: {
glong i;
sscanf (value, "%ld", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_ULONG: {
gulong i;
sscanf (value, "%lu", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_BOOLEAN: {
gboolean i = FALSE;
if (!strncmp ("true", value, 4)) i = TRUE;
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_CHAR: {
gchar i;
sscanf (value, "%c", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_UCHAR: {
guchar i;
sscanf (value, "%c", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_FLOAT: {
gfloat i;
sscanf (value, "%f", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
break;
}
case G_TYPE_DOUBLE: {
gfloat i;
sscanf (value, "%g", &i);
g_object_set (G_OBJECT (object), name, (gdouble)i, NULL);
break;
}
default:
if (G_IS_PARAM_SPEC_ENUM(paramspec)) {
gint i;
sscanf (value, "%d", &i);
g_object_set (G_OBJECT (object), name, i, NULL);
}
else if (paramspec->value_type == GST_TYPE_FILENAME) {
g_object_set (G_OBJECT (object), name, value, NULL);
}
break;
}
}
}
}
// -----------------------------------------------------
//
// The following code will be moved out of the main
// gstreamer library someday.
//
#include "gstpad.h"
#include "gsttype.h"
#include "gstprops.h"
#include "gstpropsprivate.h"
static void string_append_indent (GString *str, gint count)
{
gint xx;
for (xx=0; xx < count; xx++)
g_string_append_c (str, ' ');
}
static void
gst_print_props (GString *buf, gint indent,
GList *props, gboolean showname)
{
GList *elem;
guint width = 0;
if (showname)
for (elem = props; elem; elem = g_list_next (elem))
{
GstPropsEntry *prop = elem->data;
const gchar *name = g_quark_to_string (prop->propid);
if (width < strlen (name))
width = strlen (name);
}
for (elem = props; elem; elem = g_list_next (elem))
{
GstPropsEntry *prop = elem->data;
string_append_indent (buf, indent);
if (showname)
{
const gchar *name = g_quark_to_string (prop->propid);
g_string_append (buf, name);
string_append_indent (buf, 2 + width - strlen (name));
}
switch (prop->propstype) {
case GST_PROPS_INT_ID:
g_string_printfa (buf, "%d (int)\n", prop->data.int_data);
break;
case GST_PROPS_INT_RANGE_ID:
g_string_printfa (buf, "%d - %d (int)\n",
prop->data.int_range_data.min,
prop->data.int_range_data.max);
break;
case GST_PROPS_FLOAT_ID:
g_string_printfa (buf, "%f (float)\n", prop->data.float_data);
break;
case GST_PROPS_FLOAT_RANGE_ID:
g_string_printfa (buf, "%f - %f (float)\n",
prop->data.float_range_data.min,
prop->data.float_range_data.max);
break;
case GST_PROPS_BOOL_ID:
g_string_printfa (buf, "%s\n",
prop->data.bool_data ? "TRUE" : "FALSE");
break;
case GST_PROPS_STRING_ID:
g_string_printfa (buf, "\"%s\"\n", prop->data.string_data.string);
break;
case GST_PROPS_FOURCC_ID:
g_string_printfa (buf, "'%c%c%c%c' (fourcc)\n",
prop->data.fourcc_data & 0xff,
prop->data.fourcc_data>>8 & 0xff,
prop->data.fourcc_data>>16 & 0xff,
prop->data.fourcc_data>>24 & 0xff);
break;
case GST_PROPS_LIST_ID:
gst_print_props (buf, indent+2, prop->data.list_data.entries, FALSE);
break;
default:
g_string_printfa (buf, "unknown proptype %d\n", prop->propstype);
break;
}
}
}
void gst_print_pad_caps (GString *buf, gint indent, GstPad *pad)
{
GstRealPad *realpad;
GstCaps *caps;
realpad = GST_PAD_REALIZE(pad);
caps = realpad->caps;
if (!caps)
{
string_append_indent (buf, indent);
g_string_printf (buf, "%s:%s has no capabilities",
GST_DEBUG_PAD_NAME (pad));
}
else
{
gint capx = 0;
while (caps) {
GstType *type;
string_append_indent (buf, indent);
g_string_printfa (buf, "Cap[%d]: %s\n", capx++, caps->name);
type = gst_type_find_by_id (caps->id);
string_append_indent (buf, indent+2);
g_string_printfa (buf, "MIME type: %s\n",
type->mime? type->mime : "unknown/unknown");
if (caps->properties)
gst_print_props (buf, indent + 4,
caps->properties->properties, TRUE);
caps = caps->next;
}
}
}
void gst_print_element_args (GString *buf, gint indent, GstElement *element)
{
gint num_properties;
gint px;
guint width;
GParamSpec **property_specs =
g_object_class_list_properties (G_OBJECT_GET_CLASS (element),
&num_properties);
width=0;
for (px=0; px < num_properties; px++) {
GParamSpec *param = property_specs[px];
if (width < strlen (param->name))
width = strlen (param->name);
}
for (px=0; px < num_properties; px++) {
GParamSpec *param = property_specs[px];
GValue value;
ZERO (value);
g_value_init (&value, param->value_type);
g_object_get_property (G_OBJECT (element), param->name, &value);
string_append_indent (buf, indent);
g_string_append (buf, param->name);
string_append_indent (buf, 2 + width - strlen (param->name));
if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
#ifdef USE_GLIB2
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
#else
values = gtk_type_enum_get_values (param->value_type);
#endif
g_string_printfa (buf, "%s (%s)",
values [g_value_get_enum (&value)].value_nick,
g_type_name (G_VALUE_TYPE (&value)));
}
else
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
g_string_printfa (buf, "\"%s\"", g_value_get_string (&value));
break;
case G_TYPE_BOOLEAN:
g_string_append (buf, g_value_get_boolean (&value)? "TRUE":"FALSE");
break;
case G_TYPE_ULONG:{
gulong val = g_value_get_ulong (&value);
g_string_printfa (buf, "%lu (0x%lx)", val, val);
break;}
case G_TYPE_LONG:{
glong val = g_value_get_long (&value);
g_string_printfa (buf, "%ld (0x%lx)", val, val);
break;}
case G_TYPE_UINT:{
guint val = g_value_get_uint (&value);
g_string_printfa (buf, "%u (0x%x)", val, val);
break;}
case G_TYPE_INT:{
gint val = g_value_get_int (&value);
g_string_printfa (buf, "%d (0x%x)", val, val);
break;}
case G_TYPE_FLOAT:
g_string_printfa (buf, "%f", g_value_get_float (&value));
break;
case G_TYPE_DOUBLE:
g_string_printfa (buf, "%f", g_value_get_double (&value));
break;
default:
g_string_printfa (buf, "unknown value_type %d", G_VALUE_TYPE (&value));
break;
}
g_string_append_c (buf, '\n');
if (G_VALUE_TYPE (&value))
g_value_unset (&value);
}
g_free (property_specs);
}