gst/debugutils/rndbuffersize.c

   1 /* GStreamer
   2  * Copyright (C) 2007 Nokia Corporation (contact <stefan.kost@nokia.com>)
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 /**
  20  * SECTION:element-rndbuffersize
  21  *
  22  * This element pulls buffers with random sizes from the source.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include <gst/gst.h>
  30 #include <gst/base/gstadapter.h>
  31
  32 GST_DEBUG_CATEGORY_STATIC (gst_rnd_buffer_size_debug);
  33 #define GST_CAT_DEFAULT gst_rnd_buffer_size_debug
  34
  35 #define GST_TYPE_RND_BUFFER_SIZE            (gst_rnd_buffer_size_get_type())
  36 #define GST_RND_BUFFER_SIZE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RND_BUFFER_SIZE,GstRndBufferSize))
  37 #define GST_RND_BUFFER_SIZE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RND_BUFFER_SIZE,GstRndBufferSizeClass))
  38 #define GST_IS_RND_BUFFER_SIZE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RND_BUFFER_SIZE))
  39 #define GST_IS_RND_BUFFER_SIZE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RND_BUFFER_SIZE))
  40
  41 typedef struct _GstRndBufferSize GstRndBufferSize;
  42 typedef struct _GstRndBufferSizeClass GstRndBufferSizeClass;
  43
  44 struct _GstRndBufferSize
  45 {
  46   GstElement parent;
  47
  48   /*< private > */
  49   GRand *rand;
  50   guint seed;
  51   gint min, max;
  52
  53   GstPad *sinkpad, *srcpad;
  54   guint64 offset;
  55
  56   gboolean need_newsegment;
  57
  58   GstAdapter *adapter;
  59 };
  60
  61 struct _GstRndBufferSizeClass
  62 {
  63   GstElementClass parent_class;
  64 };
  65
  66 enum
  67 {
  68   ARG_SEED = 1,
  69   ARG_MINIMUM,
  70   ARG_MAXIMUM
  71 };
  72
  73 #define DEFAULT_SEED 0
  74 #define DEFAULT_MIN  1
  75 #define DEFAULT_MAX  (8*1024)
  76
  77 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  78     GST_PAD_SRC,
  79     GST_PAD_ALWAYS,
  80     GST_STATIC_CAPS_ANY);
  81
  82 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  83     GST_PAD_SINK,
  84     GST_PAD_ALWAYS,
  85     GST_STATIC_CAPS_ANY);
  86
  87 static void gst_rnd_buffer_size_finalize (GObject * object);
  88 static void gst_rnd_buffer_size_set_property (GObject * object, guint prop_id,
  89     const GValue * value, GParamSpec * pspec);
  90 static void gst_rnd_buffer_size_get_property (GObject * object, guint prop_id,
  91     GValue * value, GParamSpec * pspec);
  92
  93 static gboolean gst_rnd_buffer_size_activate (GstPad * pad, GstObject * parent);
  94 static gboolean gst_rnd_buffer_size_activate_mode (GstPad * pad,
  95     GstObject * parent, GstPadMode mode, gboolean active);
  96 static void gst_rnd_buffer_size_loop (GstRndBufferSize * self);
  97 static GstStateChangeReturn gst_rnd_buffer_size_change_state (GstElement *
  98     element, GstStateChange transition);
  99 static gboolean gst_rnd_buffer_size_src_event (GstPad * pad,
 100     GstObject * parent, GstEvent * event);
 101 static gboolean gst_rnd_buffer_size_sink_event (GstPad * pad,
 102     GstObject * parent, GstEvent * event);
 103 static GstFlowReturn gst_rnd_buffer_size_chain (GstPad * pad,
 104     GstObject * parent, GstBuffer * buffer);
 105
 106 GType gst_rnd_buffer_size_get_type (void);
 107 #define gst_rnd_buffer_size_parent_class parent_class
 108 G_DEFINE_TYPE (GstRndBufferSize, gst_rnd_buffer_size, GST_TYPE_ELEMENT);
 109
 110 static void
 111 gst_rnd_buffer_size_class_init (GstRndBufferSizeClass * klass)
 112 {
 113   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 114   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 115
 116   GST_DEBUG_CATEGORY_INIT (gst_rnd_buffer_size_debug, "rndbuffersize", 0,
 117       "rndbuffersize element");
 118
 119   gobject_class->set_property = gst_rnd_buffer_size_set_property;
 120   gobject_class->get_property = gst_rnd_buffer_size_get_property;
 121   gobject_class->finalize = gst_rnd_buffer_size_finalize;
 122
 123   gst_element_class_add_pad_template (gstelement_class,
 124       gst_static_pad_template_get (&sink_template));
 125   gst_element_class_add_pad_template (gstelement_class,
 126       gst_static_pad_template_get (&src_template));
 127
 128   gst_element_class_set_static_metadata (gstelement_class, "Random buffer size",
 129       "Testing", "pull random sized buffers",
 130       "Stefan Kost <stefan.kost@nokia.com>");
 131
 132   gstelement_class->change_state =
 133       GST_DEBUG_FUNCPTR (gst_rnd_buffer_size_change_state);
 134
 135   g_object_class_install_property (gobject_class, ARG_SEED,
 136       g_param_spec_uint ("seed", "random number seed",
 137           "seed for randomness (initialized when going from READY to PAUSED)",
 138           0, G_MAXUINT32, DEFAULT_SEED,
 139           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 140   g_object_class_install_property (gobject_class, ARG_MINIMUM,
 141       g_param_spec_int ("min", "mininum", "mininum buffer size",
 142           0, G_MAXINT32, DEFAULT_MIN,
 143           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 144   g_object_class_install_property (gobject_class, ARG_MAXIMUM,
 145       g_param_spec_int ("max", "maximum", "maximum buffer size",
 146           1, G_MAXINT32, DEFAULT_MAX,
 147           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 148 }
 149
 150 static void
 151 gst_rnd_buffer_size_init (GstRndBufferSize * self)
 152 {
 153   self->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink");
 154   gst_pad_set_activate_function (self->sinkpad,
 155       GST_DEBUG_FUNCPTR (gst_rnd_buffer_size_activate));
 156   gst_pad_set_activatemode_function (self->sinkpad,
 157       GST_DEBUG_FUNCPTR (gst_rnd_buffer_size_activate_mode));
 158   gst_pad_set_event_function (self->sinkpad,
 159       GST_DEBUG_FUNCPTR (gst_rnd_buffer_size_sink_event));
 160   gst_pad_set_chain_function (self->sinkpad,
 161       GST_DEBUG_FUNCPTR (gst_rnd_buffer_size_chain));
 162   gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
 163
 164   self->srcpad = gst_pad_new_from_static_template (&src_template, "src");
 165   gst_pad_set_event_function (self->srcpad,
 166       GST_DEBUG_FUNCPTR (gst_rnd_buffer_size_src_event));
 167   gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
 168 }
 169
 170
 171 static void
 172 gst_rnd_buffer_size_finalize (GObject * object)
 173 {
 174   GstRndBufferSize *self = GST_RND_BUFFER_SIZE (object);
 175
 176   if (self->rand) {
 177     g_rand_free (self->rand);
 178     self->rand = NULL;
 179   }
 180
 181   G_OBJECT_CLASS (parent_class)->finalize (object);
 182 }
 183
 184
 185 static void
 186 gst_rnd_buffer_size_set_property (GObject * object, guint prop_id,
 187     const GValue * value, GParamSpec * pspec)
 188 {
 189   GstRndBufferSize *self = GST_RND_BUFFER_SIZE (object);
 190
 191   switch (prop_id) {
 192     case ARG_SEED:
 193       self->seed = g_value_get_uint (value);
 194       break;
 195     case ARG_MINIMUM:
 196       self->min = g_value_get_int (value);
 197       break;
 198     case ARG_MAXIMUM:
 199       self->max = g_value_get_int (value);
 200       break;
 201     default:
 202       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 203       break;
 204   }
 205 }
 206
 207
 208 static void
 209 gst_rnd_buffer_size_get_property (GObject * object, guint prop_id,
 210     GValue * value, GParamSpec * pspec)
 211 {
 212   GstRndBufferSize *self = GST_RND_BUFFER_SIZE (object);
 213
 214   switch (prop_id) {
 215     case ARG_SEED:
 216       g_value_set_uint (value, self->seed);
 217       break;
 218     case ARG_MINIMUM:
 219       g_value_set_int (value, self->min);
 220       break;
 221     case ARG_MAXIMUM:
 222       g_value_set_int (value, self->max);
 223       break;
 224     default:
 225       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 226       break;
 227   }
 228 }
 229
 230
 231 static gboolean
 232 gst_rnd_buffer_size_activate (GstPad * pad, GstObject * parent)
 233 {
 234   GstQuery *query;
 235   gboolean pull_mode;
 236
 237   query = gst_query_new_scheduling ();
 238
 239   if (gst_pad_peer_query (pad, query))
 240     pull_mode = gst_query_has_scheduling_mode (query, GST_PAD_MODE_PULL);
 241   else
 242     pull_mode = FALSE;
 243
 244   gst_query_unref (query);
 245
 246   if (pull_mode) {
 247     GST_DEBUG_OBJECT (pad, "activating pull");
 248     return gst_pad_activate_mode (pad, GST_PAD_MODE_PULL, TRUE);
 249   } else {
 250     GST_DEBUG_OBJECT (pad, "activating push");
 251     return gst_pad_activate_mode (pad, GST_PAD_MODE_PUSH, TRUE);
 252   }
 253 }
 254
 255
 256 static gboolean
 257 gst_rnd_buffer_size_activate_mode (GstPad * pad, GstObject * parent,
 258     GstPadMode mode, gboolean active)
 259 {
 260   gboolean res;
 261   GstRndBufferSize *self = GST_RND_BUFFER_SIZE (parent);
 262
 263   switch (mode) {
 264     case GST_PAD_MODE_PULL:
 265       if (active) {
 266         GST_INFO_OBJECT (self, "starting pull");
 267         res =
 268             gst_pad_start_task (pad, (GstTaskFunction) gst_rnd_buffer_size_loop,
 269             self, NULL);
 270         self->need_newsegment = TRUE;
 271       } else {
 272         GST_INFO_OBJECT (self, "stopping pull");
 273         res = gst_pad_stop_task (pad);
 274       }
 275       break;
 276     case GST_PAD_MODE_PUSH:
 277       GST_INFO_OBJECT (self, "%sactivating in push mode", (active) ? "" : "de");
 278       res = TRUE;
 279       break;
 280     default:
 281       res = FALSE;
 282       break;
 283   }
 284   return res;
 285 }
 286
 287 static gboolean
 288 gst_rnd_buffer_size_src_event (GstPad * pad, GstObject * parent,
 289     GstEvent * event)
 290 {
 291   GstRndBufferSize *self;
 292   GstSeekType start_type;
 293   GstSeekFlags flags;
 294   GstFormat format;
 295   gint64 start;
 296
 297   if (GST_EVENT_TYPE (event) != GST_EVENT_SEEK) {
 298     GST_WARNING_OBJECT (pad, "dropping %s event", GST_EVENT_TYPE_NAME (event));
 299     return FALSE;
 300   }
 301
 302   self = GST_RND_BUFFER_SIZE (parent);
 303   gst_event_parse_seek (event, NULL, &format, &flags, &start_type, &start,
 304       NULL, NULL);
 305
 306   if (format != GST_FORMAT_BYTES) {
 307     GST_WARNING_OBJECT (pad, "only BYTE format supported");
 308     return FALSE;
 309   }
 310   if (start_type != GST_SEEK_TYPE_SET) {
 311     GST_WARNING_OBJECT (pad, "only SEEK_TYPE_SET supported");
 312     return FALSE;
 313   }
 314
 315   if ((flags & GST_SEEK_FLAG_FLUSH)) {
 316     gst_pad_push_event (self->srcpad, gst_event_new_flush_start ());
 317     gst_pad_push_event (self->sinkpad, gst_event_new_flush_start ());
 318   } else {
 319     gst_pad_pause_task (self->sinkpad);
 320   }
 321
 322   GST_PAD_STREAM_LOCK (self->sinkpad);
 323
 324   if ((flags & GST_SEEK_FLAG_FLUSH)) {
 325     gst_pad_push_event (self->srcpad, gst_event_new_flush_stop (TRUE));
 326     gst_pad_push_event (self->sinkpad, gst_event_new_flush_stop (TRUE));
 327   }
 328
 329   GST_INFO_OBJECT (pad, "seeking to offset %" G_GINT64_FORMAT, start);
 330
 331   self->offset = start;
 332   self->need_newsegment = TRUE;
 333
 334   gst_pad_start_task (self->sinkpad, (GstTaskFunction) gst_rnd_buffer_size_loop,
 335       self, NULL);
 336
 337   GST_PAD_STREAM_UNLOCK (self->sinkpad);
 338   return TRUE;
 339 }
 340
 341 static GstFlowReturn
 342 gst_rnd_buffer_size_drain_adapter (GstRndBufferSize * self, gboolean eos)
 343 {
 344   GstFlowReturn flow;
 345   GstBuffer *buf;
 346   guint num_bytes, avail;
 347
 348   flow = GST_FLOW_OK;
 349
 350   if (G_UNLIKELY (self->min > self->max))
 351     goto bogus_minmax;
 352
 353   do {
 354     if (self->min != self->max) {
 355       num_bytes = g_rand_int_range (self->rand, self->min, self->max);
 356     } else {
 357       num_bytes = self->min;
 358     }
 359
 360     GST_LOG_OBJECT (self, "pulling %u bytes out of adapter", num_bytes);
 361
 362     buf = gst_adapter_take_buffer (self->adapter, num_bytes);
 363
 364     if (buf == NULL) {
 365       if (!eos) {
 366         GST_LOG_OBJECT (self, "not enough bytes in adapter");
 367         break;
 368       }
 369
 370       avail = gst_adapter_available (self->adapter);
 371
 372       if (avail == 0)
 373         break;
 374
 375       if (avail < self->min) {
 376         GST_WARNING_OBJECT (self, "discarding %u bytes at end (min=%u)",
 377             avail, self->min);
 378         gst_adapter_clear (self->adapter);
 379         break;
 380       }
 381       buf = gst_adapter_take_buffer (self->adapter, avail);
 382       g_assert (buf != NULL);
 383     }
 384
 385     flow = gst_pad_push (self->srcpad, buf);
 386   }
 387   while (flow == GST_FLOW_OK);
 388
 389   return flow;
 390
 391 /* ERRORS */
 392 bogus_minmax:
 393   {
 394     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS,
 395         ("The minimum buffer size is smaller than the maximum buffer size."),
 396         ("buffer sizes: max=%d, min=%d", self->min, self->max));
 397     return GST_FLOW_ERROR;
 398   }
 399 }
 400
 401 static gboolean
 402 gst_rnd_buffer_size_sink_event (GstPad * pad, GstObject * parent,
 403     GstEvent * event)
 404 {
 405   GstRndBufferSize *rnd = GST_RND_BUFFER_SIZE (parent);
 406
 407   switch (GST_EVENT_TYPE (event)) {
 408     case GST_EVENT_EOS:
 409       gst_rnd_buffer_size_drain_adapter (rnd, TRUE);
 410       break;
 411     case GST_EVENT_FLUSH_STOP:
 412       if (rnd->adapter != NULL)
 413         gst_adapter_clear (rnd->adapter);
 414       break;
 415     default:
 416       break;
 417   }
 418
 419   return gst_pad_push_event (rnd->srcpad, event);
 420 }
 421
 422 static GstFlowReturn
 423 gst_rnd_buffer_size_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
 424 {
 425   GstRndBufferSize *rnd = GST_RND_BUFFER_SIZE (parent);
 426   GstFlowReturn flow;
 427
 428   if (rnd->adapter == NULL)
 429     rnd->adapter = gst_adapter_new ();
 430
 431   gst_adapter_push (rnd->adapter, buf);
 432
 433   flow = gst_rnd_buffer_size_drain_adapter (rnd, FALSE);
 434
 435   if (flow != GST_FLOW_OK)
 436     GST_INFO_OBJECT (rnd, "flow: %s", gst_flow_get_name (flow));
 437
 438   return flow;
 439 }
 440
 441 static void
 442 gst_rnd_buffer_size_loop (GstRndBufferSize * self)
 443 {
 444   GstBuffer *buf = NULL;
 445   GstFlowReturn ret;
 446   guint num_bytes, size;
 447
 448   if (G_UNLIKELY (self->min > self->max))
 449     goto bogus_minmax;
 450
 451   if (G_UNLIKELY (self->min != self->max)) {
 452     num_bytes = g_rand_int_range (self->rand, self->min, self->max);
 453   } else {
 454     num_bytes = self->min;
 455   }
 456
 457   GST_LOG_OBJECT (self, "pulling %u bytes at offset %" G_GUINT64_FORMAT,
 458       num_bytes, self->offset);
 459
 460   ret = gst_pad_pull_range (self->sinkpad, self->offset, num_bytes, &buf);
 461
 462   if (ret != GST_FLOW_OK)
 463     goto pull_failed;
 464
 465   size = gst_buffer_get_size (buf);
 466
 467   if (size < num_bytes) {
 468     GST_WARNING_OBJECT (self, "short buffer: %u bytes", size);
 469   }
 470
 471   if (self->need_newsegment) {
 472     GstSegment segment;
 473
 474     gst_segment_init (&segment, GST_FORMAT_BYTES);
 475     segment.start = self->offset;
 476     gst_pad_push_event (self->srcpad, gst_event_new_segment (&segment));
 477     self->need_newsegment = FALSE;
 478   }
 479
 480   self->offset += size;
 481
 482   ret = gst_pad_push (self->srcpad, buf);
 483
 484   if (ret != GST_FLOW_OK)
 485     goto push_failed;
 486
 487   return;
 488
 489 pause_task:
 490   {
 491     GST_DEBUG_OBJECT (self, "pausing task");
 492     gst_pad_pause_task (self->sinkpad);
 493     return;
 494   }
 495
 496 pull_failed:
 497   {
 498     if (ret == GST_FLOW_EOS) {
 499       GST_DEBUG_OBJECT (self, "eos");
 500       gst_pad_push_event (self->srcpad, gst_event_new_eos ());
 501     } else {
 502       GST_WARNING_OBJECT (self, "pull_range flow: %s", gst_flow_get_name (ret));
 503     }
 504     goto pause_task;
 505   }
 506
 507 push_failed:
 508   {
 509     GST_DEBUG_OBJECT (self, "push flow: %s", gst_flow_get_name (ret));
 510     if (ret == GST_FLOW_EOS) {
 511       GST_DEBUG_OBJECT (self, "eos");
 512       gst_pad_push_event (self->srcpad, gst_event_new_eos ());
 513     } else if (ret < GST_FLOW_EOS || ret == GST_FLOW_NOT_LINKED) {
 514       GST_ELEMENT_ERROR (self, STREAM, FAILED,
 515           ("Internal data stream error."),
 516           ("streaming stopped, reason: %s", gst_flow_get_name (ret)));
 517     }
 518     goto pause_task;
 519   }
 520
 521 bogus_minmax:
 522   {
 523     GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS,
 524         ("The minimum buffer size is smaller than the maximum buffer size."),
 525         ("buffer sizes: max=%d, min=%d", self->min, self->max));
 526     goto pause_task;
 527   }
 528 }
 529
 530 static GstStateChangeReturn
 531 gst_rnd_buffer_size_change_state (GstElement * element,
 532     GstStateChange transition)
 533 {
 534   GstRndBufferSize *self = GST_RND_BUFFER_SIZE (element);
 535   GstStateChangeReturn ret;
 536
 537   switch (transition) {
 538     case GST_STATE_CHANGE_NULL_TO_READY:
 539       break;
 540     case GST_STATE_CHANGE_READY_TO_PAUSED:
 541       self->offset = 0;
 542       if (!self->rand) {
 543         self->rand = g_rand_new_with_seed (self->seed);
 544       }
 545       break;
 546     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 547       break;
 548     default:
 549       break;
 550   }
 551
 552   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 553
 554   switch (transition) {
 555     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 556       break;
 557     case GST_STATE_CHANGE_PAUSED_TO_READY:
 558       if (self->rand) {
 559         g_rand_free (self->rand);
 560         self->rand = NULL;
 561       }
 562       break;
 563     case GST_STATE_CHANGE_READY_TO_NULL:
 564       if (self->adapter) {
 565         g_object_unref (self->adapter);
 566         self->adapter = NULL;
 567       }
 568       break;
 569     default:
 570       break;
 571   }
 572
 573   return ret;
 574 }