Commit f86bfaf5 authored by Sebastian Dröge's avatar Sebastian Dröge 🍵
Browse files

gst/audiofx/: Use generator macros for the process functions for the different...

gst/audiofx/: Use generator macros for the process functions for the different sample types, add lower upper boundari...

Original commit message from CVS:
* gst/audiofx/audiochebyshevfreqband.c:
(gst_audio_chebyshev_freq_band_class_init):
* gst/audiofx/audiochebyshevfreqlimit.c:
(gst_audio_chebyshev_freq_limit_class_init):
Use generator macros for the process functions for the different
sample types, add lower upper boundaries for the GObject properties
so automatically generated UIs can use sliders and add a note about
the number of poles as a too high number of poles combined with
very low or very high frequencies will produce only noise.
* docs/plugins/gst-plugins-good-plugins.args:
Regenerated for the property changes.
parent 6ef70550
2007-08-17 Sebastian Dröge <slomo@circular-chaos.org>
* gst/audiofx/audiochebyshevfreqband.c:
(gst_audio_chebyshev_freq_band_class_init):
* gst/audiofx/audiochebyshevfreqlimit.c:
(gst_audio_chebyshev_freq_limit_class_init):
Use generator macros for the process functions for the different
sample types, add lower upper boundaries for the GObject properties
so automatically generated UIs can use sliders and add a note about
the number of poles as a too high number of poles combined with
very low or very high frequencies will produce only noise.
* docs/plugins/gst-plugins-good-plugins.args:
Regenerated for the property changes.
2007-08-17 Wim Taymans <wim.taymans@gmail.com>
* gst/rtsp/gstrtspsrc.c: (gst_rtspsrc_set_property),
......
......@@ -401,21 +401,21 @@
<ARG>
<NAME>GstVertigoTV::speed</NAME>
<TYPE>gfloat</TYPE>
<RANGE>[0.01,100]</RANGE>
<RANGE>[0,01,100]</RANGE>
<FLAGS>rw</FLAGS>
<NICK>Speed</NICK>
<BLURB>Control the speed of movement.</BLURB>
<DEFAULT>0.02</DEFAULT>
<DEFAULT>0,02</DEFAULT>
</ARG>
<ARG>
<NAME>GstVertigoTV::zoom-speed</NAME>
<TYPE>gfloat</TYPE>
<RANGE>[1.01,1.1]</RANGE>
<RANGE>[1,01,1,1]</RANGE>
<FLAGS>rw</FLAGS>
<NICK>Zoom Speed</NICK>
<BLURB>Control the rate of zooming.</BLURB>
<DEFAULT>1.01</DEFAULT>
<DEFAULT>1,01</DEFAULT>
</ARG>
<ARG>
......@@ -17241,7 +17241,7 @@
<ARG>
<NAME>GstGamma::gamma</NAME>
<TYPE>gdouble</TYPE>
<RANGE>[0.01,10]</RANGE>
<RANGE>[0,01,10]</RANGE>
<FLAGS>rw</FLAGS>
<NICK>Gamma</NICK>
<BLURB>gamma.</BLURB>
......@@ -17365,7 +17365,7 @@
<FLAGS>rw</FLAGS>
<NICK>Ripple</NICK>
<BLURB>Amount of ripple (dB).</BLURB>
<DEFAULT>0.25</DEFAULT>
<DEFAULT>0,25</DEFAULT>
</ARG>
<ARG>
......@@ -17391,7 +17391,7 @@
<ARG>
<NAME>GstAudioChebyshevFreqLimit::cutoff</NAME>
<TYPE>gfloat</TYPE>
<RANGE>>= 0</RANGE>
<RANGE>[0,100000]</RANGE>
<FLAGS>rw</FLAGS>
<NICK>Cutoff</NICK>
<BLURB>Cut off frequency (Hz).</BLURB>
......@@ -17421,11 +17421,11 @@
<ARG>
<NAME>GstAudioChebyshevFreqLimit::ripple</NAME>
<TYPE>gfloat</TYPE>
<RANGE>>= 0</RANGE>
<RANGE>[0,200]</RANGE>
<FLAGS>rw</FLAGS>
<NICK>Ripple</NICK>
<BLURB>Amount of ripple (dB).</BLURB>
<DEFAULT>0.25</DEFAULT>
<DEFAULT>0,25</DEFAULT>
</ARG>
<ARG>
......
......@@ -53,6 +53,10 @@
* <para>
* As a special case, a Chebyshev type 1 filter with no ripple is a Butterworth filter.
* </para>
* <para><note>
* Be warned that a too large number of poles can produce noise. The most poles are possible with
* a cutoff frequency at a quarter of the sampling rate.
* </note></para>
* <title>Example launch line</title>
* <para>
* <programlisting>
......@@ -233,18 +237,24 @@ gst_audio_chebyshev_freq_band_class_init (GstAudioChebyshevFreqBandClass *
g_param_spec_int ("type", "Type",
"Type of the chebychev filter", 1, 2,
1, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: Don't use the complete possible range but restrict the upper boundary
* so automatically generated UIs can use a slider without */
g_object_class_install_property (gobject_class, PROP_LOWER_FREQUENCY,
g_param_spec_float ("lower-frequency", "Lower frequency",
"Start frequency of the band (Hz)", 0.0, G_MAXFLOAT,
"Start frequency of the band (Hz)", 0.0, 100000.0,
0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_UPPER_FREQUENCY,
g_param_spec_float ("upper-frequency", "Upper frequency",
"Stop frequency of the band (Hz)", 0.0, G_MAXFLOAT,
"Stop frequency of the band (Hz)", 0.0, 100000.0,
0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_RIPPLE,
g_param_spec_float ("ripple", "Ripple",
"Amount of ripple (dB)", 0.0, G_MAXFLOAT,
"Amount of ripple (dB)", 0.0, 200.0,
0.25, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: What to do about this upper boundary? With a frequencies near
* rate/4 32 poles are completely possible, with frequencies very low
* or very high 16 poles already produces only noise */
g_object_class_install_property (gobject_class, PROP_POLES,
g_param_spec_int ("poles", "Poles",
"Number of poles to use, will be rounded up to the next multiply of four",
......@@ -840,35 +850,26 @@ process (GstAudioChebyshevFreqBand * filter,
return val;
}
static void
process_64 (GstAudioChebyshevFreqBand * filter,
gdouble * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioChebyshevFreqBand * filter, \
g##ctype * data, guint num_samples) \
{ \
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels; \
gdouble val; \
\
for (i = 0; i < num_samples / channels; i++) { \
for (j = 0; j < channels; j++) { \
val = process (filter, &filter->channels[j], *data); \
*data++ = val; \
} \
} \
}
static void
process_32 (GstAudioChebyshevFreqBand * filter,
gfloat * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
}
#undef DEFINE_PROCESS_FUNC
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
......
......@@ -49,6 +49,10 @@
* <para>
* As a special case, a Chebyshev type 1 filter with no ripple is a Butterworth filter.
* </para>
* <para><note>
* Be warned that a too large number of poles can produce noise. The most poles are possible with
* a cutoff frequency at a quarter of the sampling rate.
* </note></para>
* <title>Example launch line</title>
* <para>
* <programlisting>
......@@ -229,12 +233,19 @@ gst_audio_chebyshev_freq_limit_class_init (GstAudioChebyshevFreqLimitClass *
g_object_class_install_property (gobject_class, PROP_TYPE,
g_param_spec_int ("type", "Type", "Type of the chebychev filter", 1, 2, 1,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: Don't use the complete possible range but restrict the upper boundary
* so automatically generated UIs can use a slider without */
g_object_class_install_property (gobject_class, PROP_CUTOFF,
g_param_spec_float ("cutoff", "Cutoff", "Cut off frequency (Hz)", 0.0,
G_MAXFLOAT, 0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
100000.0, 0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_RIPPLE,
g_param_spec_float ("ripple", "Ripple", "Amount of ripple (dB)", 0.0,
G_MAXFLOAT, 0.25, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
200.0, 0.25, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: What to do about this upper boundary? With a cutoff frequency of
* rate/4 32 poles are completely possible, with a cutoff frequency very low
* or very high 16 poles already produces only noise */
g_object_class_install_property (gobject_class, PROP_POLES,
g_param_spec_int ("poles", "Poles",
"Number of poles to use, will be rounded up to the next even number",
......@@ -739,35 +750,26 @@ process (GstAudioChebyshevFreqLimit * filter,
return val;
}
static void
process_64 (GstAudioChebyshevFreqLimit * filter,
gdouble * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioChebyshevFreqLimit * filter, \
g##ctype * data, guint num_samples) \
{ \
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels; \
gdouble val; \
\
for (i = 0; i < num_samples / channels; i++) { \
for (j = 0; j < channels; j++) { \
val = process (filter, &filter->channels[j], *data); \
*data++ = val; \
} \
} \
}
static void
process_32 (GstAudioChebyshevFreqLimit * filter,
gfloat * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
}
#undef DEFINE_PROCESS_FUNC
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
......
......@@ -53,6 +53,10 @@
* <para>
* As a special case, a Chebyshev type 1 filter with no ripple is a Butterworth filter.
* </para>
* <para><note>
* Be warned that a too large number of poles can produce noise. The most poles are possible with
* a cutoff frequency at a quarter of the sampling rate.
* </note></para>
* <title>Example launch line</title>
* <para>
* <programlisting>
......@@ -233,18 +237,24 @@ gst_audio_chebyshev_freq_band_class_init (GstAudioChebyshevFreqBandClass *
g_param_spec_int ("type", "Type",
"Type of the chebychev filter", 1, 2,
1, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: Don't use the complete possible range but restrict the upper boundary
* so automatically generated UIs can use a slider without */
g_object_class_install_property (gobject_class, PROP_LOWER_FREQUENCY,
g_param_spec_float ("lower-frequency", "Lower frequency",
"Start frequency of the band (Hz)", 0.0, G_MAXFLOAT,
"Start frequency of the band (Hz)", 0.0, 100000.0,
0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_UPPER_FREQUENCY,
g_param_spec_float ("upper-frequency", "Upper frequency",
"Stop frequency of the band (Hz)", 0.0, G_MAXFLOAT,
"Stop frequency of the band (Hz)", 0.0, 100000.0,
0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_RIPPLE,
g_param_spec_float ("ripple", "Ripple",
"Amount of ripple (dB)", 0.0, G_MAXFLOAT,
"Amount of ripple (dB)", 0.0, 200.0,
0.25, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: What to do about this upper boundary? With a frequencies near
* rate/4 32 poles are completely possible, with frequencies very low
* or very high 16 poles already produces only noise */
g_object_class_install_property (gobject_class, PROP_POLES,
g_param_spec_int ("poles", "Poles",
"Number of poles to use, will be rounded up to the next multiply of four",
......@@ -840,35 +850,26 @@ process (GstAudioChebyshevFreqBand * filter,
return val;
}
static void
process_64 (GstAudioChebyshevFreqBand * filter,
gdouble * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioChebyshevFreqBand * filter, \
g##ctype * data, guint num_samples) \
{ \
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels; \
gdouble val; \
\
for (i = 0; i < num_samples / channels; i++) { \
for (j = 0; j < channels; j++) { \
val = process (filter, &filter->channels[j], *data); \
*data++ = val; \
} \
} \
}
static void
process_32 (GstAudioChebyshevFreqBand * filter,
gfloat * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
}
#undef DEFINE_PROCESS_FUNC
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
......
......@@ -49,6 +49,10 @@
* <para>
* As a special case, a Chebyshev type 1 filter with no ripple is a Butterworth filter.
* </para>
* <para><note>
* Be warned that a too large number of poles can produce noise. The most poles are possible with
* a cutoff frequency at a quarter of the sampling rate.
* </note></para>
* <title>Example launch line</title>
* <para>
* <programlisting>
......@@ -229,12 +233,19 @@ gst_audio_chebyshev_freq_limit_class_init (GstAudioChebyshevFreqLimitClass *
g_object_class_install_property (gobject_class, PROP_TYPE,
g_param_spec_int ("type", "Type", "Type of the chebychev filter", 1, 2, 1,
G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: Don't use the complete possible range but restrict the upper boundary
* so automatically generated UIs can use a slider without */
g_object_class_install_property (gobject_class, PROP_CUTOFF,
g_param_spec_float ("cutoff", "Cutoff", "Cut off frequency (Hz)", 0.0,
G_MAXFLOAT, 0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
100000.0, 0.0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
g_object_class_install_property (gobject_class, PROP_RIPPLE,
g_param_spec_float ("ripple", "Ripple", "Amount of ripple (dB)", 0.0,
G_MAXFLOAT, 0.25, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
200.0, 0.25, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));
/* FIXME: What to do about this upper boundary? With a cutoff frequency of
* rate/4 32 poles are completely possible, with a cutoff frequency very low
* or very high 16 poles already produces only noise */
g_object_class_install_property (gobject_class, PROP_POLES,
g_param_spec_int ("poles", "Poles",
"Number of poles to use, will be rounded up to the next even number",
......@@ -739,35 +750,26 @@ process (GstAudioChebyshevFreqLimit * filter,
return val;
}
static void
process_64 (GstAudioChebyshevFreqLimit * filter,
gdouble * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
#define DEFINE_PROCESS_FUNC(width,ctype) \
static void \
process_##width (GstAudioChebyshevFreqLimit * filter, \
g##ctype * data, guint num_samples) \
{ \
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels; \
gdouble val; \
\
for (i = 0; i < num_samples / channels; i++) { \
for (j = 0; j < channels; j++) { \
val = process (filter, &filter->channels[j], *data); \
*data++ = val; \
} \
} \
}
static void
process_32 (GstAudioChebyshevFreqLimit * filter,
gfloat * data, guint num_samples)
{
gint i, j, channels = GST_AUDIO_FILTER (filter)->format.channels;
gdouble val;
DEFINE_PROCESS_FUNC (32, float);
DEFINE_PROCESS_FUNC (64, double);
for (i = 0; i < num_samples / channels; i++) {
for (j = 0; j < channels; j++) {
val = process (filter, &filter->channels[j], *data);
*data++ = val;
}
}
}
#undef DEFINE_PROCESS_FUNC
/* GstBaseTransform vmethod implementations */
static GstFlowReturn
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment