testplugin.c 8.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/* GStreamer
 * Copyright (C) 2004 Benjamin Otte <otte@gnome.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <gst/gst.h>
25
#include <gst/base/gstbasesink.h>
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
#include "tests.h"

GST_DEBUG_CATEGORY_STATIC (gst_test_debug);
#define GST_CAT_DEFAULT gst_test_debug

/* This plugin does all the tests registered in the tests.h file
 */

#define GST_TYPE_TEST \
  (gst_test_get_type())
#define GST_TEST(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_TEST,GstTest))
#define GST_TEST_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_TEST,GstTestClass))
#define GST_TEST_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj),GST_TYPE_TEST,GstTestClass))
#define GST_IS_TEST(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_TEST))
Stefan Kost's avatar
Stefan Kost committed
44
#define GST_IS_TEST_CLASS(klass) \
45 46 47 48 49 50 51
  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_TEST))

typedef struct _GstTest GstTest;
typedef struct _GstTestClass GstTestClass;

struct _GstTest
{
52
  GstBaseSink basesink;
53 54 55 56 57 58 59

  gpointer tests[TESTS_COUNT];
  GValue values[TESTS_COUNT];
};

struct _GstTestClass
{
60
  GstBaseSinkClass parent_class;
61 62 63 64

  gchar *param_names[2 * TESTS_COUNT];
};

65 66
static void gst_test_finalize (GstTest * test);

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
static gboolean gst_test_start (GstBaseSink * trans);
static gboolean gst_test_stop (GstBaseSink * trans);
static gboolean gst_test_sink_event (GstBaseSink * basesink, GstEvent * event);
static GstFlowReturn gst_test_render_buffer (GstBaseSink * basesink,
    GstBuffer * buf);

static void gst_test_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec);
static void gst_test_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec);

static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS_ANY);

83

84
static const GstElementDetails details = GST_ELEMENT_DETAILS ("Test plugin",
85 86 87
    "Testing",
    "perform a number of tests",
    "Benjamin Otte <otte@gnome>");
88

89
GST_BOILERPLATE (GstTest, gst_test, GstBaseSink, GST_TYPE_BASE_SINK);
90

91 92
static void
gst_test_base_init (gpointer g_class)
93 94 95
{
  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);

96 97 98
  gst_element_class_add_pad_template (gstelement_class,
      gst_static_pad_template_get (&sinktemplate));

99 100 101 102 103 104
  gst_element_class_set_details (gstelement_class, &details);
}

static void
gst_test_class_init (GstTestClass * klass)
{
105 106
  GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
107 108
  guint i;

109 110
  object_class->set_property = GST_DEBUG_FUNCPTR (gst_test_set_property);
  object_class->get_property = GST_DEBUG_FUNCPTR (gst_test_get_property);
111

112 113
  object_class->finalize = (GObjectFinalizeFunc) gst_test_finalize;

114 115 116 117 118
  for (i = 0; i < TESTS_COUNT; i++) {
    GParamSpec *spec;

    spec = tests[i].get_spec (&tests[i], FALSE);
    klass->param_names[2 * i] = g_strdup (g_param_spec_get_name (spec));
119
    g_object_class_install_property (object_class, 2 * i + 1, spec);
120 121
    spec = tests[i].get_spec (&tests[i], TRUE);
    klass->param_names[2 * i + 1] = g_strdup (g_param_spec_get_name (spec));
122
    g_object_class_install_property (object_class, 2 * i + 2, spec);
123
  }
124 125 126 127 128 129

  basesink_class->preroll = GST_DEBUG_FUNCPTR (gst_test_render_buffer);
  basesink_class->render = GST_DEBUG_FUNCPTR (gst_test_render_buffer);
  basesink_class->event = GST_DEBUG_FUNCPTR (gst_test_sink_event);
  basesink_class->start = GST_DEBUG_FUNCPTR (gst_test_start);
  basesink_class->stop = GST_DEBUG_FUNCPTR (gst_test_stop);
130 131 132
}

static void
133
gst_test_init (GstTest * test, GstTestClass * g_class)
134 135 136 137 138 139 140 141 142 143 144 145 146
{
  GstTestClass *klass;
  guint i;

  klass = GST_TEST_GET_CLASS (test);
  for (i = 0; i < TESTS_COUNT; i++) {
    GParamSpec *spec = g_object_class_find_property (G_OBJECT_CLASS (klass),
        klass->param_names[2 * i + 1]);

    g_value_init (&test->values[i], G_PARAM_SPEC_VALUE_TYPE (spec));
  }
}

147 148 149 150 151 152 153 154 155 156 157 158
static void
gst_test_finalize (GstTest * test)
{
  guint i;

  for (i = 0; i < TESTS_COUNT; i++) {
    g_value_unset (&test->values[i]);
  }

  G_OBJECT_CLASS (parent_class)->finalize ((GObject *) test);
}

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
static void
tests_unset (GstTest * test)
{
  guint i;

  for (i = 0; i < TESTS_COUNT; i++) {
    if (test->tests[i]) {
      tests[i].free (test->tests[i]);
      test->tests[i] = NULL;
    }
  }
}

static void
tests_set (GstTest * test)
{
  guint i;

  for (i = 0; i < TESTS_COUNT; i++) {
    g_assert (test->tests[i] == NULL);
    test->tests[i] = tests[i].new (&tests[i]);
  }
}

183 184
static gboolean
gst_test_sink_event (GstBaseSink * basesink, GstEvent * event)
185
{
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
  GstTestClass *klass = GST_TEST_GET_CLASS (basesink);
  GstTest *test = GST_TEST (basesink);
  gboolean ret = FALSE;

  switch (GST_EVENT_TYPE (event)) {
/*
    case GST_EVENT_NEWSEGMENT:
      if (GST_EVENT_DISCONT_NEW_MEDIA (event)) {
        tests_unset (test);
        tests_set (test);
      }
      break;
*/
    case GST_EVENT_EOS:{
      gint i;

      g_object_freeze_notify (G_OBJECT (test));
      for (i = 0; i < TESTS_COUNT; i++) {
        if (test->tests[i]) {
          if (!tests[i].finish (test->tests[i], &test->values[i])) {
            GValue v = { 0, };
            gchar *real, *expected;

            expected = gst_value_serialize (&test->values[i]);
            g_value_init (&v, G_VALUE_TYPE (&test->values[i]));
            g_object_get_property (G_OBJECT (test), klass->param_names[2 * i],
                &v);
            real = gst_value_serialize (&v);
            g_value_unset (&v);
            GST_ELEMENT_ERROR (test, STREAM, FORMAT, (NULL),
                ("test %s returned value \"%s\" and not expected value \"%s\"",
                    klass->param_names[2 * i], real, expected));
            g_free (real);
            g_free (expected);
220
          }
221
          g_object_notify (G_OBJECT (test), klass->param_names[2 * i]);
222
        }
223 224 225 226
      }
      g_object_thaw_notify (G_OBJECT (test));
      ret = TRUE;
      break;
227
    }
228 229
    default:
      break;
230 231
  }

232 233 234 235 236 237 238 239 240
  return ret;
}

static GstFlowReturn
gst_test_render_buffer (GstBaseSink * basesink, GstBuffer * buf)
{
  GstTest *test = GST_TEST (basesink);
  guint i;

241 242
  for (i = 0; i < TESTS_COUNT; i++) {
    if (test->tests[i]) {
243
      tests[i].add (test->tests[i], buf);
244 245
    }
  }
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
  return GST_FLOW_OK;
}

static gboolean
gst_test_start (GstBaseSink * sink)
{
  GstTest *test = GST_TEST (sink);

  tests_set (test);
  return TRUE;
}

static gboolean
gst_test_stop (GstBaseSink * sink)
{
  GstTest *test = GST_TEST (sink);

  tests_unset (test);
  return TRUE;
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
}

static void
gst_test_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstTest *test = GST_TEST (object);

  if (prop_id == 0 || prop_id > 2 * TESTS_COUNT) {
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    return;
  }

  if (prop_id % 2) {
    /* real values can't be set */
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  } else {
    /* expected values */
283
    GST_OBJECT_LOCK (test);
284
    g_value_copy (value, &test->values[prop_id / 2 - 1]);
285
    GST_OBJECT_UNLOCK (test);
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
  }
}

static void
gst_test_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
{
  GstTest *test = GST_TEST (object);
  guint id = (prop_id - 1) / 2;

  if (prop_id == 0 || prop_id > 2 * TESTS_COUNT) {
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    return;
  }

301
  GST_OBJECT_LOCK (test);
302

303 304 305 306 307 308 309
  if (prop_id % 2) {
    /* real values */
    tests[id].get_value (test->tests[id], value);
  } else {
    /* expected values */
    g_value_copy (&test->values[id], value);
  }
310

311
  GST_OBJECT_UNLOCK (test);
312 313 314
}

gboolean
315
gst_test_plugin_init (GstPlugin * plugin, GstPluginClass * g_class)
316 317 318 319 320 321 322 323 324
{
  if (!gst_element_register (plugin, "testsink", GST_RANK_NONE, GST_TYPE_TEST))
    return FALSE;

  GST_DEBUG_CATEGORY_INIT (gst_test_debug, "testsink", 0,
      "debugging category for testsink element");

  return TRUE;
}