gstreamer/libs/gst/control/unitconvert.c

457 lines
13 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) 2001 Steve Baker <stevebaker_org@yahoo.co.uk>
*
* unitconvert.c: Conversion between units of measurement
*
* 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.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "unitconvert.h"
#include <gst/gstinfo.h>
static GHashTable *_gst_units;
static GHashTable *_gst_unit_domain_defaults;
static gboolean _gst_unitconv_init_done = FALSE;
typedef struct _GstUnit GstUnit;
struct _GstUnit
{
GParamSpec *unit_spec;
const gchar *domain_name;
gboolean domain_default;
gboolean logarithmic;
GHashTable *convert_to_funcs;
GSList *convert_paramspecs;
};
static void gst_unitconv_add_core_converters (void);
static void gst_unitconv_class_init (GstUnitConvertClass * klass);
static void gst_unitconv_init (GstUnitConvert * unitconv);
static void gst_unitconv_dispose (GObject * object);
GType
gst_unitconv_get_type (void)
{
static GType unitconv_type = 0;
if (!unitconv_type) {
static const GTypeInfo unitconv_info = {
sizeof (GstUnitConvertClass),
NULL,
NULL,
(GClassInitFunc) gst_unitconv_class_init,
NULL,
NULL,
sizeof (GstUnitConvert),
0,
(GInstanceInitFunc) gst_unitconv_init,
};
unitconv_type =
g_type_register_static (GST_TYPE_OBJECT, "GstUnitConvert",
&unitconv_info, 0);
}
return unitconv_type;
}
static void
gst_unitconv_class_init (GstUnitConvertClass * klass)
{
GObjectClass *gobject_class;
GstUnitConvertClass *unitconv_class;
GstObjectClass *gstobject_class;
gobject_class = (GObjectClass *) klass;
unitconv_class = (GstUnitConvertClass *) klass;
gstobject_class = (GstObjectClass *) klass;
gobject_class->dispose = gst_unitconv_dispose;
}
static void
gst_unitconv_init (GstUnitConvert * unitconv)
{
g_return_if_fail (unitconv != NULL);
unitconv->convert_func_chain = NULL;
unitconv->convert_params = g_hash_table_new (g_str_hash, g_str_equal);
}
GstUnitConvert *
gst_unitconv_new ()
{
GstUnitConvert *unitconv;
unitconv = g_object_new (gst_unitconv_get_type (), NULL);
return unitconv;
}
static void
gst_unitconv_init_for_change_state (GstUnitConvert * unitconv)
{
unitconv->convert_func_chain = NULL;
}
gboolean
gst_unitconv_set_convert_units (GstUnitConvert * unitconv,
gchar * from_unit_named, gchar * to_unit_named)
{
GHashTable *convert_funcs;
GstUnit *from_unit, *to_unit;
GstUnitConvertFunc convert_func;
g_return_val_if_fail (unitconv != NULL, FALSE);
g_return_val_if_fail (from_unit_named != NULL, FALSE);
g_return_val_if_fail (to_unit_named != NULL, FALSE);
g_return_val_if_fail (GST_IS_UNIT_CONVERT (unitconv), FALSE);
from_unit = g_hash_table_lookup (_gst_units, from_unit_named);
to_unit = g_hash_table_lookup (_gst_units, to_unit_named);
g_return_val_if_fail (from_unit != NULL, FALSE);
g_return_val_if_fail (to_unit != NULL, FALSE);
convert_funcs = from_unit->convert_to_funcs;
convert_func = g_hash_table_lookup (convert_funcs, to_unit);
if (convert_func == NULL) {
g_warning ("cannot convert from %s to %s", from_unit_named, to_unit_named);
}
gst_unitconv_init_for_change_state (unitconv);
unitconv->convert_func_chain =
g_slist_append (unitconv->convert_func_chain, convert_func);
return TRUE;
}
gboolean
gst_unitconv_convert_value (GstUnitConvert * unitconv, GValue * from_value,
GValue * to_value)
{
GstUnitConvertFunc convert_func;
GSList *convert_func_chain;
g_return_val_if_fail (unitconv->convert_func_chain != NULL, FALSE);
/* only do this until we can chain convert funcs */
g_return_val_if_fail (g_slist_length (unitconv->convert_func_chain) == 1,
FALSE);
convert_func_chain = unitconv->convert_func_chain;
convert_func = (GstUnitConvertFunc) (convert_func_chain);
convert_func (unitconv, from_value, to_value);
return TRUE;
}
gboolean
gst_unitconv_unit_exists (gchar * unit_name)
{
g_return_val_if_fail (unit_name != NULL, FALSE);
return (g_hash_table_lookup (_gst_units, unit_name) != NULL);
}
gboolean
gst_unitconv_unit_is_logarithmic (gchar * unit_name)
{
GstUnit *unit;
g_return_val_if_fail (unit_name != NULL, FALSE);
unit = g_hash_table_lookup (_gst_units, unit_name);
g_return_val_if_fail (unit != NULL, FALSE);
return unit->logarithmic;
}
GParamSpec *
gst_unitconv_unit_spec (gchar * unit_name)
{
GstUnit *unit;
g_return_val_if_fail (unit_name != NULL, FALSE);
unit = g_hash_table_lookup (_gst_units, unit_name);
g_return_val_if_fail (unit != NULL, FALSE);
return unit->unit_spec;
}
static void
gst_unitconv_dispose (GObject * object)
{
}
void
_gst_unitconv_initialize (void)
{
if (_gst_unitconv_init_done)
return;
_gst_unitconv_init_done = TRUE;
_gst_units = g_hash_table_new (g_str_hash, g_str_equal);
_gst_unit_domain_defaults = g_hash_table_new (g_str_hash, g_str_equal);
/* frequency based units */
gst_unitconv_register_unit ("frequency", TRUE, TRUE,
g_param_spec_float ("hertz", "Hz", "Frequency in hertz",
0, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("frequency", FALSE, TRUE,
g_param_spec_float ("hertz-rate-bound", "Hz",
"Frequency in hertz, bound by the sample rate", 0.0, G_MAXFLOAT, 0.0,
0));
gst_unitconv_register_unit ("frequency", FALSE, FALSE,
g_param_spec_string ("twelve-tone-scale", "note",
"Name of the note from the western twelve tone scale", "C", 0));
gst_unitconv_register_unit ("frequency", FALSE, FALSE,
g_param_spec_int ("midi-note", "midi note",
"MIDI note value of the frequency", 1, 127, 1, 0));
/* time based units */
gst_unitconv_register_unit ("time", TRUE, FALSE,
g_param_spec_float ("seconds", "s", "Time in seconds",
-G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("time", FALSE, FALSE,
g_param_spec_int64 ("nanoseconds", "ns", "Time in nanoseconds",
G_MININT64, G_MAXINT64, 0, 0));
gst_unitconv_register_unit ("time", FALSE, FALSE,
g_param_spec_int64 ("samples", "samples", "Time in number of samples",
G_MININT64, G_MAXINT64, 0, 0));
gst_unitconv_register_convert_property ("samples",
g_param_spec_int ("samplerate", "samplerate", "samplerate",
0, G_MAXINT, 0, G_PARAM_READWRITE));
/* magnitude based units */
gst_unitconv_register_unit ("magnitude", TRUE, FALSE,
g_param_spec_float ("scalar", "scalar", "Magnitude as a scalar",
-G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("magnitude", FALSE, FALSE,
g_param_spec_int ("scalar-int", "scalar int",
"Magnitude as an integer scalar", G_MININT, G_MAXINT, 0, 0));
gst_unitconv_register_unit ("magnitude", FALSE, TRUE,
g_param_spec_float ("decibel", "dB", "Magnitude in decibels",
-G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("magnitude", FALSE, FALSE,
g_param_spec_float ("percent", "%", "Magnitude in percent",
-G_MAXFLOAT, G_MAXFLOAT, 0, 0));
/* generic units */
gst_unitconv_register_unit ("float_default", TRUE, FALSE,
g_param_spec_float ("float", "float", "Float value",
-G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("int_default", TRUE, FALSE,
g_param_spec_int ("int", "int", "Integer value",
G_MININT, G_MAXINT, 0, 0));
gst_unitconv_register_unit ("int64_default", TRUE, FALSE,
g_param_spec_int64 ("int64", "int64", "64 bit integer value",
G_MININT, G_MAXINT, 0, 0));
gst_unitconv_add_core_converters ();
}
gboolean
gst_unitconv_register_unit (const gchar * domain_name,
gboolean is_domain_default, gboolean is_logarithmic, GParamSpec * unit_spec)
{
GstUnit *unit;
gchar *unit_name;
g_return_val_if_fail (unit_spec != NULL, FALSE);
g_return_val_if_fail (G_IS_PARAM_SPEC (unit_spec), FALSE);
g_return_val_if_fail (domain_name != NULL, FALSE);
unit_name = g_strdup (g_param_spec_get_name (unit_spec));
/* check if this unit name already exists */
if (g_hash_table_lookup (_gst_units, unit_name) != NULL) {
g_free (unit_name);
return FALSE;
}
if (is_domain_default) {
/* check if an default unit already exists for this domain */
g_return_val_if_fail (g_hash_table_lookup (_gst_unit_domain_defaults,
domain_name) == NULL, FALSE);
}
GST_DEBUG ("creating unit: %s", unit_name);
unit = g_new0 (GstUnit, 1);
unit->unit_spec = unit_spec;
unit->domain_name = domain_name;
unit->domain_default = is_domain_default;
unit->logarithmic = is_logarithmic;
unit->convert_to_funcs = g_hash_table_new (NULL, NULL);
/* unit->convert_properties = g_hash_table_new(g_str_hash,g_str_equal); */
g_hash_table_insert (_gst_units, unit_name, unit);
if (is_domain_default) {
g_hash_table_insert (_gst_unit_domain_defaults, g_strdup (domain_name),
unit);
}
return TRUE;
}
gboolean
gst_unitconv_register_convert_func (gchar * from_unit_named,
gchar * to_unit_named, GstUnitConvertFunc convert_func)
{
GHashTable *convert_funcs;
GstUnit *from_unit, *to_unit;
g_return_val_if_fail (from_unit_named != NULL, FALSE);
g_return_val_if_fail (to_unit_named != NULL, FALSE);
from_unit = g_hash_table_lookup (_gst_units, from_unit_named);
to_unit = g_hash_table_lookup (_gst_units, to_unit_named);
g_return_val_if_fail (from_unit != NULL, FALSE);
g_return_val_if_fail (to_unit != NULL, FALSE);
convert_funcs = from_unit->convert_to_funcs;
g_return_val_if_fail (g_hash_table_lookup (convert_funcs, to_unit) == NULL,
FALSE);
GST_DEBUG ("adding unit converter from %s to %s\n",
g_param_spec_get_name (from_unit->unit_spec),
g_param_spec_get_name (to_unit->unit_spec));
g_hash_table_insert (convert_funcs, to_unit, convert_func);
return TRUE;
}
gboolean
gst_unitconv_register_convert_property (gchar * unit_name,
GParamSpec * convert_prop_spec)
{
GstUnit *unit;
g_return_val_if_fail (unit_name != NULL, FALSE);
g_return_val_if_fail (convert_prop_spec != NULL, FALSE);
unit = g_hash_table_lookup (_gst_units, unit_name);
g_return_val_if_fail (unit != NULL, FALSE);
unit->convert_paramspecs =
g_slist_append (unit->convert_paramspecs, convert_prop_spec);
return TRUE;
}
static void
gst_unitconv_time_seconds_to_nanoseconds (GstUnitConvert * unitconv,
GValue * seconds_val, GValue * nanos_val)
{
g_value_set_int64 (nanos_val,
(gint64) (g_value_get_float (seconds_val) * 1000000000.0));
}
static void
gst_unitconv_time_nanoseconds_to_seconds (GstUnitConvert * unitconv,
GValue * nanos_val, GValue * seconds_val)
{
g_value_set_float (seconds_val,
((gfloat) g_value_get_int64 (nanos_val)) / 1000000000.0);
}
static void
gst_unitconv_time_seconds_to_samples (GstUnitConvert * unitconv,
GValue * seconds_val, GValue * samples_val)
{
/* GValue *samplerate;
GValue *samplerate = g_hash_table_lookup(unitconv->currentToUnit->convert_properties, "samplerate");
g_value_set_int64(samples_val,
(gint64)(g_value_get_float(seconds_val) * (gfloat)g_value_get_int(samplerate))); */
}
static void
gst_unitconv_time_samples_to_seconds (GstUnitConvert * unitconv,
GValue * samples_val, GValue * seconds_val)
{
/* GValue *samplerate;
GValue *samplerate = g_hash_table_lookup(unitconv->currentFromUnit->convert_properties, "samplerate");
g_value_set_float(seconds_val,
((gfloat)g_value_get_int64(samples_val)) / (gfloat)g_value_get_int(samplerate)); */
}
static void
gst_unitconv_magnitude_scalar_to_percent (GstUnitConvert * unitconv,
GValue * scalar_val, GValue * percent_val)
{
g_value_set_float (percent_val, g_value_get_float (scalar_val) * 100.0);
}
static void
gst_unitconv_magnitude_percent_to_scalar (GstUnitConvert * unitconv,
GValue * percent_val, GValue * scalar_val)
{
g_value_set_float (scalar_val, g_value_get_float (percent_val) / 100.0);
}
static void
gst_unitconv_add_core_converters (void)
{
gst_unitconv_register_convert_func ("nanoseconds", "seconds",
gst_unitconv_time_nanoseconds_to_seconds);
gst_unitconv_register_convert_func ("seconds", "nanoseconds",
gst_unitconv_time_seconds_to_nanoseconds);
gst_unitconv_register_convert_func ("seconds", "samples",
gst_unitconv_time_seconds_to_samples);
gst_unitconv_register_convert_func ("samples", "seconds",
gst_unitconv_time_samples_to_seconds);
gst_unitconv_register_convert_func ("scalar", "percent",
gst_unitconv_magnitude_scalar_to_percent);
gst_unitconv_register_convert_func ("percent", "scalar",
gst_unitconv_magnitude_percent_to_scalar);
}