mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-01-03 05:59:10 +00:00
Code Issues 1 Projects Releases Wiki Activity

+ simplifying the filter's structure, but it's still not working perfectly + starting to wonder if/how midi integrati...

Browse source 
Original commit message from CVS:
+ simplifying the filter's structure, but it's still not working perfectly
+ starting to wonder if/how midi integration is possible ...
This commit is contained in:
Leif Johnson 2003-06-16 22:20:52 +00:00
parent bea8637738
commit 7e761258c1
4 changed files with 199 additions and 216 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
gst/playondemand/demo-mp3.c
View file

@ -3,24 +3,29 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <gst/gst.h> #include <gst/gst.h>
#define NUM_BEATS 16 #define NUM_BEATS 12
#define SPEED 1e-9
GtkWidget *window, *vbox, *beat_box, *button_box; GtkWidget *window, *vbox, *beat_box, *button_box;
GtkWidget *play_button, *clear_button, *reset_button, *quit_button; GtkWidget *play_button, *clear_button, *reset_button, *quit_button;
GtkWidget **beat_button; GtkWidget **beat_button;
GtkWidget *speed_scale; GtkWidget *speed_scale;
GtkObject *speed_adj; GtkObject *speed_adj;
GstElement *src, *mad, *pod, *osssink, *pipeline; GstElement *src, *mad, *pod, *sink, *pipeline;
GstClock *element_clock; GstClock *element_clock;
GSList *beats; guint32 *beats;
void void
played (GstElement *pod, gpointer data) played (GstElement *pod, gpointer data)
{ {
g_print("Played beat at %u\n", gint i;
((guint) (gst_clock_get_time(element_clock) *
(GTK_ADJUSTMENT(speed_adj))->value * SPEED)) % NUM_BEATS); g_print("Played beat at %02u, beats are ",
(guint) (gst_clock_get_time(element_clock) / GST_SECOND *
(GTK_ADJUSTMENT(speed_adj))->value) % NUM_BEATS);
for (i = 0; i <= NUM_BEATS / 32; i++) g_print ("%08x ", beats[i]);
g_print("\n");
} }
void void
@ -47,18 +52,19 @@ reset (GtkButton *button, gpointer data)
void void
beat (GtkToggleButton *button, gpointer data) beat (GtkToggleButton *button, gpointer data)
{ {
guint b = GPOINTER_TO_UINT(data);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)))
beats = g_slist_append(beats, data); beats[b / 32] |= 1 << (b % 32);
else else
beats = g_slist_remove(beats, data); beats[b / 32] &= ~ (1 << (b % 32));
g_object_set(G_OBJECT(pod), "tick-list", beats, NULL);
} }
void void
speed (GtkAdjustment *adjustment, gpointer data) speed (GtkAdjustment *adjustment, gpointer data)
{ {
g_object_set(G_OBJECT(pod), "clock-speed", adjustment->value * SPEED, NULL); g_object_set(G_OBJECT(pod), "tick-rate", adjustment->value, NULL);
/*gst_clock_set_speed(element_clock, adjustment->value * SPEED);*/ /*gst_clock_set_speed(element_clock, adjustment->value);*/
} }
void void
@ -67,17 +73,21 @@ setup_pipeline (gchar *filename)
src = gst_element_factory_make("filesrc", "filesrc"); src = gst_element_factory_make("filesrc", "filesrc");
mad = gst_element_factory_make("mad", "mad"); mad = gst_element_factory_make("mad", "mad");
pod = gst_element_factory_make("playondemand", "playondemand"); pod = gst_element_factory_make("playondemand", "playondemand");
osssink = gst_element_factory_make("osssink", "osssink"); sink = gst_element_factory_make("alsasink", "alsasink");
g_object_set(G_OBJECT(src), "location", filename, NULL); g_object_set(G_OBJECT(src), "location", filename, NULL);
g_object_set(G_OBJECT(osssink), "fragment", 0x00180008, NULL); g_object_set(G_OBJECT(sink), "period-count", 32,
"period-size", 512, NULL);
g_object_set(G_OBJECT(pod), "total-ticks", NUM_BEATS, g_object_set(G_OBJECT(pod), "total-ticks", NUM_BEATS,
"clock-speed", SPEED, NULL); "tick-rate", 1.0,
"max-plays", NUM_BEATS * 2, NULL);
g_object_get(G_OBJECT(pod), "ticks", &beats, NULL);
pipeline = gst_pipeline_new("app"); pipeline = gst_pipeline_new("app");
gst_bin_add_many(GST_BIN(pipeline), src, mad, pod, osssink, NULL); gst_bin_add_many(GST_BIN(pipeline), src, mad, pod, sink, NULL);
gst_element_link_many(src, mad, pod, osssink, NULL); gst_element_link_many(src, mad, pod, sink, NULL);
element_clock = gst_bin_get_clock(GST_BIN(pipeline)); element_clock = gst_bin_get_clock(GST_BIN(pipeline));
gst_element_set_clock(GST_ELEMENT(pod), element_clock); gst_element_set_clock(GST_ELEMENT(pod), element_clock);
@ -106,9 +116,9 @@ setup_gui (void)
quit_button = gtk_button_new_with_label("Quit"); quit_button = gtk_button_new_with_label("Quit");
for (i = 0; i < NUM_BEATS; i++) for (i = 0; i < NUM_BEATS; i++)
beat_button[i] = gtk_toggle_button_new_with_label(g_strdup_printf("%2d", i)); beat_button[i] = gtk_toggle_button_new_with_label(g_strdup_printf("%2d", i+1));
speed_adj = gtk_adjustment_new(1, 0.0, 2, 0.01, 0.1, 0.0); speed_adj = gtk_adjustment_new(1, 0.0, 10.0, 0.1, 1.0, 0.0);
speed_scale = gtk_hscale_new(GTK_ADJUSTMENT(speed_adj)); speed_scale = gtk_hscale_new(GTK_ADJUSTMENT(speed_adj));
gtk_scale_set_digits(GTK_SCALE(speed_scale), 4); gtk_scale_set_digits(GTK_SCALE(speed_scale), 4);
gtk_range_set_update_policy(GTK_RANGE(speed_scale), GTK_UPDATE_DISCONTINUOUS); gtk_range_set_update_policy(GTK_RANGE(speed_scale), GTK_UPDATE_DISCONTINUOUS);
@ -140,19 +150,7 @@ setup_gui (void)
g_signal_connect(G_OBJECT(beat_button[i]), "toggled", G_CALLBACK(beat), GUINT_TO_POINTER(i)); g_signal_connect(G_OBJECT(beat_button[i]), "toggled", G_CALLBACK(beat), GUINT_TO_POINTER(i));
/* show the gui. */ /* show the gui. */
gtk_widget_show(play_button); gtk_widget_show_all(window);
gtk_widget_show(clear_button);
gtk_widget_show(reset_button);
gtk_widget_show(quit_button);
for (i = 0; i < NUM_BEATS; i++)
gtk_widget_show(beat_button[i]);
gtk_widget_show(beat_box);
gtk_widget_show(button_box);
gtk_widget_show(speed_scale);
gtk_widget_show(vbox);
gtk_widget_show(window);
gtk_idle_add((GtkFunction)gst_bin_iterate, pipeline); gtk_idle_add((GtkFunction)gst_bin_iterate, pipeline);
} }

109
gst/playondemand/filter.func
View file

@ -5,18 +5,23 @@ _TYPE_ *data_in, *data_out, *filter_data;
filter_data = (_TYPE_ *) filter->buffer; filter_data = (_TYPE_ *) filter->buffer;
num_filter = filter->buffer_bytes / sizeof(_TYPE_); num_filter = filter->buffer_bytes / sizeof(_TYPE_);
/******************************************************************************/
/* see if we've got any events coming through ... */
do { do {
while (GST_IS_EVENT(in)) { /****************************************************************************/
/* see if we've got any events coming through ... */
while (! filter->eos && GST_IS_EVENT(in)) {
if (GST_EVENT_TYPE(in) == GST_EVENT_EOS) { if (GST_EVENT_TYPE(in) == GST_EVENT_EOS) {
gst_event_unref(in);
filter->eos = TRUE; filter->eos = TRUE;
} else if ((GST_EVENT_TYPE(in) == GST_EVENT_SEEK) || } else if ((GST_EVENT_TYPE(in) == GST_EVENT_SEEK) ||
(GST_EVENT_TYPE(in) == GST_EVENT_FLUSH)) { (GST_EVENT_TYPE(in) == GST_EVENT_FLUSH)) {
filter->eos = FALSE; filter->eos = FALSE;
filter->write = 0; filter->write = 0;
} else { } else {
if ((GST_EVENT_TYPE(in) == GST_EVENT_SEEK) ||
(GST_EVENT_TYPE(in) == GST_EVENT_FLUSH))
filter->write = 0;
gst_pad_push(filter->srcpad, in); gst_pad_push(filter->srcpad, in);
} }
@ -24,76 +29,81 @@ do {
} }
/****************************************************************************/ /****************************************************************************/
/* first handle data from the input buffer. */ /* handle data from the input buffer. */
/* only update the input if there hasn't been an eos yet. */
if (! filter->eos) { if (! filter->eos) {
register guint j, w = filter->write;
data_in = (_TYPE_ *) GST_BUFFER_DATA(in); data_in = (_TYPE_ *) GST_BUFFER_DATA(in);
num_in = GST_BUFFER_SIZE(in) / sizeof(_TYPE_); num_in = GST_BUFFER_SIZE(in) / sizeof(_TYPE_);
w = filter->write; for (j = 0; (j < num_in) && (w+j < num_filter); j++)
filter_data[w+j] = data_in[j];
/* copy the input data to the filter's internal buffer. */ filter->write += j;
for (j = 0; (j < num_in) && ((w + j) < num_filter); j++)
filter_data[(w + j) % num_filter] = data_in[j];
filter->write = (w + j) % num_filter; if (filter->write >= num_filter) filter->eos = TRUE;
if ((w + j) >= num_filter)
filter->eos = TRUE;
out = in; out = in;
} else { } else {
j = num_filter;
w = 0;
out = gst_buffer_new_from_pool(filter->bufpool, 0, 0); out = gst_buffer_new_from_pool(filter->bufpool, 0, 0);
} }
/****************************************************************************/ /****************************************************************************/
/* check to see if we have to add a new play pointer. */ /* check to see if we have to add new play pointers. */
if (filter->clock) { if (filter->clock) {
current_tick = ((guint) (gst_clock_get_time(filter->clock) * register gint t, tick_offset;
filter->clock_speed)) % filter->total_ticks;
if (current_tick != last_tick) { guint total_ticks = filter->total_ticks;
/* now we go through the tick list and play samples */ guint current_tick = \
tick_list = filter->tick_list; ((guint) (gst_clock_get_time(filter->clock) * filter->tick_rate /
while (tick_list) { GST_SECOND)) % total_ticks;
tick = GPOINTER_TO_UINT(tick_list->data);
if (current_tick == tick) /* for some reason modulo arithmetic isn't working for me here, i suspect
play_on_demand_add_play_pointer(filter, 0); some unsigned/signed voodoo. but it's probably safe to do this with an if
else if (GST_POD_TICK_ELAPSED(tick, current_tick, last_tick)) statement since it doesn't happen all that often ... */
play_on_demand_add_play_pointer(filter, GST_POD_SAMPLE_OFFSET(filter, current_tick - tick));
tick_list = g_slist_next(tick_list); tick_offset = current_tick - last_tick;
} if (tick_offset < 0) tick_offset += total_ticks;
last_tick = current_tick;
for (tick_offset -= 1, t = current_tick - tick_offset;
tick_offset >= 0;
tick_offset--, t--) {
if (t < 0) t += total_ticks;
if (filter->ticks[t / 32] & (1 << t % 32))
play_on_demand_add_play_pointer(
filter, filter->rate * tick_offset / filter->tick_rate);
} }
last_tick = current_tick;
} }
/****************************************************************************/ /****************************************************************************/
/* now handle output data. */ /* handle output data. */
data_out = (_TYPE_ *) GST_BUFFER_DATA(out); {
num_out = GST_BUFFER_SIZE(out) / sizeof(_TYPE_); register guint k, p;
for (k = 0; k < num_out; k++) data_out = (_TYPE_ *) GST_BUFFER_DATA(out);
data_out[k] = zero; num_out = GST_BUFFER_SIZE(out) / sizeof(_TYPE_);
/* output play pointer data. */ for (k = 0; k < num_out; k++) data_out[k] = zero;
if (! filter->mute)
for (t = 0; t < filter->max_plays; t++) { for (p = 0; p < filter->max_plays; p++) {
offset = filter->plays[t]; guint offset = filter->plays[p];
if (offset != G_MAXUINT) { if (offset != G_MAXUINT) {
for (k = 0; (k < num_out) && (offset + k < num_filter); k++)
data_out[k] = CLAMP(data_out[k] + filter_data[offset + k], min, max);
if ((offset + k) == num_filter) /* only copy audio data if the element's not muted. */
filter->plays[t] = G_MAXUINT; if (! filter->mute)
else for (k = 0; (k < num_out) && (offset+k < num_filter); k++)
filter->plays[t] = offset + k; data_out[k] = CLAMP(data_out[k] + filter_data[offset+k], min, max);
/* update the play pointer. k > 0 even if the filter is muted. */
filter->plays[p] = (offset+k >= num_filter) ? G_MAXUINT : offset + k;
} }
} }
@ -102,9 +112,8 @@ do {
gst_pad_push(filter->srcpad, out); gst_pad_push(filter->srcpad, out);
if (! filter->eos) in = (! filter->eos) ? gst_pad_pull(filter->sinkpad) : NULL;
in = gst_pad_pull(filter->sinkpad);
gst_element_interrupt (GST_ELEMENT (filter)); if (gst_element_interrupt (GST_ELEMENT (filter))) break;
} while (TRUE); } while (TRUE);

240
gst/playondemand/gstplayondemand.c
View file

@ -24,11 +24,14 @@
#include "gstplayondemand.h" #include "gstplayondemand.h"
/* in these files, a 'tick' is a discrete unit of time, usually around the 1ms
* range. a tick is not divisible into smaller units of time. 1ms is probably
* way beyond what a real computer can actually keep track of, but hey ... */
/* some default values */ /* some default values */
#define GST_POD_MAX_PLAYS 100 /* maximum simultaneous plays */ #define GST_POD_MAX_PLAYS 100 /* maximum simultaneous plays */
#define GST_POD_BUFFER_TIME 5.0 /* buffer length in seconds */ #define GST_POD_BUFFER_TIME 5.0 /* buffer length in seconds */
#define GST_POD_CLOCK_SPEED 1e-8 /* 0.1 sec/tick default */ #define GST_POD_TICK_RATE 1e-6 /* ticks per second */
/* buffer pool fallback values ... use if no buffer pool is available */ /* buffer pool fallback values ... use if no buffer pool is available */
#define GST_POD_BUFPOOL_SIZE 4096 #define GST_POD_BUFPOOL_SIZE 4096
@ -88,6 +91,7 @@ static void play_on_demand_class_init (GstPlayOnDemandClass *klass);
static void play_on_demand_init (GstPlayOnDemand *filter); static void play_on_demand_init (GstPlayOnDemand *filter);
static void play_on_demand_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void play_on_demand_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void play_on_demand_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static void play_on_demand_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
static void play_on_demand_dispose (GObject *object);
/* GStreamer functionality */ /* GStreamer functionality */
static GstBufferPool* play_on_demand_get_bufferpool (GstPad *pad); static GstBufferPool* play_on_demand_get_bufferpool (GstPad *pad);
@ -144,9 +148,9 @@ enum {
PROP_MUTE, PROP_MUTE,
PROP_BUFFER_TIME, PROP_BUFFER_TIME,
PROP_MAX_PLAYS, PROP_MAX_PLAYS,
PROP_CLOCK_SPEED, PROP_TICK_RATE,
PROP_TOTAL_TICKS, PROP_TOTAL_TICKS,
PROP_TICK_LIST, PROP_TICKS,
}; };
static guint gst_pod_filter_signals[LAST_SIGNAL] = { 0 }; static guint gst_pod_filter_signals[LAST_SIGNAL] = { 0 };
@ -163,40 +167,24 @@ play_on_demand_class_init (GstPlayOnDemandClass *klass)
gstelement_class = (GstElementClass *) klass; gstelement_class = (GstElementClass *) klass;
gst_pod_filter_signals[PLAYED_SIGNAL] = gst_pod_filter_signals[PLAYED_SIGNAL] =
g_signal_new("played", g_signal_new("played", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GstPlayOnDemandClass, played), G_STRUCT_OFFSET(GstPlayOnDemandClass, played),
NULL, NULL, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gst_pod_filter_signals[PLAY_SIGNAL] = gst_pod_filter_signals[PLAY_SIGNAL] =
g_signal_new("play", g_signal_new("play", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GstPlayOnDemandClass, play), G_STRUCT_OFFSET(GstPlayOnDemandClass, play),
NULL, NULL, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gst_pod_filter_signals[CLEAR_SIGNAL] = gst_pod_filter_signals[CLEAR_SIGNAL] =
g_signal_new("clear", g_signal_new("clear", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GstPlayOnDemandClass, clear), G_STRUCT_OFFSET(GstPlayOnDemandClass, clear),
NULL, NULL, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
gst_pod_filter_signals[RESET_SIGNAL] = gst_pod_filter_signals[RESET_SIGNAL] =
g_signal_new("reset", g_signal_new("reset", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GstPlayOnDemandClass, reset), G_STRUCT_OFFSET(GstPlayOnDemandClass, reset),
NULL, NULL, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
klass->play = play_on_demand_play_handler; klass->play = play_on_demand_play_handler;
klass->clear = play_on_demand_clear_handler; klass->clear = play_on_demand_clear_handler;
@ -206,45 +194,33 @@ play_on_demand_class_init (GstPlayOnDemandClass *klass)
gobject_class->set_property = play_on_demand_set_property; gobject_class->set_property = play_on_demand_set_property;
gobject_class->get_property = play_on_demand_get_property; gobject_class->get_property = play_on_demand_get_property;
gobject_class->dispose = play_on_demand_dispose;
gstelement_class->set_clock = play_on_demand_set_clock; gstelement_class->set_clock = play_on_demand_set_clock;
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_MUTE, g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_MUTE,
g_param_spec_boolean("mute", "Silence output", g_param_spec_boolean("mute", "Silence output", "Do not output any sound",
"Do not output any sound", FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
FALSE, G_PARAM_READWRITE));
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_BUFFER_TIME, g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_BUFFER_TIME,
g_param_spec_float("buffer-time", "Buffer length in seconds", g_param_spec_float("buffer-time", "Buffer length in seconds", "Number of seconds of audio the buffer holds",
"Number of seconds of audio the buffer holds", 0.0, G_MAXUINT / GST_AUDIO_MAX_RATE - 10, GST_POD_BUFFER_TIME, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
0.0, G_MAXUINT - 2, GST_POD_BUFFER_TIME, G_PARAM_READWRITE));
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_MAX_PLAYS, g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_MAX_PLAYS,
g_param_spec_uint("plays", "Maximum simultaneous playback", g_param_spec_uint("max-plays", "Maximum simultaneous playbacks", "Maximum allowed number of simultaneous plays from the buffer",
"Maximum allowed number of simultaneous plays from the buffer", 1, G_MAXUINT, GST_POD_MAX_PLAYS, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
1, G_MAXUINT, GST_POD_MAX_PLAYS, G_PARAM_READWRITE)); g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TICK_RATE,
g_param_spec_float("tick-rate", "Tick rate (ticks/second)", "The rate of musical ticks, the smallest time unit in a song",
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_CLOCK_SPEED, 0, G_MAXFLOAT, GST_POD_TICK_RATE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_param_spec_float("clock-speed", "Clock speed (ticks/second)",
"The relative speed of a musical tick",
0, G_MAXFLOAT, 1, G_PARAM_READWRITE));
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TOTAL_TICKS, g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TOTAL_TICKS,
g_param_spec_uint("total-ticks", "Total number of ticks", g_param_spec_uint("total-ticks", "Total number of ticks", "Total number of ticks in the tick array",
"Total number of ticks (only relevant for tick lists)", 1, G_MAXUINT, 1, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
1, G_MAXUINT, 1, G_PARAM_READWRITE)); g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TICKS,
g_param_spec_pointer("ticks", "Ticks to play sample on", "An array of ticks (musical times) at which to play the sample",
g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_TICK_LIST, G_PARAM_READWRITE));
g_param_spec_pointer("tick-list", "List of ticks to play",
"A list of ticks (musical times) at which to play the sample",
G_PARAM_WRITABLE));
} }
static void static void
play_on_demand_init (GstPlayOnDemand *filter) play_on_demand_init (GstPlayOnDemand *filter)
{ {
guint i;
filter->srcpad = gst_pad_new_from_template(play_on_demand_src_factory(), "src"); filter->srcpad = gst_pad_new_from_template(play_on_demand_src_factory(), "src");
filter->sinkpad = gst_pad_new_from_template(play_on_demand_sink_factory(), "sink"); filter->sinkpad = gst_pad_new_from_template(play_on_demand_sink_factory(), "sink");
@ -258,23 +234,14 @@ play_on_demand_init (GstPlayOnDemand *filter)
filter->clock = NULL; filter->clock = NULL;
/* filter properties */ filter->rate = 0;
filter->mute = FALSE;
filter->buffer_time = GST_POD_BUFFER_TIME; filter->ticks = g_new(guint32, filter->total_ticks / 32 + 1);
filter->max_plays = GST_POD_MAX_PLAYS; filter->plays = g_new(guint, filter->max_plays);
filter->clock_speed = GST_POD_CLOCK_SPEED;
filter->total_ticks = 1;
filter->tick_list = NULL;
/* internal buffer stuff */
play_on_demand_resize_buffer(filter); play_on_demand_resize_buffer(filter);
filter->eos = FALSE; play_on_demand_clear_handler(GST_ELEMENT(filter));
play_on_demand_reset_handler(GST_ELEMENT(filter));
/* play pointers, stored as an array of buffer offsets */
filter->write = 0;
filter->plays = g_new(guint, filter->max_plays);
for (i = 0; i < filter->max_plays; i++)
filter->plays[i] = G_MAXUINT;
} }
static void static void
@ -284,6 +251,7 @@ play_on_demand_set_property (GObject *object, guint prop_id,
GstPlayOnDemand *filter; GstPlayOnDemand *filter;
register guint i; register guint i;
guint new_size, min_size, *new_plays; guint new_size, min_size, *new_plays;
guint *new_ticks;
g_return_if_fail(GST_IS_PLAYONDEMAND(object)); g_return_if_fail(GST_IS_PLAYONDEMAND(object));
filter = GST_PLAYONDEMAND(object); filter = GST_PLAYONDEMAND(object);
@ -296,10 +264,9 @@ play_on_demand_set_property (GObject *object, guint prop_id,
filter->buffer_time = g_value_get_float(value); filter->buffer_time = g_value_get_float(value);
play_on_demand_resize_buffer(filter); play_on_demand_resize_buffer(filter);
/* clear out now-invalid play pointers, if there are any. */ /* clear out now-invalid play pointers */
for (i = 0; i < filter->max_plays; i++) for (i = 0; i < filter->max_plays; i++)
if (filter->plays[i] > filter->buffer_bytes) filter->plays[i] = G_MAXUINT;
filter->plays[i] = G_MAXUINT;
break; break;
case PROP_MAX_PLAYS: case PROP_MAX_PLAYS:
@ -308,21 +275,35 @@ play_on_demand_set_property (GObject *object, guint prop_id,
new_plays = g_new(guint, new_size); new_plays = g_new(guint, new_size);
for (i = 0; i < min_size; i++) new_plays[i] = filter->plays[i]; for (i = 0; i < min_size; i++) new_plays[i] = filter->plays[i];
for (i = min_size; i < filter->max_plays; i++) new_plays[i] = G_MAXUINT; for (i = min_size; i < new_size; i++) new_plays[i] = G_MAXUINT;
g_free(filter->plays); g_free(filter->plays);
filter->plays = new_plays; filter->plays = new_plays;
filter->max_plays = new_size; filter->max_plays = new_size;
break; break;
case PROP_CLOCK_SPEED: case PROP_TICK_RATE:
filter->clock_speed = g_value_get_float(value); filter->tick_rate = g_value_get_float(value);
break; break;
case PROP_TOTAL_TICKS: case PROP_TOTAL_TICKS:
filter->total_ticks = g_value_get_uint(value); new_size = g_value_get_uint(value);
min_size = (new_size < filter->total_ticks) ? new_size : filter->total_ticks;
new_ticks = g_new(guint32, new_size / 32 + 1);
for (i = 0; i <= min_size / 32; i++) new_ticks[i] = filter->ticks[i];
for (i = min_size / 32 + 1; i <= new_size / 32; i++) new_ticks[i] = 0;
g_free(filter->ticks);
filter->ticks = new_ticks;
filter->total_ticks = new_size;
break; break;
case PROP_TICK_LIST: case PROP_TICKS:
filter->tick_list = (GSList *) g_value_get_pointer(value); new_ticks = (guint *) g_value_get_pointer(value);
if (new_ticks) {
g_free(filter->ticks);
filter->ticks = new_ticks;
}
break; break;
default: default:
break; break;
@ -348,18 +329,33 @@ play_on_demand_get_property (GObject *object, guint prop_id,
case PROP_MAX_PLAYS: case PROP_MAX_PLAYS:
g_value_set_uint(value, filter->max_plays); g_value_set_uint(value, filter->max_plays);
break; break;
case PROP_CLOCK_SPEED: case PROP_TICK_RATE:
g_value_set_float(value, filter->clock_speed); g_value_set_float(value, filter->tick_rate);
break; break;
case PROP_TOTAL_TICKS: case PROP_TOTAL_TICKS:
g_value_set_uint(value, filter->total_ticks); g_value_set_uint(value, filter->total_ticks);
break; break;
case PROP_TICKS:
g_value_set_pointer(value, (gpointer) filter->ticks);
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break; break;
} }
} }
static void
play_on_demand_dispose (GObject *object)
{
GstPlayOnDemand *filter = GST_PLAYONDEMAND (object);
G_OBJECT_CLASS (parent_class)->dispose (object);
g_free (filter->ticks);
g_free (filter->plays);
g_free (filter->buffer);
}
static GstBufferPool* static GstBufferPool*
play_on_demand_get_bufferpool (GstPad *pad) play_on_demand_get_bufferpool (GstPad *pad)
{ {
@ -380,7 +376,7 @@ play_on_demand_pad_link (GstPad *pad, GstCaps *caps)
filter = GST_PLAYONDEMAND(GST_PAD_PARENT(pad)); filter = GST_PLAYONDEMAND(GST_PAD_PARENT(pad));
gst_caps_get_string(caps, "format", &format); gst_caps_get_string(caps, "format", &format);
gst_caps_get_int(caps, "rate", &filter->rate); gst_caps_get_int(caps, "rate", &filter->rate);
gst_caps_get_int(caps, "channels", &filter->channels); gst_caps_get_int(caps, "channels", &filter->channels);
if (strcmp(format, "int") == 0) { if (strcmp(format, "int") == 0) {
@ -397,21 +393,22 @@ play_on_demand_pad_link (GstPad *pad, GstCaps *caps)
return GST_PAD_LINK_DELAYED; return GST_PAD_LINK_DELAYED;
} }
/* clock check macros. in these macros, inline static void
f == filter play_on_demand_add_play_pointer (GstPlayOnDemand *filter, guint pos)
t == tick in question {
c == current tick (from the clock) register guint i;
l == last tick (last tick when clock was checked)
dt == ticks between c and t */
#define GST_POD_SAMPLE_OFFSET(f, dt) \
((guint) (dt * (f)->rate / (f)->clock_speed))
/* play a sample if the tick in question came between the last time we checked if (filter->rate && ((filter->buffer_time * filter->rate) > pos)) {
the clock and the current clock time. only looks complicated because the last for (i = 0; i < filter->max_plays; i++) {
clock time could have been at the end of the total_ticks, so the clock might if (filter->plays[i] == G_MAXUINT) {
have wrapped around ... */ filter->plays[i] = pos;
#define GST_POD_TICK_ELAPSED(t, c, l) \ /* emit a signal to indicate a sample being played */
(((l < c) && (l < t) && (t < c)) || ((l > c) && ((l < t) || (t < c)))) g_signal_emit(filter, gst_pod_filter_signals[PLAYED_SIGNAL], 0);
break;
}
}
}
}
static void static void
play_on_demand_loop (GstElement *elem) play_on_demand_loop (GstElement *elem)
@ -419,37 +416,30 @@ play_on_demand_loop (GstElement *elem)
GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem); GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
guint num_in, num_out, num_filter; guint num_in, num_out, num_filter;
GstBuffer *in, *out; GstBuffer *in, *out;
register guint j, k, t;
guint w, offset;
/* variables for clock check. */
static guint last_tick = 0; static guint last_tick = 0;
GSList *tick_list;
guint tick, current_tick;
g_return_if_fail(filter != NULL); g_return_if_fail(filter != NULL);
g_return_if_fail(GST_IS_PLAYONDEMAND(filter)); g_return_if_fail(GST_IS_PLAYONDEMAND(filter));
filter->bufpool = gst_pad_get_bufferpool(filter->srcpad); filter->bufpool = gst_pad_get_bufferpool(filter->srcpad);
if (filter->bufpool == NULL) { if (filter->bufpool == NULL)
filter->bufpool = gst_buffer_pool_get_default(GST_POD_BUFPOOL_SIZE, filter->bufpool = gst_buffer_pool_get_default(GST_POD_BUFPOOL_SIZE,
GST_POD_BUFPOOL_NUM); GST_POD_BUFPOOL_NUM);
}
in = gst_pad_pull(filter->sinkpad); in = gst_pad_pull(filter->sinkpad);
if (filter->format == GST_PLAYONDEMAND_FORMAT_INT) { if (filter->format == GST_PLAYONDEMAND_FORMAT_INT) {
if (filter->width == 16) { if (filter->width == 16) {
gint16 min = -32768; gint16 min = 0xffff;
gint16 max = 32767; gint16 max = 0x7fff;
gint16 zero = 0; gint16 zero = 0;
#define _TYPE_ gint16 #define _TYPE_ gint16
#include "filter.func" #include "filter.func"
#undef _TYPE_ #undef _TYPE_
} else if (filter->width == 8) { } else if (filter->width == 8) {
gint8 min = -128; gint8 min = 0xff;
gint8 max = 127; gint8 max = 0x7f;
gint8 zero = 0; gint8 zero = 0;
#define _TYPE_ gint8 #define _TYPE_ gint8
#include "filter.func" #include "filter.func"
@ -493,6 +483,7 @@ static void
play_on_demand_clear_handler (GstElement *elem) play_on_demand_clear_handler (GstElement *elem)
{ {
GstPlayOnDemand *filter; GstPlayOnDemand *filter;
register guint i;
g_return_if_fail(elem != NULL); g_return_if_fail(elem != NULL);
g_return_if_fail(GST_IS_PLAYONDEMAND(elem)); g_return_if_fail(GST_IS_PLAYONDEMAND(elem));
@ -500,6 +491,9 @@ play_on_demand_clear_handler (GstElement *elem)
filter->write = 0; filter->write = 0;
filter->eos = FALSE; filter->eos = FALSE;
for (i = 0; i < filter->max_plays; i++) filter->plays[i] = G_MAXUINT;
for (i = 0; i < filter->buffer_bytes; i++) filter->buffer[i] = 0;
} }
static void static void
@ -508,39 +502,21 @@ play_on_demand_reset_handler (GstElement *elem)
GstPlayOnDemand *filter; GstPlayOnDemand *filter;
register guint i; register guint i;
play_on_demand_clear_handler (elem);
g_return_if_fail(elem != NULL); g_return_if_fail(elem != NULL);
g_return_if_fail(GST_IS_PLAYONDEMAND(elem)); g_return_if_fail(GST_IS_PLAYONDEMAND(elem));
filter = GST_PLAYONDEMAND(elem); filter = GST_PLAYONDEMAND(elem);
for (i = 0; i < filter->max_plays; i++) { for (i = 0; i <= filter->total_ticks / 32; i++) filter->ticks[i] = 0;
filter->plays[i] = G_MAXUINT;
}
filter->write = 0;
filter->eos = FALSE;
}
static void
play_on_demand_add_play_pointer (GstPlayOnDemand *filter, guint pos)
{
register guint i;
if (filter->rate && ((filter->buffer_time * filter->rate) > pos))
for (i = 0; i < filter->max_plays; i++)
if (filter->plays[i] == G_MAXUINT) {
filter->plays[i] = pos;
/* emit a signal to indicate a sample being played */
g_signal_emit(filter, gst_pod_filter_signals[PLAYED_SIGNAL], 0);
return;
}
} }
static void static void
play_on_demand_resize_buffer (GstPlayOnDemand *filter) play_on_demand_resize_buffer (GstPlayOnDemand *filter)
{ {
register guint i; register guint i;
guint new_size, min_size; guint new_size, min_size;
gchar *new_buffer; gchar *new_buffer;
/* use a default sample rate of 44100, 1 channel, 1 byte per sample if caps /* use a default sample rate of 44100, 1 channel, 1 byte per sample if caps
haven't been set yet */ haven't been set yet */
@ -557,7 +533,7 @@ play_on_demand_resize_buffer (GstPlayOnDemand *filter)
new_buffer = g_new(gchar, new_size); new_buffer = g_new(gchar, new_size);
for (i = 0; i < min_size; i++) new_buffer[i] = filter->buffer[i]; for (i = 0; i < min_size; i++) new_buffer[i] = filter->buffer[i];
for (i = min_size; i < filter->buffer_bytes; i++) new_buffer[i] = 0; for (i = min_size; i < new_size; i++) new_buffer[i] = 0;
g_free(filter->buffer); g_free(filter->buffer);
filter->buffer = new_buffer; filter->buffer = new_buffer;

4
gst/playondemand/gstplayondemand.h
View file

@ -63,9 +63,9 @@ struct _GstPlayOnDemand {
gboolean mute; gboolean mute;
gfloat buffer_time; gfloat buffer_time;
guint max_plays; guint max_plays;
gfloat clock_speed; gfloat tick_rate;
guint total_ticks; guint total_ticks;
GSList *tick_list; guint32 *ticks;
/* internal buffer info */ /* internal buffer info */
gchar *buffer; gchar *buffer;