mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2025-04-16 21:14:44 +00:00
Working multi-channel pads for LV2 plugins.
This commit is contained in:
Dave Robillard
Stefan Kost
parent
c076e7d34f
commit
403f58b562
5 changed files with 319 additions and 127 deletions
|
|
@ -125,10 +125,10 @@ gst_ladspa_base_init (gpointer g_class)
|
|||
|
||||
if (LADSPA_IS_PORT_INPUT (p))
|
||||
gst_signal_processor_class_add_pad_template (gsp_class, name,
|
||||
GST_PAD_SINK, gsp_class->num_audio_in++);
|
||||
GST_PAD_SINK, gsp_class->num_audio_in++, 1);
|
||||
else
|
||||
gst_signal_processor_class_add_pad_template (gsp_class, name,
|
||||
GST_PAD_SRC, gsp_class->num_audio_out++);
|
||||
GST_PAD_SRC, gsp_class->num_audio_out++, 1);
|
||||
|
||||
g_free (name);
|
||||
} else if (LADSPA_IS_PORT_CONTROL (p)) {
|
||||
|
|
|
|||
261
ext/lv2/gstlv2.c
261
ext/lv2/gstlv2.c
|
|
@ -54,6 +54,7 @@ SLV2Value integer_prop;
|
|||
SLV2Value toggled_prop;
|
||||
SLV2Value in_place_broken_pred;
|
||||
SLV2Value in_group_pred;
|
||||
SLV2Value lv2_symbol_pred;
|
||||
|
||||
static GstSignalProcessorClass *parent_class;
|
||||
|
||||
|
|
@ -62,12 +63,15 @@ static GstPlugin *gst_lv2_plugin;
|
|||
GST_DEBUG_CATEGORY_STATIC (lv2_debug);
|
||||
#define GST_CAT_DEFAULT lv2_debug
|
||||
|
||||
static gint
|
||||
gst_lv2_value_cmp (gconstpointer a, gconstpointer b)
|
||||
/** Find and return the group @a uri in @a groups, or NULL if not found */
|
||||
static GstLV2Group *
|
||||
gst_lv2_class_find_group (GArray * groups, SLV2Value uri)
|
||||
{
|
||||
if (slv2_value_equals ((SLV2Value) a, (SLV2Value) b))
|
||||
return 0;
|
||||
return 1;
|
||||
int i = 0;
|
||||
for (; i < groups->len; ++i)
|
||||
if (slv2_value_equals (g_array_index (groups, GstLV2Group, i).uri, uri))
|
||||
return &g_array_index (groups, GstLV2Group, i);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -79,8 +83,9 @@ gst_lv2_base_init (gpointer g_class)
|
|||
GstElementDetails *details;
|
||||
SLV2Plugin lv2plugin;
|
||||
SLV2Value val;
|
||||
SLV2Values values;
|
||||
guint j, audio_in_count, audio_out_count, control_in_count, control_out_count;
|
||||
SLV2Values values, sub_values;
|
||||
GstLV2Group *group = NULL;
|
||||
guint j, in_pad_index = 0, out_pad_index = 0;
|
||||
gchar *klass_tags;
|
||||
|
||||
GST_DEBUG ("base_init %p", g_class);
|
||||
|
|
@ -90,89 +95,116 @@ gst_lv2_base_init (gpointer g_class)
|
|||
|
||||
g_assert (lv2plugin);
|
||||
|
||||
/* audio ports (pads) */
|
||||
gsp_class->num_audio_in = slv2_plugin_get_num_ports_of_class (lv2plugin,
|
||||
audio_class, input_class, NULL);
|
||||
gsp_class->num_audio_out = slv2_plugin_get_num_ports_of_class (lv2plugin,
|
||||
audio_class, output_class, NULL);
|
||||
gsp_class->num_group_in = 0;
|
||||
gsp_class->num_group_out = 0;
|
||||
gsp_class->num_audio_in = 0;
|
||||
gsp_class->num_audio_out = 0;
|
||||
gsp_class->num_control_in = 0;
|
||||
gsp_class->num_control_out = 0;
|
||||
|
||||
/* control ports (properties) */
|
||||
gsp_class->num_control_in = slv2_plugin_get_num_ports_of_class (lv2plugin,
|
||||
control_class, input_class, NULL);
|
||||
gsp_class->num_control_out = slv2_plugin_get_num_ports_of_class (lv2plugin,
|
||||
control_class, output_class, NULL);
|
||||
klass->in_groups = g_array_new (FALSE, TRUE, sizeof (GstLV2Group));
|
||||
klass->out_groups = g_array_new (FALSE, TRUE, sizeof (GstLV2Group));
|
||||
klass->audio_in_ports = g_array_new (FALSE, TRUE, sizeof (GstLV2Port));
|
||||
klass->audio_out_ports = g_array_new (FALSE, TRUE, sizeof (GstLV2Port));
|
||||
klass->control_in_ports = g_array_new (FALSE, TRUE, sizeof (GstLV2Port));
|
||||
klass->control_out_ports = g_array_new (FALSE, TRUE, sizeof (GstLV2Port));
|
||||
|
||||
klass->audio_in_ports = g_new0 (struct _GstLV2Port, gsp_class->num_audio_in);
|
||||
klass->audio_out_ports =
|
||||
g_new0 (struct _GstLV2Port, gsp_class->num_audio_out);
|
||||
klass->control_in_ports =
|
||||
g_new0 (struct _GstLV2Port, gsp_class->num_control_in);
|
||||
klass->control_out_ports =
|
||||
g_new0 (struct _GstLV2Port, gsp_class->num_control_out);
|
||||
|
||||
klass->groups = NULL;
|
||||
|
||||
/* find port groups */
|
||||
audio_in_count = audio_out_count = control_in_count = control_out_count = 0;
|
||||
/* find ports and groups */
|
||||
for (j = 0; j < slv2_plugin_get_num_ports (lv2plugin); j++) {
|
||||
SLV2Port port = slv2_plugin_get_port_by_index (lv2plugin, j);
|
||||
gboolean is_input = slv2_port_is_a (lv2plugin, port, input_class);
|
||||
struct _GstLV2Port *desc = NULL;
|
||||
if (slv2_port_is_a (lv2plugin, port, audio_class)) {
|
||||
if (is_input)
|
||||
desc = &klass->audio_in_ports[audio_in_count++];
|
||||
else
|
||||
desc = &klass->audio_out_ports[audio_out_count++];
|
||||
} else if (slv2_port_is_a (lv2plugin, port, control_class)) {
|
||||
if (is_input)
|
||||
desc = &klass->control_in_ports[control_in_count++];
|
||||
else
|
||||
desc = &klass->control_out_ports[control_out_count++];
|
||||
} else {
|
||||
/* unknown port type */
|
||||
continue;
|
||||
}
|
||||
desc->index = j;
|
||||
const SLV2Port port = slv2_plugin_get_port_by_index (lv2plugin, j);
|
||||
const gboolean is_input = slv2_port_is_a (lv2plugin, port, input_class);
|
||||
struct _GstLV2Port desc = { j, 0 };
|
||||
values = slv2_port_get_value (lv2plugin, port, in_group_pred);
|
||||
|
||||
if (slv2_values_size (values) > 0) {
|
||||
SLV2Value v = slv2_values_get_at (values, 0);
|
||||
desc->group = v;
|
||||
if (!g_slist_find_custom (klass->groups, v, gst_lv2_value_cmp)) {
|
||||
klass->groups =
|
||||
g_slist_prepend (klass->groups, slv2_value_duplicate (v));
|
||||
/* port is part of a group */
|
||||
SLV2Value group_uri = slv2_values_get_at (values, 0);
|
||||
GArray *groups = is_input ? klass->in_groups : klass->out_groups;
|
||||
GstLV2Group *group = gst_lv2_class_find_group (groups, group_uri);
|
||||
if (group == NULL) {
|
||||
GstLV2Group g;
|
||||
g.uri = slv2_value_duplicate (group_uri);
|
||||
g.pad = is_input ? in_pad_index++ : out_pad_index++;
|
||||
g.ports = g_array_new (FALSE, TRUE, sizeof (GstLV2Port));
|
||||
sub_values = slv2_plugin_get_value_for_subject (lv2plugin, group_uri,
|
||||
lv2_symbol_pred);
|
||||
if (slv2_values_size (sub_values) > 0)
|
||||
g.symbol = slv2_value_duplicate (slv2_values_get_at (sub_values, 0));
|
||||
else
|
||||
g.symbol = NULL;
|
||||
slv2_values_free (sub_values);
|
||||
|
||||
g_array_append_val (groups, g);
|
||||
group = &g_array_index (groups, GstLV2Group, groups->len - 1);
|
||||
}
|
||||
|
||||
g_array_append_val (group->ports, desc);
|
||||
|
||||
} else {
|
||||
/* port is not part of a group */
|
||||
if (slv2_port_is_a (lv2plugin, port, audio_class)) {
|
||||
desc.pad = is_input ? in_pad_index++ : out_pad_index++;
|
||||
if (is_input)
|
||||
g_array_append_val (klass->audio_in_ports, desc);
|
||||
else
|
||||
g_array_append_val (klass->audio_out_ports, desc);
|
||||
} else if (slv2_port_is_a (lv2plugin, port, control_class)) {
|
||||
if (is_input)
|
||||
g_array_append_val (klass->control_in_ports, desc);
|
||||
else
|
||||
g_array_append_val (klass->control_out_ports, desc);
|
||||
} else {
|
||||
/* unknown port type */
|
||||
continue;
|
||||
}
|
||||
g_assert (g_slist_find_custom (klass->groups, v, gst_lv2_value_cmp));
|
||||
}
|
||||
slv2_values_free (values);
|
||||
}
|
||||
g_assert (audio_in_count == gsp_class->num_audio_in);
|
||||
g_assert (audio_out_count == gsp_class->num_audio_out);
|
||||
g_assert (control_in_count == gsp_class->num_control_in);
|
||||
g_assert (control_out_count == gsp_class->num_control_out);
|
||||
|
||||
/* add pad templates */
|
||||
audio_in_count = audio_out_count = 0;
|
||||
for (j = 0; j < slv2_plugin_get_num_ports (lv2plugin); j++) {
|
||||
SLV2Port port = slv2_plugin_get_port_by_index (lv2plugin, j);
|
||||
if (slv2_port_is_a (lv2plugin, port, audio_class)) {
|
||||
gchar *name =
|
||||
g_strdup (slv2_value_as_string (slv2_port_get_symbol (lv2plugin,
|
||||
port)));
|
||||
gsp_class->num_group_in = klass->in_groups->len;
|
||||
gsp_class->num_group_out = klass->out_groups->len;
|
||||
gsp_class->num_audio_in = klass->audio_in_ports->len;
|
||||
gsp_class->num_audio_out = klass->audio_out_ports->len;
|
||||
gsp_class->num_control_in = klass->control_in_ports->len;
|
||||
gsp_class->num_control_out = klass->control_out_ports->len;
|
||||
|
||||
GST_DEBUG ("LV2 port name: \"%s\"", name);
|
||||
|
||||
if (slv2_port_is_a (lv2plugin, port, input_class))
|
||||
gst_signal_processor_class_add_pad_template (gsp_class, name,
|
||||
GST_PAD_SINK, audio_in_count++);
|
||||
else if (slv2_port_is_a (lv2plugin, port, output_class))
|
||||
gst_signal_processor_class_add_pad_template (gsp_class, name,
|
||||
GST_PAD_SRC, audio_out_count++);
|
||||
|
||||
g_free (name);
|
||||
}
|
||||
/* add input group pad templates */
|
||||
for (j = 0; j < gsp_class->num_group_in; ++j) {
|
||||
group = &g_array_index (klass->in_groups, GstLV2Group, j);
|
||||
gst_signal_processor_class_add_pad_template (gsp_class,
|
||||
slv2_value_as_string (group->symbol),
|
||||
GST_PAD_SINK, j, group->ports->len);
|
||||
}
|
||||
|
||||
/* add output group pad templates */
|
||||
for (j = 0; j < gsp_class->num_group_out; ++j) {
|
||||
group = &g_array_index (klass->out_groups, GstLV2Group, j);
|
||||
gst_signal_processor_class_add_pad_template (gsp_class,
|
||||
slv2_value_as_string (group->symbol),
|
||||
GST_PAD_SRC, j, group->ports->len);
|
||||
}
|
||||
|
||||
/* add non-grouped input port pad templates */
|
||||
for (j = 0; j < gsp_class->num_audio_in; ++j) {
|
||||
struct _GstLV2Port *desc =
|
||||
&g_array_index (klass->audio_in_ports, GstLV2Port, j);
|
||||
SLV2Port port = slv2_plugin_get_port_by_index (lv2plugin, desc->index);
|
||||
const gchar *name =
|
||||
slv2_value_as_string (slv2_port_get_symbol (lv2plugin, port));
|
||||
gst_signal_processor_class_add_pad_template (gsp_class, name, GST_PAD_SINK,
|
||||
j, 1);
|
||||
}
|
||||
|
||||
/* add non-grouped output port pad templates */
|
||||
for (j = 0; j < gsp_class->num_audio_out; ++j) {
|
||||
struct _GstLV2Port *desc =
|
||||
&g_array_index (klass->audio_out_ports, GstLV2Port, j);
|
||||
SLV2Port port = slv2_plugin_get_port_by_index (lv2plugin, desc->index);
|
||||
const gchar *name =
|
||||
slv2_value_as_string (slv2_port_get_symbol (lv2plugin, port));
|
||||
gst_signal_processor_class_add_pad_template (gsp_class, name, GST_PAD_SINK,
|
||||
j, 1);
|
||||
}
|
||||
g_assert (audio_in_count == gsp_class->num_audio_in);
|
||||
g_assert (audio_out_count == gsp_class->num_audio_out);
|
||||
|
||||
/* construct the element details struct */
|
||||
details = g_new0 (GstElementDetails, 1);
|
||||
|
|
@ -257,6 +289,10 @@ gst_lv2_class_get_param_spec (GstLV2Class * klass, gint portnum)
|
|||
if (lv2max)
|
||||
upper = slv2_value_as_float (lv2max);
|
||||
|
||||
slv2_value_free (lv2def);
|
||||
slv2_value_free (lv2min);
|
||||
slv2_value_free (lv2max);
|
||||
|
||||
if (def < lower) {
|
||||
GST_WARNING ("%s has lower bound %f > default %f\n",
|
||||
slv2_value_as_string (slv2_plugin_get_uri (lv2plugin)), lower, def);
|
||||
|
|
@ -306,7 +342,8 @@ gst_lv2_class_init (GstLV2Class * klass, SLV2Plugin lv2plugin)
|
|||
for (i = 0; i < gsp_class->num_control_in; i++) {
|
||||
GParamSpec *p;
|
||||
|
||||
p = gst_lv2_class_get_param_spec (klass, klass->control_in_ports[i].index);
|
||||
p = gst_lv2_class_get_param_spec (klass,
|
||||
g_array_index (klass->control_in_ports, GstLV2Port, i).index);
|
||||
|
||||
/* properties have an offset of 1 */
|
||||
g_object_class_install_property (G_OBJECT_CLASS (klass), i + 1, p);
|
||||
|
|
@ -315,7 +352,8 @@ gst_lv2_class_init (GstLV2Class * klass, SLV2Plugin lv2plugin)
|
|||
for (i = 0; i < gsp_class->num_control_out; i++) {
|
||||
GParamSpec *p;
|
||||
|
||||
p = gst_lv2_class_get_param_spec (klass, klass->control_out_ports[i].index);
|
||||
p = gst_lv2_class_get_param_spec (klass,
|
||||
g_array_index (klass->control_out_ports, GstLV2Port, i).index);
|
||||
|
||||
/* properties have an offset of 1, and we already added num_control_in */
|
||||
g_object_class_install_property (G_OBJECT_CLASS (klass),
|
||||
|
|
@ -425,10 +463,12 @@ gst_lv2_setup (GstSignalProcessor * gsp, guint sample_rate)
|
|||
/* connect the control ports */
|
||||
for (i = 0; i < gsp_class->num_control_in; i++)
|
||||
slv2_instance_connect_port (lv2->instance,
|
||||
oclass->control_in_ports[i].index, &(gsp->control_in[i]));
|
||||
g_array_index (oclass->control_in_ports, GstLV2Port, i).index,
|
||||
&(gsp->control_in[i]));
|
||||
for (i = 0; i < gsp_class->num_control_out; i++)
|
||||
slv2_instance_connect_port (lv2->instance,
|
||||
oclass->control_out_ports[i].index, &(gsp->control_out[i]));
|
||||
g_array_index (oclass->control_out_ports, GstLV2Port, i).index,
|
||||
&(gsp->control_out[i]));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
|
@ -486,18 +526,43 @@ gst_lv2_process (GstSignalProcessor * gsp, guint nframes)
|
|||
GstSignalProcessorClass *gsp_class;
|
||||
GstLV2 *lv2;
|
||||
GstLV2Class *oclass;
|
||||
guint i;
|
||||
GstLV2Group *lv2_group;
|
||||
GstLV2Port *lv2_port;
|
||||
GstSignalProcessorGroup *gst_group;
|
||||
guint i, j;
|
||||
|
||||
gsp_class = GST_SIGNAL_PROCESSOR_GET_CLASS (gsp);
|
||||
lv2 = (GstLV2 *) gsp;
|
||||
oclass = (GstLV2Class *) gsp_class;
|
||||
|
||||
for (i = 0; i < gsp_class->num_audio_in; i++)
|
||||
slv2_instance_connect_port (lv2->instance,
|
||||
oclass->audio_in_ports[i].index, gsp->audio_in[i]);
|
||||
for (i = 0; i < gsp_class->num_audio_out; i++)
|
||||
slv2_instance_connect_port (lv2->instance,
|
||||
oclass->audio_out_ports[i].index, gsp->audio_out[i]);
|
||||
for (i = 0; i < gsp_class->num_group_in; i++) {
|
||||
lv2_group = &g_array_index (oclass->in_groups, GstLV2Group, i);
|
||||
gst_group = &gsp->group_in[i];
|
||||
for (j = 0; j < lv2_group->ports->len; ++j) {
|
||||
lv2_port = &g_array_index (lv2_group->ports, GstLV2Port, j);
|
||||
slv2_instance_connect_port (lv2->instance, lv2_port->index,
|
||||
gst_group->buffer + (j * nframes));
|
||||
}
|
||||
}
|
||||
for (i = 0; i < gsp_class->num_audio_in; i++) {
|
||||
lv2_port = &g_array_index (oclass->audio_in_ports, GstLV2Port, i);
|
||||
slv2_instance_connect_port (lv2->instance, lv2_port->index,
|
||||
gsp->audio_in[i]);
|
||||
}
|
||||
for (i = 0; i < gsp_class->num_group_out; i++) {
|
||||
lv2_group = &g_array_index (oclass->out_groups, GstLV2Group, i);
|
||||
gst_group = &gsp->group_out[i];
|
||||
for (j = 0; j < lv2_group->ports->len; ++j) {
|
||||
lv2_port = &g_array_index (lv2_group->ports, GstLV2Port, j);
|
||||
slv2_instance_connect_port (lv2->instance, lv2_port->index,
|
||||
gst_group->buffer + (j * nframes));
|
||||
}
|
||||
}
|
||||
for (i = 0; i < gsp_class->num_audio_out; i++) {
|
||||
lv2_port = &g_array_index (oclass->audio_out_ports, GstLV2Port, i);
|
||||
slv2_instance_connect_port (lv2->instance, lv2_port->index,
|
||||
gsp->audio_out[i]);
|
||||
}
|
||||
|
||||
slv2_instance_run (lv2->instance, nframes);
|
||||
}
|
||||
|
|
@ -565,15 +630,15 @@ plugin_init (GstPlugin * plugin)
|
|||
control_class = slv2_value_new_uri (world, SLV2_PORT_CLASS_CONTROL);
|
||||
input_class = slv2_value_new_uri (world, SLV2_PORT_CLASS_INPUT);
|
||||
output_class = slv2_value_new_uri (world, SLV2_PORT_CLASS_OUTPUT);
|
||||
integer_prop =
|
||||
slv2_value_new_uri (world, "http://lv2plug.in/ns/lv2core#integer");
|
||||
toggled_prop =
|
||||
slv2_value_new_uri (world, "http://lv2plug.in/ns/lv2core#toggled");
|
||||
in_place_broken_pred = slv2_value_new_uri (world,
|
||||
"http://lv2plug.in/ns/lv2core#inPlaceBroken");
|
||||
in_group_pred =
|
||||
slv2_value_new_uri (world,
|
||||
"http://lv2plug.in/ns/dev/port-groups#inGroup");
|
||||
|
||||
#define NS_LV2 "http://lv2plug.in/ns/lv2core#"
|
||||
#define NS_PG "http://lv2plug.in/ns/dev/port-groups#"
|
||||
|
||||
integer_prop = slv2_value_new_uri (world, NS_LV2 "integer");
|
||||
toggled_prop = slv2_value_new_uri (world, NS_LV2 "toggled");
|
||||
in_place_broken_pred = slv2_value_new_uri (world, NS_LV2 "inPlaceBroken");
|
||||
in_group_pred = slv2_value_new_uri (world, NS_PG "inGroup");
|
||||
lv2_symbol_pred = slv2_value_new_string (world, NS_LV2 "symbol");
|
||||
|
||||
parent_class = g_type_class_ref (GST_TYPE_SIGNAL_PROCESSOR);
|
||||
|
||||
|
|
|
|||
|
|
@ -46,6 +46,8 @@ typedef struct _lv2_control_info {
|
|||
|
||||
typedef struct _GstLV2 GstLV2;
|
||||
typedef struct _GstLV2Class GstLV2Class;
|
||||
typedef struct _GstLV2Group GstLV2Group;
|
||||
typedef struct _GstLV2Port GstLV2Port;
|
||||
|
||||
|
||||
struct _GstLV2 {
|
||||
|
|
@ -57,9 +59,16 @@ struct _GstLV2 {
|
|||
gboolean activated;
|
||||
};
|
||||
|
||||
struct _GstLV2Group {
|
||||
SLV2Value uri; /**< RDF resource (URI or blank node) */
|
||||
guint pad; /**< Gst pad index */
|
||||
SLV2Value symbol; /**< Gst pad name / LV2 group symbol */
|
||||
GArray *ports; /**< Array of GstLV2Port */
|
||||
};
|
||||
|
||||
struct _GstLV2Port {
|
||||
gint index;
|
||||
SLV2Value group;
|
||||
gint index; /**< LV2 port index (on LV2 plugin) */
|
||||
gint pad; /**< Gst pad index (iff not part of a group) */
|
||||
};
|
||||
|
||||
struct _GstLV2Class {
|
||||
|
|
@ -67,12 +76,13 @@ struct _GstLV2Class {
|
|||
|
||||
SLV2Plugin plugin;
|
||||
|
||||
GSList *groups;
|
||||
GArray *in_groups; /**< Array of GstLV2Group */
|
||||
GArray *out_groups; /**< Array of GstLV2Group */
|
||||
GArray *audio_in_ports; /**< Array of GstLV2Port */
|
||||
GArray *audio_out_ports; /**< Array of GstLV2Port */
|
||||
GArray *control_in_ports; /**< Array of GstLV2Port */
|
||||
GArray *control_out_ports; /**< Array of GstLV2Port */
|
||||
|
||||
struct _GstLV2Port *audio_in_ports;
|
||||
struct _GstLV2Port *audio_out_ports;
|
||||
struct _GstLV2Port *control_in_ports;
|
||||
struct _GstLV2Port *control_out_ports;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -31,13 +31,14 @@
|
|||
* 1. store each received buffer on the pad and decrement pending_in
|
||||
* 2. when pending_in==0, process as much as we can and push outputs
|
||||
*
|
||||
* In pull mode (gst_signal_processor_getrange) is operates as follows:
|
||||
* In pull mode (gst_signal_processor_getrange) it operates as follows:
|
||||
* 1. if there is an output ready, deliver
|
||||
* 2. otherwise pull from each sink-pad, process requested frames and deliver
|
||||
* the buffer
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -63,6 +64,7 @@ struct _GstSignalProcessorPadTemplate
|
|||
GstPadTemplate parent;
|
||||
|
||||
guint index;
|
||||
guint channels;
|
||||
};
|
||||
|
||||
static GType
|
||||
|
|
@ -92,11 +94,10 @@ gst_signal_processor_pad_template_get_type (void)
|
|||
*/
|
||||
void
|
||||
gst_signal_processor_class_add_pad_template (GstSignalProcessorClass * klass,
|
||||
const gchar * name, GstPadDirection direction, guint index)
|
||||
const gchar * name, GstPadDirection direction, guint index, guint channels)
|
||||
{
|
||||
GstPadTemplate *new;
|
||||
GstCaps *caps;
|
||||
guint channels = 1;
|
||||
|
||||
g_return_if_fail (GST_IS_SIGNAL_PROCESSOR_CLASS (klass));
|
||||
g_return_if_fail (name != NULL);
|
||||
|
|
@ -111,6 +112,7 @@ gst_signal_processor_class_add_pad_template (GstSignalProcessorClass * klass,
|
|||
"direction", direction, "presence", GST_PAD_ALWAYS, "caps", caps, NULL);
|
||||
|
||||
GST_SIGNAL_PROCESSOR_PAD_TEMPLATE (new)->index = index;
|
||||
GST_SIGNAL_PROCESSOR_PAD_TEMPLATE (new)->channels = channels;
|
||||
|
||||
gst_element_class_add_pad_template (GST_ELEMENT_CLASS (klass), new);
|
||||
}
|
||||
|
|
@ -132,6 +134,9 @@ struct _GstSignalProcessorPad
|
|||
/* index for the pad per direction (starting from 0) */
|
||||
guint index;
|
||||
|
||||
/* number of channels for the pad */
|
||||
guint channels;
|
||||
|
||||
/* these are only used for sink pads */
|
||||
guint samples_avail; /* available mono sample frames */
|
||||
gfloat *data; /* data pointer to read from / write to */
|
||||
|
|
@ -208,6 +213,8 @@ gst_signal_processor_add_pad_from_template (GstSignalProcessor * self,
|
|||
"template", templ, NULL);
|
||||
GST_SIGNAL_PROCESSOR_PAD (new)->index =
|
||||
GST_SIGNAL_PROCESSOR_PAD_TEMPLATE (templ)->index;
|
||||
GST_SIGNAL_PROCESSOR_PAD (new)->channels =
|
||||
GST_SIGNAL_PROCESSOR_PAD_TEMPLATE (templ)->channels;
|
||||
|
||||
gst_pad_set_setcaps_function (new,
|
||||
GST_DEBUG_FUNCPTR (gst_signal_processor_setcaps));
|
||||
|
|
@ -244,20 +251,21 @@ gst_signal_processor_init (GstSignalProcessor * self,
|
|||
|
||||
while (templates) {
|
||||
GstPadTemplate *templ = GST_PAD_TEMPLATE (templates->data);
|
||||
|
||||
gst_signal_processor_add_pad_from_template (self, templ);
|
||||
templates = templates->next;
|
||||
}
|
||||
|
||||
self->state = GST_SIGNAL_PROCESSOR_STATE_NULL;
|
||||
|
||||
self->group_in = g_new0 (GstSignalProcessorGroup, klass->num_group_in);
|
||||
self->group_out = g_new0 (GstSignalProcessorGroup, klass->num_group_out);
|
||||
self->audio_in = g_new0 (gfloat *, klass->num_audio_in);
|
||||
self->control_in = g_new0 (gfloat, klass->num_control_in);
|
||||
self->audio_out = g_new0 (gfloat *, klass->num_audio_out);
|
||||
self->control_in = g_new0 (gfloat, klass->num_control_in);
|
||||
self->control_out = g_new0 (gfloat, klass->num_control_out);
|
||||
|
||||
/* init */
|
||||
self->pending_in = klass->num_audio_in;
|
||||
self->pending_in = klass->num_group_in + klass->num_audio_in;
|
||||
self->pending_out = 0;
|
||||
|
||||
self->sample_rate = 0;
|
||||
|
|
@ -268,12 +276,16 @@ gst_signal_processor_finalize (GObject * object)
|
|||
{
|
||||
GstSignalProcessor *self = GST_SIGNAL_PROCESSOR (object);
|
||||
|
||||
g_free (self->group_in);
|
||||
self->group_in = NULL;
|
||||
g_free (self->group_out);
|
||||
self->group_out = NULL;
|
||||
g_free (self->audio_in);
|
||||
self->audio_in = NULL;
|
||||
g_free (self->control_in);
|
||||
self->control_in = NULL;
|
||||
g_free (self->audio_out);
|
||||
self->audio_out = NULL;
|
||||
g_free (self->control_in);
|
||||
self->control_in = NULL;
|
||||
g_free (self->control_out);
|
||||
self->control_out = NULL;
|
||||
|
||||
|
|
@ -369,6 +381,7 @@ static void
|
|||
gst_signal_processor_cleanup (GstSignalProcessor * self)
|
||||
{
|
||||
GstSignalProcessorClass *klass;
|
||||
gint i;
|
||||
|
||||
klass = GST_SIGNAL_PROCESSOR_GET_CLASS (self);
|
||||
|
||||
|
|
@ -379,6 +392,16 @@ gst_signal_processor_cleanup (GstSignalProcessor * self)
|
|||
if (klass->cleanup)
|
||||
klass->cleanup (self);
|
||||
|
||||
for (i = 0; i < klass->num_group_in; ++i) {
|
||||
g_free (self->group_in[i].buffer);
|
||||
memset (&self->group_in[i], '\0', sizeof (GstSignalProcessorGroup));
|
||||
}
|
||||
|
||||
for (i = 0; i < klass->num_group_out; ++i) {
|
||||
g_free (self->group_out[i].buffer);
|
||||
memset (&self->group_in[i], '\0', sizeof (GstSignalProcessorGroup));
|
||||
}
|
||||
|
||||
self->state = GST_SIGNAL_PROCESSOR_STATE_NULL;
|
||||
}
|
||||
|
||||
|
|
@ -503,6 +526,36 @@ impossible:
|
|||
}
|
||||
}
|
||||
|
||||
/** De-interleave a pad (gstreamer => plugin) */
|
||||
static void
|
||||
gst_signal_processor_deinterleave_group (GstSignalProcessorGroup * group,
|
||||
guint nframes)
|
||||
{
|
||||
guint i, j;
|
||||
g_assert (group->nframes == nframes);
|
||||
g_assert (group->interleaved_buffer);
|
||||
g_assert (group->buffer);
|
||||
for (i = 0; i < nframes; ++i)
|
||||
for (j = 0; j < group->channels; ++j)
|
||||
group->buffer[(j * nframes) + i]
|
||||
= group->interleaved_buffer[(i * group->channels) + j];
|
||||
}
|
||||
|
||||
/** Interleave a pad (plugin => gstreamer) */
|
||||
static void
|
||||
gst_signal_processor_interleave_group (GstSignalProcessorGroup * group,
|
||||
guint nframes)
|
||||
{
|
||||
guint i, j;
|
||||
g_assert (group->nframes == nframes);
|
||||
g_assert (group->interleaved_buffer);
|
||||
g_assert (group->buffer);
|
||||
for (i = 0; i < nframes; ++i)
|
||||
for (j = 0; j < group->channels; ++j)
|
||||
group->interleaved_buffer[(i * group->channels) + j]
|
||||
= group->buffer[(j * nframes) + i];
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gst_signal_processor_event (GstPad * pad, GstEvent * event)
|
||||
{
|
||||
|
|
@ -543,18 +596,38 @@ gst_signal_processor_prepare (GstSignalProcessor * self, guint nframes)
|
|||
GstSignalProcessorClass *klass;
|
||||
GList *sinks, *srcs;
|
||||
guint samples_avail = nframes;
|
||||
guint i, in_group_index = 0, out_group_index = 0;
|
||||
|
||||
klass = GST_SIGNAL_PROCESSOR_GET_CLASS (self);
|
||||
|
||||
/* first, assign audio_in pointers, and determine the number of samples that
|
||||
* we can process */
|
||||
for (sinks = elem->sinkpads; sinks; sinks = sinks->next) {
|
||||
i = 0;
|
||||
for (sinks = elem->sinkpads; sinks; sinks = sinks->next, ++i) {
|
||||
GstSignalProcessorPad *sinkpad;
|
||||
|
||||
sinkpad = (GstSignalProcessorPad *) sinks->data;
|
||||
g_assert (sinkpad->samples_avail > 0);
|
||||
samples_avail = MIN (samples_avail, sinkpad->samples_avail);
|
||||
self->audio_in[sinkpad->index] = sinkpad->data;
|
||||
if (sinkpad->channels > 1) {
|
||||
GstSignalProcessorGroup *group = &self->group_in[in_group_index++];
|
||||
group->interleaved_buffer = sinkpad->data;
|
||||
/* allocate buffer for de-interleaving */
|
||||
if (!group->buffer || group->channels < sinkpad->channels
|
||||
|| group->nframes < samples_avail) {
|
||||
group->buffer =
|
||||
(gfloat *) g_realloc (group->buffer,
|
||||
samples_avail * sinkpad->channels * sizeof (gfloat));
|
||||
memset (group->buffer, '\0',
|
||||
samples_avail * sinkpad->channels * sizeof (gfloat));
|
||||
}
|
||||
g_assert (group->buffer);
|
||||
group->channels = sinkpad->channels;
|
||||
group->nframes = samples_avail;
|
||||
gst_signal_processor_deinterleave_group (group, samples_avail);
|
||||
} else {
|
||||
self->audio_in[sinkpad->index] = sinkpad->data;
|
||||
}
|
||||
}
|
||||
|
||||
/* FIXME: return if samples_avail==0 ? */
|
||||
|
|
@ -571,7 +644,9 @@ gst_signal_processor_prepare (GstSignalProcessor * self, guint nframes)
|
|||
sinkpad = (GstSignalProcessorPad *) sinks->data;
|
||||
srcpad = (GstSignalProcessorPad *) srcs->data;
|
||||
|
||||
if (GST_BUFFER_SIZE (sinkpad->pen) == samples_avail * sizeof (gfloat)) {
|
||||
if (sinkpad->channels == 1 && sinkpad->channels == srcpad->channels
|
||||
&& GST_BUFFER_SIZE (sinkpad->pen) ==
|
||||
samples_avail * sizeof (gfloat)) {
|
||||
/* reusable, yay */
|
||||
g_assert (sinkpad->samples_avail == samples_avail);
|
||||
srcpad->pen = sinkpad->pen;
|
||||
|
|
@ -597,11 +672,24 @@ gst_signal_processor_prepare (GstSignalProcessor * self, guint nframes)
|
|||
|
||||
ret =
|
||||
gst_pad_alloc_buffer_and_set_caps (GST_PAD (srcpad), -1,
|
||||
samples_avail * sizeof (gfloat), self->caps, &srcpad->pen);
|
||||
samples_avail * srcpad->channels * sizeof (gfloat), self->caps,
|
||||
&srcpad->pen);
|
||||
|
||||
if (ret != GST_FLOW_OK) {
|
||||
self->flow_state = ret;
|
||||
return 0;
|
||||
} else if (srcpad->channels > 1) {
|
||||
GstSignalProcessorGroup *group = &self->group_out[out_group_index++];
|
||||
group->interleaved_buffer = (gfloat *) GST_BUFFER_DATA (srcpad->pen);
|
||||
if (!group->buffer || group->channels < srcpad->channels
|
||||
|| group->nframes < samples_avail)
|
||||
group->buffer =
|
||||
(gfloat *) g_realloc (group->buffer,
|
||||
samples_avail * srcpad->channels * sizeof (gfloat));
|
||||
g_assert (group->buffer);
|
||||
group->channels = srcpad->channels;
|
||||
group->nframes = samples_avail;
|
||||
self->pending_out++;
|
||||
} else {
|
||||
self->audio_out[srcpad->index] = (gfloat *) GST_BUFFER_DATA (srcpad->pen);
|
||||
self->pending_out++;
|
||||
|
|
@ -640,11 +728,21 @@ gst_signal_processor_update_inputs (GstSignalProcessor * self, guint nprocessed)
|
|||
/* advance ->data pointers and decrement ->samples_avail, unreffing buffer
|
||||
if no samples are left */
|
||||
sinkpad->samples_avail -= nprocessed;
|
||||
sinkpad->data += nprocessed; /* gfloat* arithmetic */
|
||||
sinkpad->data += nprocessed * sinkpad->channels; /* gfloat* arithmetic */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
gst_signal_processor_update_outputs (GstSignalProcessor * self,
|
||||
guint nprocessed)
|
||||
{
|
||||
GstSignalProcessorClass *klass = GST_SIGNAL_PROCESSOR_GET_CLASS (self);
|
||||
guint i;
|
||||
for (i = 0; i < klass->num_group_out; ++i)
|
||||
gst_signal_processor_interleave_group (&self->group_out[i], nprocessed);
|
||||
}
|
||||
|
||||
static void
|
||||
gst_signal_processor_process (GstSignalProcessor * self, guint nframes)
|
||||
{
|
||||
|
|
@ -669,6 +767,7 @@ gst_signal_processor_process (GstSignalProcessor * self, guint nframes)
|
|||
klass->process (self, nframes);
|
||||
|
||||
gst_signal_processor_update_inputs (self, nframes);
|
||||
gst_signal_processor_update_outputs (self, nframes);
|
||||
|
||||
return;
|
||||
|
||||
|
|
@ -692,7 +791,8 @@ gst_signal_processor_pen_buffer (GstSignalProcessor * self, GstPad * pad,
|
|||
/* keep the reference */
|
||||
spad->pen = buffer;
|
||||
spad->data = (gfloat *) GST_BUFFER_DATA (buffer);
|
||||
spad->samples_avail = GST_BUFFER_SIZE (buffer) / sizeof (float);
|
||||
spad->samples_avail =
|
||||
GST_BUFFER_SIZE (buffer) / sizeof (float) / spad->channels;
|
||||
|
||||
g_assert (self->pending_in != 0);
|
||||
|
||||
|
|
|
|||
|
|
@ -62,10 +62,18 @@ typedef enum
|
|||
#define GST_SIGNAL_PROCESSOR_IS_RUNNING(obj) \
|
||||
(GST_SIGNAL_PROCESSOR (obj)->state == GST_SIGNAL_PROCESSOR_STATE_RUNNING)
|
||||
|
||||
typedef struct _GstSignalProcessorGroup GstSignalProcessorGroup;
|
||||
typedef struct _GstSignalProcessor GstSignalProcessor;
|
||||
typedef struct _GstSignalProcessorClass GstSignalProcessorClass;
|
||||
|
||||
|
||||
struct _GstSignalProcessorGroup {
|
||||
guint channels; /**< Number of channels in buffers */
|
||||
guint nframes; /**< Number of frames currently allocated per channel */
|
||||
gfloat *interleaved_buffer; /**< Interleaved buffer (c1c2c1c2...)*/
|
||||
gfloat *buffer; /**< De-interleaved buffer (c1c1...c2c2...) */
|
||||
};
|
||||
|
||||
struct _GstSignalProcessor {
|
||||
GstElement element;
|
||||
|
||||
|
|
@ -81,23 +89,32 @@ struct _GstSignalProcessor {
|
|||
|
||||
/* pending inputs before processing can take place */
|
||||
guint pending_in;
|
||||
/* panding outputs to be filled */
|
||||
/* pending outputs to be filled */
|
||||
guint pending_out;
|
||||
|
||||
gfloat *control_in;
|
||||
/* multi-channel signal pads */
|
||||
GstSignalProcessorGroup *group_in;
|
||||
GstSignalProcessorGroup *group_out;
|
||||
|
||||
/* single channel signal pads */
|
||||
gfloat **audio_in;
|
||||
gfloat *control_out;
|
||||
gfloat **audio_out;
|
||||
|
||||
/* controls */
|
||||
gfloat *control_in;
|
||||
gfloat *control_out;
|
||||
};
|
||||
|
||||
struct _GstSignalProcessorClass {
|
||||
GstElementClass parent_class;
|
||||
|
||||
/*< public >*/
|
||||
guint num_control_in;
|
||||
guint num_group_in;
|
||||
guint num_group_out;
|
||||
guint num_audio_in;
|
||||
guint num_control_out;
|
||||
guint num_audio_out;
|
||||
guint num_control_in;
|
||||
guint num_control_out;
|
||||
|
||||
guint flags;
|
||||
|
||||
|
|
@ -114,7 +131,7 @@ struct _GstSignalProcessorClass {
|
|||
|
||||
GType gst_signal_processor_get_type (void);
|
||||
void gst_signal_processor_class_add_pad_template (GstSignalProcessorClass *klass,
|
||||
const gchar *name, GstPadDirection direction, guint index);
|
||||
const gchar *name, GstPadDirection direction, guint index, guint channels);
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue