#include <gtk/gtk.h>
#include <gst/gst.h>
-void play (GtkButton *button, gpointer data)
+#include "gstplayondemand.h"
+
+guint channels;
+GtkWidget *window, *vbox, *play_button, *reset_button, *quit_button;
+GtkWidget *hbox, *measure1_button, *measure2_button, *measure3_button, \
+ *measure4_button, *measure5_button, *measure6_button, *speed_scale;
+GstElement *src, *mad, *pod, *osssink, *pipeline;
+GstClock *element_clock;
+
+void
+play (GtkButton *button, gpointer data)
{
- g_signal_emit_by_name(G_OBJECT(data), "play", NULL, NULL);
+ g_signal_emit_by_name(G_OBJECT(pod), "play", NULL, NULL);
}
-
-void reset (GtkButton *button, gpointer data)
+
+void
+reset (GtkButton *button, gpointer data)
{
- g_signal_emit_by_name(G_OBJECT(data), "reset", NULL, NULL);
+ g_signal_emit_by_name(G_OBJECT(pod), "reset", NULL, NULL);
}
-
-int main(int argc, char **argv)
+
+void
+measure (GtkToggleButton *button, gpointer data)
+{
+ gst_play_on_demand_toggle_beat(GST_PLAYONDEMAND(pod),
+ GPOINTER_TO_UINT(data), 0);
+}
+
+void
+speed (GtkAdjustment *scale, gpointer data)
+{
+ gst_clock_set_speed(element_clock, gtk_adjustment_get_value(scale));
+}
+
+void
+setup_pipeline (gchar *filename)
{
- guint channels;
- GtkWidget *window, *vbox, *play_button, *reset_button, *quit_button;
- GstElement *src, *mad, *pod, *osssink, *pipeline;
-
- gst_init (&argc, &argv);
- gtk_init (&argc, &argv);
-
- if (argc!=2) {
- g_print("usage: %s <mp3-filename>\n", argv[0]);
- exit(-1);
- }
-
src = gst_element_factory_make("filesrc", "filesrc");
mad = gst_element_factory_make("mad", "mad");
pod = gst_element_factory_make("playondemand", "playondemand");
osssink = gst_element_factory_make("osssink", "osssink");
- g_object_set(G_OBJECT(src), "location", argv[1], NULL);
+ g_object_set(G_OBJECT(src), "location", filename, NULL);
+ g_object_set(G_OBJECT(pod), "silent", FALSE, NULL);
g_object_set(G_OBJECT(osssink), "fragment", 0x00180008, NULL);
g_object_get(G_OBJECT(osssink), "channels", &channels, NULL);
pipeline = gst_pipeline_new("app");
- gst_bin_add(GST_BIN(pipeline), src);
- gst_bin_add(GST_BIN(pipeline), mad);
- gst_bin_add(GST_BIN(pipeline), pod);
- gst_bin_add(GST_BIN(pipeline), osssink);
-
- gst_element_connect(src, mad);
- gst_element_connect(pod, osssink);
- gst_element_connect(mad, pod);
+ gst_bin_add_many(GST_BIN(pipeline), src, mad, pod, osssink, NULL);
+ gst_element_connect_many(src, mad, pod, osssink, NULL);
- gst_element_set_state(pipeline, GST_STATE_PLAYING);
+ element_clock = gst_bin_get_clock(GST_BIN(pipeline));
+ gst_element_set_clock(GST_ELEMENT(pod), element_clock);
+ /* gst_clock_set_speed(element_clock, 0.00001); */
+}
+void
+setup_gui (void)
+{
/* initialize gui elements ... */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- vbox = gtk_vbox_new(FALSE, 0);
+ vbox = gtk_vbox_new(TRUE, 0);
+ hbox = gtk_hbox_new(TRUE, 0);
play_button = gtk_button_new_with_label("play");
reset_button = gtk_button_new_with_label("reset");
quit_button = gtk_button_new_with_label("quit");
+ measure1_button = gtk_toggle_button_new_with_label("one");
+ measure2_button = gtk_toggle_button_new_with_label("two");
+ measure3_button = gtk_toggle_button_new_with_label("three");
+ measure4_button = gtk_toggle_button_new_with_label("four");
+ measure5_button = gtk_toggle_button_new_with_label("five");
+ measure6_button = gtk_toggle_button_new_with_label("six");
+ speed_scale = gtk_hscale_new_with_range(0.0, 0.001, 0.000001);
+ /* gtk_adjustment_set_value(GTK_ADJUSTMENT(speed_scale), 0.00001); */
/* do the packing stuff ... */
gtk_window_set_default_size(GTK_WINDOW(window), 96, 96);
gtk_container_add(GTK_CONTAINER(window), vbox);
- gtk_box_pack_start(GTK_BOX(vbox), play_button, FALSE, FALSE, 2);
- gtk_box_pack_start(GTK_BOX(vbox), reset_button, FALSE, FALSE, 2);
- gtk_box_pack_start(GTK_BOX(vbox), quit_button, FALSE, FALSE, 2);
+ gtk_box_pack_start(GTK_BOX(vbox), play_button, TRUE, FALSE, 2);
+ gtk_box_pack_start(GTK_BOX(vbox), reset_button, TRUE, FALSE, 2);
+ gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 2);
+ gtk_box_pack_start(GTK_BOX(hbox), measure1_button, TRUE, TRUE, 2);
+ gtk_box_pack_start(GTK_BOX(hbox), measure2_button, TRUE, TRUE, 2);
+ gtk_box_pack_start(GTK_BOX(hbox), measure3_button, TRUE, TRUE, 2);
+ gtk_box_pack_start(GTK_BOX(hbox), measure4_button, TRUE, TRUE, 2);
+ gtk_box_pack_start(GTK_BOX(hbox), measure5_button, TRUE, TRUE, 2);
+ gtk_box_pack_start(GTK_BOX(hbox), measure6_button, TRUE, TRUE, 2);
+ /*gtk_box_pack_start(GTK_BOX(vbox), speed_scale, TRUE, FALSE, 2);*/
+ gtk_box_pack_start(GTK_BOX(vbox), quit_button, TRUE, FALSE, 2);
/* connect things ... */
- g_signal_connect(G_OBJECT(play_button), "clicked", G_CALLBACK(play), pod);
- g_signal_connect(G_OBJECT(reset_button), "clicked", G_CALLBACK(reset), pod);
+ g_signal_connect(G_OBJECT(play_button), "clicked", G_CALLBACK(play), NULL);
+ g_signal_connect(G_OBJECT(reset_button), "clicked", G_CALLBACK(reset), NULL);
g_signal_connect(G_OBJECT(quit_button), "clicked", gtk_main_quit, NULL);
+ g_signal_connect(G_OBJECT(measure1_button), "toggled", G_CALLBACK(measure), GUINT_TO_POINTER(0));
+ g_signal_connect(G_OBJECT(measure2_button), "toggled", G_CALLBACK(measure), GUINT_TO_POINTER(1));
+ g_signal_connect(G_OBJECT(measure3_button), "toggled", G_CALLBACK(measure), GUINT_TO_POINTER(2));
+ g_signal_connect(G_OBJECT(measure4_button), "toggled", G_CALLBACK(measure), GUINT_TO_POINTER(3));
+ g_signal_connect(G_OBJECT(measure5_button), "toggled", G_CALLBACK(measure), GUINT_TO_POINTER(4));
+ g_signal_connect(G_OBJECT(measure6_button), "toggled", G_CALLBACK(measure), GUINT_TO_POINTER(5));
+ /*g_signal_connect(G_OBJECT(speed_scale), "value-changed", G_CALLBACK(speed), NULL);*/
/* show the gui. */
gtk_widget_show(play_button);
gtk_widget_show(reset_button);
gtk_widget_show(quit_button);
+ gtk_widget_show(measure1_button);
+ gtk_widget_show(measure2_button);
+ gtk_widget_show(measure3_button);
+ gtk_widget_show(measure4_button);
+ gtk_widget_show(measure5_button);
+ gtk_widget_show(measure6_button);
+ gtk_widget_show(hbox);
+ /*gtk_widget_show(speed_scale);*/
gtk_widget_show(vbox);
gtk_widget_show(window);
gtk_idle_add((GtkFunction)gst_bin_iterate, pipeline);
-
- gtk_main();
+}
+
+int
+main(int argc, char **argv)
+{
+ gst_init (&argc, &argv);
+ gtk_init (&argc, &argv);
+
+ if (argc!=2) {
+ g_print("usage: %s <mp3-filename>\n", argv[0]);
+ exit(-1);
+ }
+ setup_pipeline(argv[1]);
+ gst_element_set_state(pipeline, GST_STATE_PLAYING);
+ setup_gui();
+ gtk_main();
return 0;
}
filter_data = (_TYPE_ *) filter->buffer;
num_filter = filter->buffer_size / sizeof(_TYPE_);
+max_filter = (filter->play_from_beginning) ? num_filter : G_MAXUINT;
/******************************************************************************/
/* see if we've got any events coming through ... */
in = gst_pad_pull(filter->sinkpad);
}
- /******************************************************************************/
+ /****************************************************************************/
/* first handle data from the input buffer. */
GST_DEBUG(0, "--- done with events, going to input");
w = filter->write;
/* copy the input data to the filter's internal buffer. */
- if (filter->follow_stream_tail) {
- for (j = 0; j < num_in; j++) {
- filter_data[(w + j) % num_filter] = data_in[j];
- }
+ for (j = 0; (j < num_in) && ((w + j) < max_filter); j++) {
+ filter_data[(w + j) % num_filter] = data_in[j];
+ }
- filter->write = (w + j) % num_filter;
-
- /* update the start pointer */
- if ((filter->start != 0) || ((w + j) >= num_filter)) {
- filter->start = (filter->write + 1) % num_filter;
- }
- } else {
- for (j = 0; (j < num_in) && ((w + j) < num_filter); j++) {
- filter_data[w + j] = data_in[j];
- }
+ filter->write = (w + j) % num_filter;
- filter->write += j;
+ if ((w + j) >= num_filter) {
+ filter->buffer_filled_once = TRUE;
- /* if we're not following the stream tail, the buffer is just a straight
- buffer. so we need to set eos if we've passed the limit of the internal
- buffer size. */
- if ((w + j) >= num_filter) {
+ /* if we're not playing from the end of the stream, the buffer is not a
+ ring buffer, so it has a fixed size. we need to set eos here because
+ we've passed that limit. */
+ if (filter->play_from_beginning) {
filter->eos = TRUE;
}
}
+ /* update the start pointer */
+ if ((! filter->play_from_beginning) && filter->buffer_filled_once) {
+ filter->start = (filter->write + 1) % num_filter;
+ }
+
out = in;
} else {
- j = 0;
+ j = num_filter;
w = 0;
-
+
out = gst_buffer_new_from_pool(filter->bufpool, 0, 0);
}
- /******************************************************************************/
+ /****************************************************************************/
+ /* check to see if we have to add a new play pointer. */
+
+ GST_DEBUG(0, "--- done with input, checking clock before output");
+
+ play_on_demand_update_plays_from_clock(filter);
+
+ /****************************************************************************/
/* now handle output data. */
- GST_DEBUG(0, "--- done with input, going to output");
+ GST_DEBUG(0, "--- done with clock, going to output");
data_out = (_TYPE_ *) GST_BUFFER_DATA(out);
num_out = GST_BUFFER_SIZE(out) / sizeof(_TYPE_);
for (k = 0; k < num_out; k++) {
data_out[k] = zero;
}
-
+
/* output play pointer data. */
- for (t = 0; t < POD_MAX_PLAYS; t++) {
+ for (t = 0; t < GST_POD_MAX_PLAY_PTRS; t++) {
offset = filter->plays[t];
if (offset != G_MAXUINT) {
- if (filter->follow_stream_tail) {
+ if (! filter->play_from_beginning) {
for (k = 0; k < num_out; k++) {
data_out[k] = CLAMP(data_out[k] + filter_data[(offset + k) % num_filter], min, max);
}
} else {
- for (k = 0; (k < num_out) && ((offset + k) < (w + j)); k++) {
+ for (k = 0; (k < num_out) && (k < (w + j - offset)); k++) {
data_out[k] = CLAMP(data_out[k] + filter_data[offset + k], min, max);
}
}
- if ((offset < w) && ((offset + k) >= (w + j))) {
- filter->plays[t] = G_MAXUINT;
+ if ((! filter->play_from_beginning) || ((offset + k) < (w + j))) {
+ filter->plays[t] = (offset + k) % num_filter;
} else {
- filter->plays[t] = (filter->plays[t] + k) % num_filter;
+ filter->plays[t] = G_MAXUINT;
}
}
}
+ /****************************************************************************/
+ /* push out the buffer. */
+
GST_DEBUG(0, "--- done with output, pushing buffer %p", out);
gst_pad_push(filter->srcpad, out);
if (! filter->eos) {
in = gst_pad_pull(filter->sinkpad);
}
+
gst_element_yield (GST_ELEMENT (filter));
} while (TRUE);
#include "gstplayondemand.h"
-#define POD_MAX_PLAYS 192 /* maximum number of simultaneous plays */
-#define POD_BUFPOOL_SIZE 4096 /* gstreamer buffer size to make if no
+#define GST_POD_MAX_PLAY_PTRS 128 /* maximum number of simultaneous plays */
+#define GST_POD_NUM_MEASURES 8 /* default number of measures */
+#define GST_POD_NUM_BEATS 16 /* default number of beats in a measure */
+#define GST_POD_BUFPOOL_SIZE 4096 /* gstreamer buffer size to use if no
bufferpool is available, must be divisible
by sizeof(gfloat) */
-#define POD_BUFPOOL_NUM 6 /* number of buffers to allocate per chunk in
+#define GST_POD_BUFPOOL_NUM 6 /* number of buffers to allocate per chunk in
sink buffer pool */
-#define POD_BUFFER_SIZE 882000 /* enough space for 10 seconds of 16-bit audio
- at 44100 samples per second ... */
+#define GST_POD_BUFFER_SIZE 882000 /* enough space for 5 seconds of 32-bit float
+ audio at 44100 samples per second ... */
/* elementfactory information */
static GstElementDetails play_on_demand_details = {
"Play On Demand",
"Filter/Audio/Effect",
"LGPL",
- "Plays a stream whenever it receives a certain signal",
+ "Plays a stream at specific times, or when it receives a signal",
VERSION,
- "Leif Morgan Johnson <lmjohns3@eos.ncsu.edu>",
+ "Leif Morgan Johnson <leif@ambient.2y.net>",
"(C) 2001",
};
static guint gst_pod_filter_signals[LAST_SIGNAL] = { 0 };
enum {
- ARG_0,
- ARG_SILENT,
- ARG_FOLLOWTAIL,
- ARG_BUFFERSIZE
+ PROP_0,
+ PROP_SILENT,
+ PROP_PLAYFROMBEGINNING,
+ PROP_BUFFERSIZE,
+ PROP_NUM_BEATS,
+ PROP_NUM_MEASURES
};
-static GstPadTemplate*
-play_on_demand_sink_factory (void)
-{
- static GstPadTemplate *template = NULL;
-
- if (!template) {
- template = gst_pad_template_new
+static GstPadTemplate*
+play_on_demand_sink_factory (void)
+{
+ static GstPadTemplate *template = NULL;
+
+ if (!template) {
+ template = gst_pad_template_new
("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
gst_caps_append(gst_caps_new ("sink_int", "audio/raw",
GST_AUDIO_INT_PAD_TEMPLATE_PROPS),
gst_caps_new ("sink_float", "audio/raw",
GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS)),
NULL);
- }
- return template;
+ }
+ return template;
}
static GstPadTemplate*
play_on_demand_src_factory (void)
{
static GstPadTemplate *template = NULL;
-
+
if (!template)
- template = gst_pad_template_new
+ template = gst_pad_template_new
("src", GST_PAD_SRC, GST_PAD_ALWAYS,
gst_caps_append (gst_caps_new ("src_float", "audio/raw",
GST_AUDIO_FLOAT_MONO_PAD_TEMPLATE_PROPS),
gst_caps_new ("src_int", "audio/raw",
GST_AUDIO_INT_PAD_TEMPLATE_PROPS)),
NULL);
-
+
return template;
}
-static void play_on_demand_class_init (GstPlayOnDemandClass *klass);
-static void play_on_demand_init (GstPlayOnDemand *filter);
+static void play_on_demand_class_init (GstPlayOnDemandClass *klass);
+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_get_property (GObject *object,
+ guint prop_id,
+ 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 GstPadConnectReturn play_on_demand_pad_connect (GstPad *pad, GstCaps *caps);
-static GstPadConnectReturn play_on_demand_pad_connect (GstPad *pad, GstCaps *caps);
+static void play_on_demand_loop (GstElement *elem);
-static void play_on_demand_loop (GstElement *elem);
+static void play_on_demand_set_clock (GstElement *elem, GstClock *clock);
-static void play_on_demand_play_handler (GstElement *elem);
-static void play_on_demand_reset_handler (GstElement *elem);
+static void play_on_demand_play_handler (GstElement *elem);
+static void play_on_demand_add_play_ptr (GstPlayOnDemand *filter, guint pos);
+static void play_on_demand_reset_handler (GstElement *elem);
+
+static void play_on_demand_update_plays_from_clock (GstPlayOnDemand *filter);
static GstElementClass *parent_class = NULL;
{
const gchar *format;
GstPlayOnDemand *filter;
-
+
g_return_val_if_fail(caps != NULL, GST_PAD_CONNECT_DELAYED);
g_return_val_if_fail(pad != NULL, GST_PAD_CONNECT_DELAYED);
filter = GST_PLAYONDEMAND(GST_PAD_PARENT(pad));
gst_caps_get_string(caps, "format", &format);
-
+
gst_caps_get_int(caps, "rate", &filter->rate);
gst_caps_get_int(caps, "channels", &filter->channels);
-
+
if (strcmp(format, "int") == 0) {
filter->format = GST_PLAYONDEMAND_FORMAT_INT;
gst_caps_get_int (caps, "width", &filter->width);
gst_caps_get_boolean (caps, "signed", &filter->is_signed);
if (!filter->silent) {
- g_print ("PlayOnDemand : channels %d, rate %d\n",
+ g_print ("PlayOnDemand : channels %d, rate %d\n",
filter->channels, filter->rate);
g_print ("PlayOnDemand : format int, bit width %d, endianness %d, signed %s\n",
filter->width, filter->endianness, filter->is_signed ? "yes" : "no");
}
- } else if (strcmp(format, "float") == 0) {
+
+ filter->buffer_samples = filter->buffer_size;
+ filter->buffer_samples /= (filter->width) ? filter->width / 8 : 1;
+ filter->buffer_samples /= (filter->channels) ? filter->channels : 1;
+} else if (strcmp(format, "float") == 0) {
filter->format = GST_PLAYONDEMAND_FORMAT_FLOAT;
gst_caps_get_string (caps, "layout", &filter->layout);
gst_caps_get_float (caps, "intercept", &filter->intercept);
gst_caps_get_float (caps, "slope", &filter->slope);
if (!filter->silent) {
- g_print ("PlayOnDemand : channels %d, rate %d\n",
+ g_print ("PlayOnDemand : channels %d, rate %d\n",
filter->channels, filter->rate);
g_print ("PlayOnDemand : format float, layout %s, intercept %f, slope %f\n",
filter->layout, filter->intercept, filter->slope);
}
+
+ filter->buffer_samples = filter->buffer_size / sizeof(gfloat);
+ filter->buffer_samples /= (filter->channels) ? filter->channels : 1;
}
if (GST_CAPS_IS_FIXED (caps))
0,
(GInstanceInitFunc) play_on_demand_init,
};
- play_on_demand_type = g_type_register_static(GST_TYPE_ELEMENT, "GstPlayOnDemand", &play_on_demand_info, 0);
+ play_on_demand_type = g_type_register_static(GST_TYPE_ELEMENT,
+ "GstPlayOnDemand",
+ &play_on_demand_info, 0);
}
return play_on_demand_type;
}
parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
- g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SILENT,
+ g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_SILENT,
g_param_spec_boolean("silent","silent","silent",
TRUE, G_PARAM_READWRITE));
- g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FOLLOWTAIL,
- g_param_spec_boolean("follow-stream-tail","follow-stream-tail","follow-stream-tail",
- FALSE, G_PARAM_READWRITE));
+ g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_PLAYFROMBEGINNING,
+ g_param_spec_boolean("play-from-beginning","play-from-beginning","play-from-beginning",
+ TRUE, G_PARAM_READWRITE));
- g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BUFFERSIZE,
+ g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_BUFFERSIZE,
g_param_spec_uint("buffer-size","buffer-size","buffer-size",
- 0, G_MAXUINT - 1, POD_BUFFER_SIZE, G_PARAM_READWRITE));
+ 0, G_MAXUINT - 1, GST_POD_BUFFER_SIZE, G_PARAM_READWRITE));
+
+ g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_NUM_BEATS,
+ g_param_spec_uint("num-beats","num-beats","num-beats",
+ 0, G_MAXUINT - 1, GST_POD_NUM_BEATS, G_PARAM_READWRITE));
+
+ g_object_class_install_property(G_OBJECT_CLASS(klass), PROP_NUM_MEASURES,
+ g_param_spec_uint("num-measures","num-measures","num-measures",
+ 0, G_MAXUINT - 1, GST_POD_NUM_MEASURES, G_PARAM_READWRITE));
gobject_class->set_property = play_on_demand_set_property;
gobject_class->get_property = play_on_demand_get_property;
play_on_demand_init (GstPlayOnDemand *filter)
{
guint i;
-
+
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");
gst_pad_set_bufferpool_function(filter->sinkpad, play_on_demand_get_bufferpool);
gst_pad_set_connect_function(filter->sinkpad, play_on_demand_pad_connect);
-
+
gst_element_add_pad(GST_ELEMENT(filter), filter->sinkpad);
gst_element_add_pad(GST_ELEMENT(filter), filter->srcpad);
gst_element_set_loop_function(GST_ELEMENT(filter), play_on_demand_loop);
- filter->follow_stream_tail = FALSE;
- filter->silent = TRUE;
-
- filter->buffer = g_new(gchar, POD_BUFFER_SIZE);
- filter->buffer_size = POD_BUFFER_SIZE;
+ filter->buffer = g_new(gchar, GST_POD_BUFFER_SIZE);
+ filter->buffer_size = GST_POD_BUFFER_SIZE;
filter->start = 0;
filter->write = 0;
- filter->eos = FALSE;
+ filter->eos = FALSE;
+ filter->buffer_filled_once = FALSE;
+ filter->play_from_beginning = TRUE;
+ filter->silent = TRUE;
+
+ GST_ELEMENT (filter)->setclockfunc = play_on_demand_set_clock;
+ filter->clock = NULL;
+ filter->last_time = 0;
+
+ filter->num_beats = GST_POD_NUM_BEATS;
+ filter->num_measures = GST_POD_NUM_MEASURES;
+ filter->total_beats = filter->num_beats * filter->num_measures;
+ filter->times = g_new(guint64, filter->num_measures);
+ for (i = 0; i < filter->num_measures; i++) {
+ filter->times[i] = 0;
+ }
/* the plays are stored as an array of buffer offsets. this initializes the
- array to `blank' values (G_MAXUINT is an invalid index for this filter). */
- filter->plays = g_new(guint, POD_MAX_PLAYS);
- for (i = 0; i < POD_MAX_PLAYS; i++) {
+ array to `blank' values (G_MAXUINT is the `invalid' index). */
+ filter->plays = g_new(guint, GST_POD_MAX_PLAY_PTRS);
+ for (i = 0; i < GST_POD_MAX_PLAY_PTRS; i++) {
filter->plays[i] = G_MAXUINT;
}
}
play_on_demand_loop (GstElement *elem)
{
GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
- guint num_in, num_out, num_filter;
+ guint num_in, num_out, num_filter, max_filter;
GstBuffer *in, *out;
register guint j, k, t;
guint w, offset;
-
+
g_return_if_fail(filter != NULL);
g_return_if_fail(GST_IS_PLAYONDEMAND(filter));
filter->bufpool = gst_pad_get_bufferpool(filter->srcpad);
if (filter->bufpool == NULL) {
- filter->bufpool = gst_buffer_pool_get_default(POD_BUFPOOL_SIZE, POD_BUFPOOL_NUM);
+ filter->bufpool = gst_buffer_pool_get_default(GST_POD_BUFPOOL_SIZE,
+ GST_POD_BUFPOOL_NUM);
}
in = gst_pad_pull(filter->sinkpad);
}
static void
-play_on_demand_play_handler(GstElement *elem)
+play_on_demand_set_clock (GstElement *elem, GstClock *clock)
+{
+ GstPlayOnDemand *filter;
+ g_return_if_fail(GST_IS_PLAYONDEMAND(elem));
+ filter = GST_PLAYONDEMAND(elem);
+ g_return_if_fail(filter != NULL);
+
+ filter->clock = clock;
+}
+
+static void
+play_on_demand_play_handler (GstElement *elem)
+{
+ GstPlayOnDemand *filter;
+
+ g_return_if_fail(GST_IS_PLAYONDEMAND(elem));
+ filter = GST_PLAYONDEMAND(elem);
+ g_return_if_fail(filter != NULL);
+
+ play_on_demand_add_play_ptr(filter, filter->start);
+}
+
+static void
+play_on_demand_add_play_ptr (GstPlayOnDemand *filter, guint pos)
{
- GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
register guint i;
- for (i = 0; i < POD_MAX_PLAYS; i++) {
+ for (i = 0; i < GST_POD_MAX_PLAY_PTRS; i++) {
if (filter->plays[i] == G_MAXUINT) {
- filter->plays[i] = filter->start;
- break;
+ filter->plays[i] = pos;
+ return;
}
}
}
static void
play_on_demand_reset_handler(GstElement *elem)
{
- GstPlayOnDemand *filter = GST_PLAYONDEMAND(elem);
+ GstPlayOnDemand *filter;
register guint i;
-
- for (i = 0; i < POD_MAX_PLAYS; i++) {
+
+ g_return_if_fail(GST_IS_PLAYONDEMAND(elem));
+ filter = GST_PLAYONDEMAND(elem);
+ g_return_if_fail(filter != NULL);
+
+ for (i = 0; i < GST_POD_MAX_PLAY_PTRS; i++) {
filter->plays[i] = G_MAXUINT;
}
filter->start = 0;
filter->write = 0;
+ filter->eos = FALSE;
+ filter->buffer_filled_once = FALSE;
+
+ for (i = 0; i < filter->num_measures; i++) {
+ filter->times[i] = 0;
+ }
}
+#define GST_POD_SAMPLE_OFFSET(f, dt) (((f)->start - ((dt) / (f)->rate)) % (f)->buffer_samples)
+
static void
-play_on_demand_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+play_on_demand_update_plays_from_clock(GstPlayOnDemand *filter)
+{
+ register guint t;
+ guint total, beats, last, time;
+
+ g_return_if_fail(GST_IS_PLAYONDEMAND(filter));
+ g_return_if_fail(filter != NULL);
+
+ if (filter->clock) {
+ total = filter->total_beats;
+ beats = filter->num_beats;
+
+ last = filter->last_time;
+ time = (guint) ((gst_clock_get_time(filter->clock) / 10000000LL) % total);
+ filter->last_time = time;
+
+ GST_DEBUG(0, "--- clock time %u, last %u, total %u", time, last, total);
+
+ /* if the current time is less than the last time, the clock has wrapped
+ around the total number of beats ... we need to count back to 0 and then
+ wrap around to the end. */
+ if (time < last) {
+ for (t = time; t != G_MAXUINT; t--) {
+ if (filter->times[t / beats] & ((guint64) 1 << (t % beats))) {
+ play_on_demand_add_play_ptr(filter,
+ GST_POD_SAMPLE_OFFSET(filter, time - t));
+ }
+ }
+
+ time = total - 1;
+ }
+
+ for (t = time; t > last; t--) {
+ if (filter->times[t / beats] & ((guint64) 1 << (t % beats))) {
+ play_on_demand_add_play_ptr(filter,
+ GST_POD_SAMPLE_OFFSET(filter, time - t));
+ }
+ }
+ }
+}
+
+void
+gst_play_on_demand_set_beat(GstPlayOnDemand *filter, const guint measure,
+ const guint beat, const gboolean value)
+{
+ g_return_if_fail(GST_IS_PLAYONDEMAND(filter));
+ g_return_if_fail(filter != NULL);
+ g_return_if_fail(filter->num_measures > measure);
+ g_return_if_fail(filter->total_beats < (filter->num_beats * measure + beat));
+
+ if (value) {
+ filter->times[measure] |= (1 << beat);
+ } else {
+ filter->times[measure] &= (((guint64) -1) ^ (1 << beat));
+ }
+}
+
+gboolean
+gst_play_on_demand_get_beat(GstPlayOnDemand *filter, const guint measure,
+ const guint beat)
+{
+ g_return_val_if_fail(GST_IS_PLAYONDEMAND(filter), FALSE);
+ g_return_val_if_fail(filter != NULL, FALSE);
+ g_return_val_if_fail(filter->num_measures > measure, FALSE);
+ g_return_val_if_fail(filter->total_beats >
+ (filter->num_beats * measure + beat), FALSE);
+
+ return ((filter->times[measure] >> beat) & ((guint64) 1));
+}
+
+void
+gst_play_on_demand_toggle_beat(GstPlayOnDemand *filter, const guint measure,
+ const guint beat)
+{
+ g_return_if_fail(GST_IS_PLAYONDEMAND(filter));
+ g_return_if_fail(filter != NULL);
+ g_return_if_fail(filter->num_measures > measure);
+ g_return_if_fail(filter->total_beats > (filter->num_beats * measure + beat));
+
+ filter->times[measure] ^= (1 << beat);
+}
+
+static void
+play_on_demand_set_property (GObject *object, guint prop_id,
+ const GValue *value, GParamSpec *pspec)
{
GstPlayOnDemand *filter;
+ register guchar c;
+ register guint i;
+ gchar *new_buffer;
+ guint64 *new_measures;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail(GST_IS_PLAYONDEMAND(object));
filter = GST_PLAYONDEMAND(object);
+ g_return_if_fail(filter != NULL);
switch (prop_id) {
- case ARG_BUFFERSIZE:
+ case PROP_BUFFERSIZE:
filter->buffer_size = g_value_get_uint(value);
- /* reallocate space for the buffer with the new size values. */
+ if (filter->format == GST_PLAYONDEMAND_FORMAT_FLOAT) {
+ filter->buffer_samples = filter->buffer_size \
+ / sizeof(gfloat) / filter->channels;
+ } else {
+ filter->buffer_samples = filter->buffer_size \
+ / filter->width / filter->channels;
+ }
+
+ /* allocate space for a new buffer, copy old data, remove invalid play
+ pointers. */
+ new_buffer = g_new(gchar, filter->buffer_size);
+ for (c = 0; c < filter->buffer_size; c++) {
+ new_buffer[c] = filter->buffer[c];
+ }
+
g_free(filter->buffer);
- filter->buffer = g_new(gchar, filter->buffer_size);
+ filter->buffer = new_buffer;
- /* reset the play pointers and read/write indexes. */
- play_on_demand_reset_handler(GST_ELEMENT(filter));
+ for (i = 0; i < GST_POD_MAX_PLAY_PTRS; i++) {
+ if (filter->plays[i] > filter->buffer_size) {
+ filter->plays[i] = G_MAXUINT;
+ }
+ }
+ break;
+ case PROP_NUM_BEATS:
+ filter->num_beats = g_value_get_uint(value);
+ filter->total_beats = filter->num_measures * filter->num_beats;
break;
- case ARG_SILENT:
+ case PROP_NUM_MEASURES:
+ filter->num_measures = g_value_get_uint(value);
+ filter->total_beats = filter->num_measures * filter->num_beats;
+
+ /* reallocate space for beat information, copy old data. this will remove
+ measures at the end if the number of measures shrinks. */
+ new_measures = g_new(guint64, filter->num_measures);
+ for (i = 0; i < filter->num_measures; i++) {
+ new_measures[i] = filter->times[i];
+ }
+
+ g_free(filter->times);
+ filter->times = new_measures;
+ break;
+ case PROP_SILENT:
filter->silent = g_value_get_boolean(value);
break;
- case ARG_FOLLOWTAIL:
- filter->follow_stream_tail = g_value_get_boolean(value);
+ case PROP_PLAYFROMBEGINNING:
+ filter->play_from_beginning = g_value_get_boolean(value);
play_on_demand_reset_handler(GST_ELEMENT(filter));
break;
default:
}
static void
-play_on_demand_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+play_on_demand_get_property (GObject *object, guint prop_id,
+ GValue *value, GParamSpec *pspec)
{
GstPlayOnDemand *filter;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail(GST_IS_PLAYONDEMAND(object));
filter = GST_PLAYONDEMAND(object);
+ g_return_if_fail(filter != NULL);
switch (prop_id) {
- case ARG_BUFFERSIZE:
+ case PROP_BUFFERSIZE:
g_value_set_uint(value, filter->buffer_size);
break;
- case ARG_SILENT:
+ case PROP_SILENT:
g_value_set_boolean(value, filter->silent);
break;
- case ARG_FOLLOWTAIL:
- g_value_set_boolean(value, filter->follow_stream_tail);
+ case PROP_PLAYFROMBEGINNING:
+ g_value_set_boolean(value, filter->play_from_beginning);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
GST_TYPE_PLAYONDEMAND,
&play_on_demand_details);
g_return_val_if_fail(factory != NULL, FALSE);
-
+
gst_element_factory_add_pad_template(factory, play_on_demand_src_factory());
gst_element_factory_add_pad_template(factory, play_on_demand_sink_factory());
projects / platform / upstream / gstreamer.git / commitdiff