libs/gst/base/gstbasesrc.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *               2000,2005 Wim Taymans <wim@fluendo.com>
   4  *
   5  * gstbasesrc.c:
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include "config.h"
  29 #endif
  30
  31 #include "gstbasesrc.h"
  32 #include "gsttypefindhelper.h"
  33 #include <gst/gstmarshal.h>
  34
  35 #define DEFAULT_BLOCKSIZE       4096
  36
  37 GST_DEBUG_CATEGORY_STATIC (gst_basesrc_debug);
  38 #define GST_CAT_DEFAULT gst_basesrc_debug
  39
  40 /* BaseSrc signals and args */
  41 enum
  42 {
  43   /* FILL ME */
  44   LAST_SIGNAL
  45 };
  46
  47 enum
  48 {
  49   PROP_0,
  50   PROP_BLOCKSIZE,
  51   PROP_HAS_LOOP,
  52   PROP_HAS_GETRANGE
  53 };
  54
  55 static GstElementClass *parent_class = NULL;
  56
  57 static void gst_basesrc_base_init (gpointer g_class);
  58 static void gst_basesrc_class_init (GstBaseSrcClass * klass);
  59 static void gst_basesrc_init (GstBaseSrc * src, gpointer g_class);
  60
  61 GType
  62 gst_basesrc_get_type (void)
  63 {
  64   static GType basesrc_type = 0;
  65
  66   if (!basesrc_type) {
  67     static const GTypeInfo basesrc_info = {
  68       sizeof (GstBaseSrcClass),
  69       (GBaseInitFunc) gst_basesrc_base_init,
  70       NULL,
  71       (GClassInitFunc) gst_basesrc_class_init,
  72       NULL,
  73       NULL,
  74       sizeof (GstBaseSrc),
  75       0,
  76       (GInstanceInitFunc) gst_basesrc_init,
  77     };
  78
  79     basesrc_type = g_type_register_static (GST_TYPE_ELEMENT,
  80         "GstBaseSrc", &basesrc_info, G_TYPE_FLAG_ABSTRACT);
  81   }
  82   return basesrc_type;
  83 }
  84
  85 static gboolean gst_basesrc_activate (GstPad * pad, GstActivateMode mode);
  86 static void gst_basesrc_set_property (GObject * object, guint prop_id,
  87     const GValue * value, GParamSpec * pspec);
  88 static void gst_basesrc_get_property (GObject * object, guint prop_id,
  89     GValue * value, GParamSpec * pspec);
  90 static gboolean gst_basesrc_event_handler (GstPad * pad, GstEvent * event);
  91
  92 static gboolean gst_basesrc_query (GstPad * pad, GstQuery * query);
  93
  94 #if 0
  95 static const GstEventMask *gst_basesrc_get_event_mask (GstPad * pad);
  96 #endif
  97
  98 static gboolean gst_basesrc_unlock (GstBaseSrc * basesrc);
  99 static gboolean gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size);
 100 static gboolean gst_basesrc_start (GstBaseSrc * basesrc);
 101 static gboolean gst_basesrc_stop (GstBaseSrc * basesrc);
 102
 103 static GstElementStateReturn gst_basesrc_change_state (GstElement * element);
 104
 105 static void gst_basesrc_set_dataflow_funcs (GstBaseSrc * this);
 106 static void gst_basesrc_loop (GstPad * pad);
 107 static gboolean gst_basesrc_check_get_range (GstPad * pad);
 108 static GstFlowReturn gst_basesrc_get_range (GstPad * pad, guint64 offset,
 109     guint length, GstBuffer ** buf);
 110
 111 static void
 112 gst_basesrc_base_init (gpointer g_class)
 113 {
 114   GST_DEBUG_CATEGORY_INIT (gst_basesrc_debug, "basesrc", 0, "basesrc element");
 115 }
 116
 117 static void
 118 gst_basesrc_class_init (GstBaseSrcClass * klass)
 119 {
 120   GObjectClass *gobject_class;
 121   GstElementClass *gstelement_class;
 122
 123   gobject_class = (GObjectClass *) klass;
 124   gstelement_class = (GstElementClass *) klass;
 125
 126   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 127
 128   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_basesrc_set_property);
 129   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_basesrc_get_property);
 130
 131   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BLOCKSIZE,
 132       g_param_spec_ulong ("blocksize", "Block size",
 133           "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
 134           G_PARAM_READWRITE));
 135
 136   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HAS_LOOP,
 137       g_param_spec_boolean ("has-loop", "Has loop function",
 138           "True if the element should expose a loop function", TRUE,
 139           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 140
 141   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HAS_GETRANGE,
 142       g_param_spec_boolean ("has-getrange", "Has getrange function",
 143           "True if the element should expose a getrange function", TRUE,
 144           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 145
 146   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_basesrc_change_state);
 147 }
 148
 149 static void
 150 gst_basesrc_init (GstBaseSrc * basesrc, gpointer g_class)
 151 {
 152   GstPad *pad;
 153   GstPadTemplate *pad_template;
 154
 155   pad_template =
 156       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");
 157   g_return_if_fail (pad_template != NULL);
 158
 159   pad = gst_pad_new_from_template (pad_template, "src");
 160
 161   gst_pad_set_activate_function (pad, gst_basesrc_activate);
 162   gst_pad_set_event_function (pad, gst_basesrc_event_handler);
 163   gst_pad_set_query_function (pad, gst_basesrc_query);
 164
 165   gst_pad_set_checkgetrange_function (pad, gst_basesrc_check_get_range);
 166
 167   /* hold ref to pad */
 168   basesrc->srcpad = pad;
 169   gst_element_add_pad (GST_ELEMENT (basesrc), pad);
 170
 171   basesrc->segment_start = -1;
 172   basesrc->segment_end = -1;
 173   basesrc->blocksize = DEFAULT_BLOCKSIZE;
 174   basesrc->clock_id = NULL;
 175
 176   GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 177 }
 178
 179 static void
 180 gst_basesrc_set_dataflow_funcs (GstBaseSrc * this)
 181 {
 182   GST_DEBUG ("updating dataflow functions");
 183
 184   if (this->has_loop)
 185     gst_pad_set_loop_function (this->srcpad, gst_basesrc_loop);
 186   else
 187     gst_pad_set_loop_function (this->srcpad, NULL);
 188
 189   if (this->has_getrange)
 190     gst_pad_set_getrange_function (this->srcpad, gst_basesrc_get_range);
 191   else
 192     gst_pad_set_getrange_function (this->srcpad, NULL);
 193 }
 194
 195 static gboolean
 196 gst_basesrc_query (GstPad * pad, GstQuery * query)
 197 {
 198   gboolean b;
 199   guint64 ui64;
 200   gint64 i64;
 201   GstBaseSrc *src;
 202
 203   src = GST_BASESRC (GST_PAD_PARENT (pad));
 204
 205   switch (GST_QUERY_TYPE (query)) {
 206     case GST_QUERY_POSITION:
 207     {
 208       GstFormat format;
 209
 210       gst_query_parse_position (query, &format, NULL, NULL);
 211       switch (format) {
 212         case GST_FORMAT_DEFAULT:
 213         case GST_FORMAT_BYTES:
 214           b = gst_basesrc_get_size (src, &ui64);
 215           /* better to make get_size take an int64 */
 216           i64 = b ? (gint64) ui64 : -1;
 217           gst_query_set_position (query, GST_FORMAT_BYTES, src->offset, i64);
 218           return TRUE;
 219         case GST_FORMAT_PERCENT:
 220           b = gst_basesrc_get_size (src, &ui64);
 221           i64 = GST_FORMAT_PERCENT_MAX;
 222           i64 *= b ? (src->offset / (gdouble) ui64) : 1.0;
 223           gst_query_set_position (query, GST_FORMAT_PERCENT,
 224               i64, GST_FORMAT_PERCENT_MAX);
 225           return TRUE;
 226         default:
 227           return FALSE;
 228       }
 229     }
 230
 231     case GST_QUERY_SEEKING:
 232       gst_query_set_seeking (query, GST_FORMAT_BYTES,
 233           src->seekable, src->segment_start, src->segment_end);
 234       return TRUE;
 235
 236     case GST_QUERY_FORMATS:
 237       gst_query_set_formats (query, 3, GST_FORMAT_DEFAULT,
 238           GST_FORMAT_BYTES, GST_FORMAT_PERCENT);
 239       return TRUE;
 240
 241     case GST_QUERY_LATENCY:
 242     case GST_QUERY_JITTER:
 243     case GST_QUERY_RATE:
 244     case GST_QUERY_CONVERT:
 245     default:
 246       return gst_pad_query_default (pad, query);
 247   }
 248 }
 249
 250 #if 0
 251 static const GstEventMask *
 252 gst_basesrc_get_event_mask (GstPad * pad)
 253 {
 254   static const GstEventMask masks[] = {
 255     {GST_EVENT_SEEK, GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_SET |
 256           GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH |
 257           GST_SEEK_FLAG_SEGMENT_LOOP},
 258     {GST_EVENT_FLUSH, 0},
 259     {GST_EVENT_SIZE, 0},
 260     {0, 0},
 261   };
 262   return masks;
 263 }
 264 #endif
 265
 266 static gboolean
 267 gst_basesrc_do_seek (GstBaseSrc * src, GstEvent * event)
 268 {
 269   GstFormat format;
 270   gint64 offset;
 271
 272   format = GST_EVENT_SEEK_FORMAT (event);
 273
 274   /* get seek format */
 275   if (format == GST_FORMAT_DEFAULT)
 276     format = GST_FORMAT_BYTES;
 277   /* we can only seek bytes */
 278   if (format != GST_FORMAT_BYTES)
 279     return FALSE;
 280
 281   /* get seek positions */
 282   offset = GST_EVENT_SEEK_OFFSET (event);
 283   src->segment_start = offset;
 284   src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 285   src->segment_loop = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
 286
 287   /* send flush start */
 288   gst_pad_push_event (src->srcpad, gst_event_new_flush (FALSE));
 289
 290   /* unblock streaming thread */
 291   gst_basesrc_unlock (src);
 292
 293   /* grab streaming lock */
 294   GST_STREAM_LOCK (src->srcpad);
 295
 296   switch (GST_EVENT_SEEK_METHOD (event)) {
 297     case GST_SEEK_METHOD_SET:
 298       if (offset < 0)
 299         goto error;
 300       src->offset = MIN (offset, src->size);
 301       GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
 302           src->offset);
 303       break;
 304     case GST_SEEK_METHOD_CUR:
 305       offset += src->offset;
 306       src->offset = CLAMP (offset, 0, src->size);
 307       GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
 308           src->offset);
 309       break;
 310     case GST_SEEK_METHOD_END:
 311       if (offset > 0)
 312         goto error;
 313       offset = src->size + offset;
 314       src->offset = MAX (0, offset);
 315       GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
 316           src->offset);
 317       break;
 318     default:
 319       goto error;
 320   }
 321   /* send flush end */
 322   gst_pad_push_event (src->srcpad, gst_event_new_flush (TRUE));
 323
 324   /* now send discont */
 325   {
 326     GstEvent *event;
 327
 328     event = gst_event_new_discontinuous (1.0,
 329         GST_FORMAT_BYTES,
 330         (gint64) src->segment_start, (gint64) src->segment_end, NULL);
 331
 332     gst_pad_push_event (src->srcpad, event);
 333   }
 334
 335   /* and restart the task */
 336   if (GST_RPAD_TASK (src->srcpad)) {
 337     gst_task_start (GST_RPAD_TASK (src->srcpad));
 338   }
 339   GST_STREAM_UNLOCK (src->srcpad);
 340
 341   gst_event_unref (event);
 342
 343   return TRUE;
 344
 345   /* ERROR */
 346 error:
 347   {
 348     GST_DEBUG_OBJECT (src, "seek error");
 349     GST_STREAM_UNLOCK (src->srcpad);
 350     gst_event_unref (event);
 351     return FALSE;
 352   }
 353 }
 354
 355 static gboolean
 356 gst_basesrc_event_handler (GstPad * pad, GstEvent * event)
 357 {
 358   GstBaseSrc *src;
 359   GstBaseSrcClass *bclass;
 360   gboolean result;
 361
 362   src = GST_BASESRC (GST_PAD_PARENT (pad));
 363   bclass = GST_BASESRC_GET_CLASS (src);
 364
 365   if (bclass->event)
 366     result = bclass->event (src, event);
 367
 368   switch (GST_EVENT_TYPE (event)) {
 369     case GST_EVENT_SEEK:
 370       return gst_basesrc_do_seek (src, event);
 371     case GST_EVENT_SIZE:
 372     {
 373       GstFormat format;
 374
 375       format = GST_EVENT_SIZE_FORMAT (event);
 376       if (format == GST_FORMAT_DEFAULT)
 377         format = GST_FORMAT_BYTES;
 378       /* we can only accept bytes */
 379       if (format != GST_FORMAT_BYTES)
 380         return FALSE;
 381
 382       src->blocksize = GST_EVENT_SIZE_VALUE (event);
 383       g_object_notify (G_OBJECT (src), "blocksize");
 384       break;
 385     }
 386     case GST_EVENT_FLUSH:
 387       /* cancel any blocking getrange */
 388       if (!GST_EVENT_FLUSH_DONE (event))
 389         gst_basesrc_unlock (src);
 390       break;
 391     default:
 392       break;
 393   }
 394   gst_event_unref (event);
 395
 396   return TRUE;
 397 }
 398
 399 static void
 400 gst_basesrc_set_property (GObject * object, guint prop_id, const GValue * value,
 401     GParamSpec * pspec)
 402 {
 403   GstBaseSrc *src;
 404
 405   src = GST_BASESRC (object);
 406
 407   switch (prop_id) {
 408     case PROP_BLOCKSIZE:
 409       src->blocksize = g_value_get_ulong (value);
 410       break;
 411     case PROP_HAS_LOOP:
 412       src->has_loop = g_value_get_boolean (value);
 413       gst_basesrc_set_dataflow_funcs (src);
 414       break;
 415     case PROP_HAS_GETRANGE:
 416       src->has_getrange = g_value_get_boolean (value);
 417       gst_basesrc_set_dataflow_funcs (src);
 418       break;
 419     default:
 420       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 421       break;
 422   }
 423 }
 424
 425 static void
 426 gst_basesrc_get_property (GObject * object, guint prop_id, GValue * value,
 427     GParamSpec * pspec)
 428 {
 429   GstBaseSrc *src;
 430
 431   src = GST_BASESRC (object);
 432
 433   switch (prop_id) {
 434     case PROP_BLOCKSIZE:
 435       g_value_set_ulong (value, src->blocksize);
 436       break;
 437     case PROP_HAS_LOOP:
 438       g_value_set_boolean (value, src->has_loop);
 439       break;
 440     case PROP_HAS_GETRANGE:
 441       g_value_set_boolean (value, src->has_getrange);
 442       break;
 443     default:
 444       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 445       break;
 446   }
 447 }
 448
 449 static GstFlowReturn
 450 gst_basesrc_get_range_unlocked (GstPad * pad, guint64 offset, guint length,
 451     GstBuffer ** buf)
 452 {
 453   GstFlowReturn ret;
 454   GstBaseSrc *src;
 455   GstBaseSrcClass *bclass;
 456
 457   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 458   bclass = GST_BASESRC_GET_CLASS (src);
 459
 460   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED))
 461     goto not_started;
 462
 463   if (!bclass->create)
 464     goto no_function;
 465
 466   /* check size */
 467   if (src->size != -1) {
 468     if (offset + length > src->size) {
 469       if (bclass->get_size)
 470         bclass->get_size (src, &src->size);
 471
 472       if (offset + length > src->size) {
 473         length = src->size - offset;
 474       }
 475     }
 476   }
 477   if (length == 0)
 478     goto unexpected_length;
 479
 480   ret = bclass->create (src, offset, length, buf);
 481
 482   return ret;
 483
 484   /* ERROR */
 485 not_started:
 486   {
 487     GST_DEBUG_OBJECT (src, "getrange but not started");
 488     return GST_FLOW_WRONG_STATE;
 489   }
 490 no_function:
 491   {
 492     GST_DEBUG_OBJECT (src, "no create function");
 493     return GST_FLOW_ERROR;
 494   }
 495 unexpected_length:
 496   {
 497     GST_DEBUG_OBJECT (src, "unexpected length %u", length);
 498     return GST_FLOW_UNEXPECTED;
 499   }
 500 }
 501
 502 static GstFlowReturn
 503 gst_basesrc_get_range (GstPad * pad, guint64 offset, guint length,
 504     GstBuffer ** ret)
 505 {
 506   GstFlowReturn fret;
 507
 508   GST_STREAM_LOCK (pad);
 509
 510   fret = gst_basesrc_get_range_unlocked (pad, offset, length, ret);
 511
 512   GST_STREAM_UNLOCK (pad);
 513
 514   return fret;
 515 }
 516
 517 static gboolean
 518 gst_basesrc_check_get_range (GstPad * pad)
 519 {
 520   GstBaseSrc *src;
 521
 522   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 523
 524   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED)) {
 525     gst_basesrc_start (src);
 526     gst_basesrc_stop (src);
 527   }
 528
 529   return src->seekable;
 530 }
 531
 532 static void
 533 gst_basesrc_loop (GstPad * pad)
 534 {
 535   GstBaseSrc *src;
 536   GstBuffer *buf = NULL;
 537   GstFlowReturn ret;
 538
 539   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 540
 541   GST_STREAM_LOCK (pad);
 542
 543   ret = gst_basesrc_get_range_unlocked (pad, src->offset, src->blocksize, &buf);
 544   if (ret != GST_FLOW_OK)
 545     goto eos;
 546
 547   src->offset += GST_BUFFER_SIZE (buf);
 548
 549   ret = gst_pad_push (pad, buf);
 550   if (ret != GST_FLOW_OK)
 551     goto pause;
 552
 553   GST_STREAM_UNLOCK (pad);
 554   return;
 555
 556 eos:
 557   {
 558     GST_DEBUG_OBJECT (src, "going to EOS");
 559     gst_task_pause (GST_RPAD_TASK (pad));
 560     gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
 561     GST_STREAM_UNLOCK (pad);
 562     return;
 563   }
 564 pause:
 565   {
 566     GST_DEBUG_OBJECT (src, "pausing task");
 567     gst_task_pause (GST_RPAD_TASK (pad));
 568     GST_STREAM_UNLOCK (pad);
 569     return;
 570   }
 571 }
 572
 573 static gboolean
 574 gst_basesrc_unlock (GstBaseSrc * basesrc)
 575 {
 576   GstBaseSrcClass *bclass;
 577   gboolean result = FALSE;
 578
 579   GST_DEBUG ("unlock");
 580   /* unblock whatever the subclass is doing */
 581   bclass = GST_BASESRC_GET_CLASS (basesrc);
 582   if (bclass->unlock)
 583     result = bclass->unlock (basesrc);
 584
 585   GST_DEBUG ("unschedule clock");
 586   /* and unblock the clock as well, if any */
 587   GST_LOCK (basesrc);
 588   if (basesrc->clock_id) {
 589     gst_clock_id_unschedule (basesrc->clock_id);
 590   }
 591   GST_UNLOCK (basesrc);
 592
 593   GST_DEBUG ("unlock done");
 594
 595   return result;
 596 }
 597
 598 static gboolean
 599 gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size)
 600 {
 601   GstBaseSrcClass *bclass;
 602   gboolean result = FALSE;
 603
 604   bclass = GST_BASESRC_GET_CLASS (basesrc);
 605   if (bclass->get_size)
 606     result = bclass->get_size (basesrc, size);
 607
 608   if (result)
 609     basesrc->size = *size;
 610
 611   return result;
 612 }
 613
 614 static gboolean
 615 gst_basesrc_is_seekable (GstBaseSrc * basesrc)
 616 {
 617   GstBaseSrcClass *bclass;
 618
 619   bclass = GST_BASESRC_GET_CLASS (basesrc);
 620
 621   /* check if we can seek */
 622   if (bclass->is_seekable)
 623     basesrc->seekable = bclass->is_seekable (basesrc);
 624   else
 625     basesrc->seekable = FALSE;
 626
 627   return basesrc->seekable;
 628 }
 629
 630 static gboolean
 631 gst_basesrc_start (GstBaseSrc * basesrc)
 632 {
 633   GstBaseSrcClass *bclass;
 634   gboolean result;
 635
 636   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 637     return TRUE;
 638
 639   bclass = GST_BASESRC_GET_CLASS (basesrc);
 640   if (bclass->start)
 641     result = bclass->start (basesrc);
 642   else
 643     result = TRUE;
 644
 645   if (!result)
 646     goto could_not_start;
 647
 648   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 649
 650   /* start in the beginning */
 651   basesrc->offset = 0;
 652   basesrc->segment_start = 0;
 653
 654   /* figure out the size */
 655   if (bclass->get_size) {
 656     result = bclass->get_size (basesrc, &basesrc->size);
 657     if (result == FALSE)
 658       basesrc->size = -1;
 659   } else {
 660     result = FALSE;
 661     basesrc->size = -1;
 662   }
 663
 664   GST_DEBUG ("size %d %lld", result, basesrc->size);
 665
 666   /* we always run to the end */
 667   basesrc->segment_end = -1;
 668
 669   /* check if we can seek, updates ->seekable */
 670   gst_basesrc_is_seekable (basesrc);
 671
 672   /* run typefind */
 673 #if 0
 674   if (basesrc->seekable) {
 675     GstCaps *caps;
 676
 677     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 678     gst_pad_set_caps (basesrc->srcpad, caps);
 679   }
 680 #endif
 681
 682   return TRUE;
 683
 684   /* ERROR */
 685 could_not_start:
 686   {
 687     GST_DEBUG_OBJECT (basesrc, "could not start");
 688     return FALSE;
 689   }
 690 }
 691
 692 static gboolean
 693 gst_basesrc_stop (GstBaseSrc * basesrc)
 694 {
 695   GstBaseSrcClass *bclass;
 696   gboolean result = TRUE;
 697
 698   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 699     return TRUE;
 700
 701   bclass = GST_BASESRC_GET_CLASS (basesrc);
 702   if (bclass->stop)
 703     result = bclass->stop (basesrc);
 704
 705   if (result)
 706     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 707
 708   return result;
 709 }
 710
 711 static gboolean
 712 gst_basesrc_activate (GstPad * pad, GstActivateMode mode)
 713 {
 714   gboolean result;
 715   GstBaseSrc *basesrc;
 716
 717   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 718
 719   /* prepare subclass first */
 720   switch (mode) {
 721     case GST_ACTIVATE_PUSH:
 722     case GST_ACTIVATE_PULL:
 723       result = gst_basesrc_start (basesrc);
 724       break;
 725     default:
 726       result = TRUE;
 727       break;
 728   }
 729   /* if that failed we can stop here */
 730   if (!result)
 731     goto error_start;
 732
 733   result = FALSE;
 734   switch (mode) {
 735     case GST_ACTIVATE_PUSH:
 736       /* if we have a scheduler we can start the task */
 737       if (GST_ELEMENT_SCHEDULER (basesrc)) {
 738         GST_STREAM_LOCK (pad);
 739         GST_RPAD_TASK (pad) =
 740             gst_scheduler_create_task (GST_ELEMENT_SCHEDULER (basesrc),
 741             (GstTaskFunction) gst_basesrc_loop, pad);
 742
 743         gst_task_start (GST_RPAD_TASK (pad));
 744         GST_STREAM_UNLOCK (pad);
 745         result = TRUE;
 746       }
 747       break;
 748     case GST_ACTIVATE_PULL:
 749       result = TRUE;
 750       break;
 751     case GST_ACTIVATE_NONE:
 752       /* step 1, unblock clock sync (if any) */
 753       gst_basesrc_unlock (basesrc);
 754
 755       /* step 2, make sure streaming finishes */
 756       GST_STREAM_LOCK (pad);
 757       /* step 3, stop the task */
 758       if (GST_RPAD_TASK (pad)) {
 759         gst_task_stop (GST_RPAD_TASK (pad));
 760         gst_object_unref (GST_OBJECT (GST_RPAD_TASK (pad)));
 761         GST_RPAD_TASK (pad) = NULL;
 762       }
 763       GST_STREAM_UNLOCK (pad);
 764
 765       result = TRUE;
 766       break;
 767   }
 768   return result;
 769
 770   /* ERROR */
 771 error_start:
 772   {
 773     GST_DEBUG_OBJECT (basesrc, "failed to start");
 774     return FALSE;
 775   }
 776 }
 777
 778 static GstElementStateReturn
 779 gst_basesrc_change_state (GstElement * element)
 780 {
 781   GstBaseSrc *basesrc;
 782   GstElementStateReturn result = GST_STATE_FAILURE;
 783   GstElementState transition;
 784
 785   basesrc = GST_BASESRC (element);
 786
 787   transition = GST_STATE_TRANSITION (element);
 788
 789   switch (transition) {
 790     case GST_STATE_NULL_TO_READY:
 791       break;
 792     case GST_STATE_READY_TO_PAUSED:
 793       break;
 794     case GST_STATE_PAUSED_TO_PLAYING:
 795       break;
 796     default:
 797       break;
 798   }
 799
 800   result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
 801
 802   switch (transition) {
 803     case GST_STATE_PLAYING_TO_PAUSED:
 804       break;
 805     case GST_STATE_PAUSED_TO_READY:
 806       if (!gst_basesrc_stop (basesrc))
 807         result = GST_STATE_FAILURE;
 808       break;
 809     case GST_STATE_READY_TO_NULL:
 810       break;
 811     default:
 812       break;
 813   }
 814
 815   return result;
 816 }