gstreamer/testsuite/bytestream/test1.c
Benjamin Otte c29e35436f gst/gstbin.c: don't add decoupled elements to schedulers - otherwise it's impossible to control if a link to a decoup...
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_set_element_sched),
(gst_bin_unset_element_sched):
don't add decoupled elements to schedulers - otherwise it's
impossible to control if a link to a decoupled element was already
removed from a scheduler or not.
* gst/schedulers/cothreads_compat.h:
* gst/schedulers/gthread-cothreads.h:
add COTHREADS_TYPE macro. Make do_cothread_set_func a macro so there
is no "unused" warning.
* gst/schedulers/Makefile.am:
* gst/schedulers/entryscheduler.c:
add new scheduler, based on ideas from talking to David and Martin.
It's supposed to be small and correct. Currently it's also slow (but
it's not noticable)
* examples/retag/retag.c: (main):
* testsuite/bytestream/test1.c: (main):
fix missing NULLs at end of variadic functions
* testsuite/elements/.cvsignore:
update
2004-03-28 02:29:24 +00:00

230 lines
5.1 KiB
C

#include <string.h>
#include <stdlib.h>
#include <gst/gst.h>
#define VM_THRES 1000
#define MAX_CONFIG_LINE 255
#define MAX_CONFIG_PATTERN 64
typedef struct
{
gint src_data;
gint src_sizetype;
gchar *bs_accesspattern;
gboolean integrity_check;
}
TestParam;
static GSList *params = NULL;
static guint8 count;
static guint iterations;
static gboolean integrity_check = TRUE;
static gboolean verbose = FALSE;
static gboolean dump = FALSE;
static void
handoff (GstElement * element, GstBuffer * buf, GstPad * pad, gpointer data)
{
if (GST_IS_BUFFER (buf)) {
if (integrity_check) {
gint i;
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = 0; i < GST_BUFFER_SIZE (buf); i++) {
if (*ptr++ != count++) {
g_print ("data error!\n");
return;
}
}
}
} else {
g_print ("not a buffer ! %p\n", buf);
}
}
static gchar *
create_desc (TestParam * param)
{
gchar *desc;
desc =
g_strdup_printf ("%s %s, pattern %s",
(param->src_sizetype == 2 ? "fixed" : "random"),
(param->src_data == 1 ? "src" : "subbuffer"), param->bs_accesspattern);
return desc;
}
static gboolean
read_param_file (gchar * filename)
{
FILE *fp;
gchar line[MAX_CONFIG_LINE + 1];
guint linenr = 0;
gchar pattern[MAX_CONFIG_PATTERN];
gint data, sizetype, integrity_check;
gchar *scan_str;
gboolean res = TRUE;
fp = fopen (filename, "r");
if (fp == NULL)
return FALSE;
scan_str = g_strdup_printf ("%%d %%d %%%ds %%d", MAX_CONFIG_PATTERN - 1);
while (fgets (line, MAX_CONFIG_LINE, fp)) {
linenr++;
if (line[0] == '\n' || line[0] == '#')
continue;
if (sscanf (line, scan_str, &data, &sizetype, pattern,
&integrity_check) != 4) {
g_print ("error on line: %d\n", linenr);
res = FALSE;
break;
} else {
TestParam *param = g_malloc (sizeof (TestParam));
param->src_data = data;
param->src_sizetype = sizetype;
param->bs_accesspattern = g_strdup (pattern);
param->integrity_check = (integrity_check == 0 ? FALSE : TRUE);
params = g_slist_append (params, param);
}
}
g_free (scan_str);
return res;
}
static void
run_test (GstBin * pipeline, gint iters)
{
gint vm = 0;
gint maxiters = iters;
gint prev_percent = -1;
count = 0;
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
while (iters) {
gint newvm = gst_alloc_trace_live_all ();
gint percent;
percent = (gint) ((maxiters - iters + 1) * 100.0 / maxiters);
if (percent != prev_percent || newvm - vm > VM_THRES) {
g_print ("\r%d (delta %d) %.3d%% ", newvm, newvm - vm,
percent);
prev_percent = percent;
vm = newvm;
}
gst_bin_iterate (pipeline);
if (iters > 0)
iters--;
}
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL);
}
static void
usage (char *argv[])
{
g_print ("usage: %s [--verbose] [--dump] <paramfile> <iterations>\n",
argv[0]);
}
int
main (int argc, char *argv[])
{
GstElement *src;
GstElement *sink;
GstElement *bs;
GstElement *pipeline;
gint testnum = 0;
GSList *walk;
gint arg_walk;
gst_alloc_trace_set_flags_all (GST_ALLOC_TRACE_LIVE);
gst_init (&argc, &argv);
arg_walk = 1;
while ((arg_walk < argc) && (argv[arg_walk][0] == '-')) {
if (!strncmp (argv[arg_walk], "--verbose", 9))
verbose = TRUE;
else if (!strncmp (argv[arg_walk], "--dump", 6))
dump = TRUE;
else {
g_print ("unknown option %s (ignored)\n", argv[arg_walk]);
}
arg_walk++;
}
if (argc - arg_walk < 2) {
usage (argv);
return -1;
}
if (!read_param_file (argv[arg_walk])) {
g_print ("error reading file %s\n", argv[arg_walk]);
usage (argv);
return -1;
}
arg_walk++;
iterations = atoi (argv[arg_walk]);
pipeline = gst_element_factory_make ("pipeline", "pipeline");
g_assert (pipeline);
src = gst_element_factory_make ("fakesrc", "src");
g_assert (src);
sink = gst_element_factory_make ("fakesink", "sink");
g_assert (sink);
g_object_set (sink, "signal-handoff", TRUE, NULL);
g_signal_connect (G_OBJECT (sink), "handoff", G_CALLBACK (handoff), NULL);
bs = gst_element_factory_make ("bstest", "bs");
g_assert (bs);
gst_element_link_many (src, bs, sink, NULL);
gst_bin_add_many (GST_BIN (pipeline), src, bs, sink, NULL);
walk = params;
while (walk) {
gchar *desc;
TestParam *param = (TestParam *) (walk->data);
integrity_check = param->integrity_check;
g_print ("\n\nrunning test %d (%d iterations):\n", testnum + 1, iterations);
desc = create_desc (param);
g_print ("%s\n", desc);
g_free (desc);
g_object_set (G_OBJECT (src), "data", param->src_data,
"sizetype", param->src_sizetype,
"filltype", (integrity_check ? 5 : 0), "silent", !verbose, NULL);
g_object_set (G_OBJECT (bs), "accesspattern", param->bs_accesspattern,
"silent", !verbose, NULL);
g_object_set (G_OBJECT (sink), "dump", dump, "silent", !verbose, NULL);
run_test (GST_BIN (pipeline), iterations);
testnum++;
walk = g_slist_next (walk);
}
g_print ("\n\ndone\n");
return 0;
}