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 static const GstEventMask *gst_basesrc_get_event_mask (GstPad * pad);
  92 static const GstQueryType *gst_basesrc_get_query_types (GstPad * pad);
  93 static gboolean gst_basesrc_query (GstPad * pad, GstQueryType type,
  94     GstFormat * format, gint64 * value);
  95 static const GstFormat *gst_basesrc_get_formats (GstPad * pad);
  96
  97 static gboolean gst_basesrc_unlock (GstBaseSrc * basesrc);
  98 static gboolean gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size);
  99 static gboolean gst_basesrc_start (GstBaseSrc * basesrc);
 100 static gboolean gst_basesrc_stop (GstBaseSrc * basesrc);
 101
 102 static GstElementStateReturn gst_basesrc_change_state (GstElement * element);
 103
 104 static void gst_basesrc_set_dataflow_funcs (GstBaseSrc * this);
 105 static void gst_basesrc_loop (GstPad * pad);
 106 static gboolean gst_basesrc_check_get_range (GstPad * pad);
 107 static GstFlowReturn gst_basesrc_get_range (GstPad * pad, guint64 offset,
 108     guint length, GstBuffer ** buf);
 109
 110 static void
 111 gst_basesrc_base_init (gpointer g_class)
 112 {
 113   GST_DEBUG_CATEGORY_INIT (gst_basesrc_debug, "basesrc", 0, "basesrc element");
 114 }
 115
 116 static void
 117 gst_basesrc_class_init (GstBaseSrcClass * klass)
 118 {
 119   GObjectClass *gobject_class;
 120   GstElementClass *gstelement_class;
 121
 122   gobject_class = (GObjectClass *) klass;
 123   gstelement_class = (GstElementClass *) klass;
 124
 125   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 126
 127   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_basesrc_set_property);
 128   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_basesrc_get_property);
 129
 130   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BLOCKSIZE,
 131       g_param_spec_ulong ("blocksize", "Block size",
 132           "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
 133           G_PARAM_READWRITE));
 134
 135   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HAS_LOOP,
 136       g_param_spec_boolean ("has-loop", "Has loop function",
 137           "True if the element should expose a loop function", TRUE,
 138           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 139
 140   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HAS_GETRANGE,
 141       g_param_spec_boolean ("has-getrange", "Has getrange function",
 142           "True if the element should expose a getrange function", TRUE,
 143           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 144
 145   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_basesrc_change_state);
 146 }
 147
 148 static void
 149 gst_basesrc_init (GstBaseSrc * basesrc, gpointer g_class)
 150 {
 151   GstPad *pad;
 152   GstPadTemplate *pad_template;
 153
 154   pad_template =
 155       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");
 156   g_return_if_fail (pad_template != NULL);
 157
 158   pad = gst_pad_new_from_template (pad_template, "src");
 159
 160   gst_pad_set_activate_function (pad, gst_basesrc_activate);
 161   gst_pad_set_event_function (pad, gst_basesrc_event_handler);
 162   gst_pad_set_event_mask_function (pad, gst_basesrc_get_event_mask);
 163   gst_pad_set_query_function (pad, gst_basesrc_query);
 164   gst_pad_set_query_type_function (pad, gst_basesrc_get_query_types);
 165   gst_pad_set_formats_function (pad, gst_basesrc_get_formats);
 166   gst_pad_set_checkgetrange_function (pad, gst_basesrc_check_get_range);
 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
 175   GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 176 }
 177
 178 static void
 179 gst_basesrc_set_dataflow_funcs (GstBaseSrc * this)
 180 {
 181   GST_DEBUG ("updating dataflow functions");
 182
 183   if (this->has_loop)
 184     gst_pad_set_loop_function (this->srcpad, gst_basesrc_loop);
 185   else
 186     gst_pad_set_loop_function (this->srcpad, NULL);
 187
 188   if (this->has_getrange)
 189     gst_pad_set_getrange_function (this->srcpad, gst_basesrc_get_range);
 190   else
 191     gst_pad_set_getrange_function (this->srcpad, NULL);
 192 }
 193
 194 static const GstFormat *
 195 gst_basesrc_get_formats (GstPad * pad)
 196 {
 197   static const GstFormat formats[] = {
 198     GST_FORMAT_DEFAULT,
 199     GST_FORMAT_BYTES,
 200     0,
 201   };
 202
 203   return formats;
 204 }
 205
 206 static const GstQueryType *
 207 gst_basesrc_get_query_types (GstPad * pad)
 208 {
 209   static const GstQueryType types[] = {
 210     GST_QUERY_TOTAL,
 211     GST_QUERY_POSITION,
 212     GST_QUERY_START,
 213     GST_QUERY_SEGMENT_END,
 214     0,
 215   };
 216
 217   return types;
 218 }
 219
 220 static gboolean
 221 gst_basesrc_query (GstPad * pad, GstQueryType type,
 222     GstFormat * format, gint64 * value)
 223 {
 224   GstBaseSrc *src = GST_BASESRC (GST_PAD_PARENT (pad));
 225
 226   if (*format == GST_FORMAT_DEFAULT)
 227     *format = GST_FORMAT_BYTES;
 228
 229   switch (type) {
 230     case GST_QUERY_TOTAL:
 231       switch (*format) {
 232         case GST_FORMAT_BYTES:
 233         {
 234           gboolean ret;
 235
 236           ret = gst_basesrc_get_size (src, (guint64 *) value);
 237           GST_DEBUG ("getting length %d %lld", ret, *value);
 238           return ret;
 239         }
 240         case GST_FORMAT_PERCENT:
 241           *value = GST_FORMAT_PERCENT_MAX;
 242           return TRUE;
 243         default:
 244           return FALSE;
 245       }
 246       break;
 247     case GST_QUERY_POSITION:
 248       switch (*format) {
 249         case GST_FORMAT_BYTES:
 250           *value = src->offset;
 251           break;
 252         case GST_FORMAT_PERCENT:
 253           /* fixme */
 254           if (!gst_basesrc_get_size (src, (guint64 *) value))
 255             return FALSE;
 256           *value = src->offset * GST_FORMAT_PERCENT_MAX / *value;
 257           return TRUE;
 258         default:
 259           return FALSE;
 260       }
 261       break;
 262     case GST_QUERY_START:
 263       *value = src->segment_start;
 264       return TRUE;
 265     case GST_QUERY_SEGMENT_END:
 266       *value = src->segment_end;
 267       return TRUE;
 268     default:
 269       return FALSE;
 270   }
 271   return FALSE;
 272 }
 273
 274 static const GstEventMask *
 275 gst_basesrc_get_event_mask (GstPad * pad)
 276 {
 277   static const GstEventMask masks[] = {
 278     {GST_EVENT_SEEK, GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_SET |
 279           GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH |
 280           GST_SEEK_FLAG_SEGMENT_LOOP},
 281     {GST_EVENT_FLUSH, 0},
 282     {GST_EVENT_SIZE, 0},
 283     {0, 0},
 284   };
 285   return masks;
 286 }
 287
 288 static gboolean
 289 gst_basesrc_do_seek (GstBaseSrc * src, GstEvent * event)
 290 {
 291   GstFormat format;
 292   gint64 offset;
 293
 294   format = GST_EVENT_SEEK_FORMAT (event);
 295
 296   /* get seek format */
 297   if (format == GST_FORMAT_DEFAULT)
 298     format = GST_FORMAT_BYTES;
 299   /* we can only seek bytes */
 300   if (format != GST_FORMAT_BYTES)
 301     return FALSE;
 302
 303   /* get seek positions */
 304   offset = GST_EVENT_SEEK_OFFSET (event);
 305   src->segment_start = offset;
 306   src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 307   src->segment_loop = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
 308
 309   /* send flush start */
 310   gst_pad_push_event (src->srcpad, gst_event_new_flush (FALSE));
 311
 312   /* unblock streaming thread */
 313   gst_basesrc_unlock (src);
 314
 315   /* grab streaming lock */
 316   GST_STREAM_LOCK (src->srcpad);
 317
 318   switch (GST_EVENT_SEEK_METHOD (event)) {
 319     case GST_SEEK_METHOD_SET:
 320       if (offset < 0)
 321         goto error;
 322       src->offset = MIN (offset, src->size);
 323       GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
 324           src->offset);
 325       break;
 326     case GST_SEEK_METHOD_CUR:
 327       offset += src->offset;
 328       src->offset = CLAMP (offset, 0, src->size);
 329       GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
 330           src->offset);
 331       break;
 332     case GST_SEEK_METHOD_END:
 333       if (offset > 0)
 334         goto error;
 335       offset = src->size + offset;
 336       src->offset = MAX (0, offset);
 337       GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
 338           src->offset);
 339       break;
 340     default:
 341       goto error;
 342   }
 343   /* send flush end */
 344   gst_pad_push_event (src->srcpad, gst_event_new_flush (TRUE));
 345
 346   /* now send discont */
 347   {
 348     GstEvent *event;
 349
 350     event = gst_event_new_discontinuous (1.0,
 351         GST_FORMAT_TIME,
 352         (gint64) src->segment_start, (gint64) src->segment_end, NULL);
 353
 354     gst_pad_push_event (src->srcpad, event);
 355   }
 356
 357   /* and restart the task */
 358   if (GST_RPAD_TASK (src->srcpad)) {
 359     gst_task_start (GST_RPAD_TASK (src->srcpad));
 360   }
 361   GST_STREAM_UNLOCK (src->srcpad);
 362
 363   gst_event_unref (event);
 364
 365   return TRUE;
 366
 367   /* ERROR */
 368 error:
 369   {
 370     GST_DEBUG_OBJECT (src, "seek error");
 371     GST_STREAM_UNLOCK (src->srcpad);
 372     gst_event_unref (event);
 373     return FALSE;
 374   }
 375 }
 376
 377 static gboolean
 378 gst_basesrc_event_handler (GstPad * pad, GstEvent * event)
 379 {
 380   GstBaseSrc *src;
 381   GstBaseSrcClass *bclass;
 382   gboolean result;
 383
 384   src = GST_BASESRC (GST_PAD_PARENT (pad));
 385   bclass = GST_BASESRC_GET_CLASS (src);
 386
 387   if (bclass->event)
 388     result = bclass->event (src, event);
 389
 390   switch (GST_EVENT_TYPE (event)) {
 391     case GST_EVENT_SEEK:
 392       return gst_basesrc_do_seek (src, event);
 393     case GST_EVENT_SIZE:
 394     {
 395       GstFormat format;
 396
 397       format = GST_EVENT_SIZE_FORMAT (event);
 398       if (format == GST_FORMAT_DEFAULT)
 399         format = GST_FORMAT_BYTES;
 400       /* we can only accept bytes */
 401       if (format != GST_FORMAT_BYTES)
 402         return FALSE;
 403
 404       src->blocksize = GST_EVENT_SIZE_VALUE (event);
 405       g_object_notify (G_OBJECT (src), "blocksize");
 406       break;
 407     }
 408     case GST_EVENT_FLUSH:
 409       /* cancel any blocking getrange */
 410       if (!GST_EVENT_FLUSH_DONE (event))
 411         gst_basesrc_unlock (src);
 412       break;
 413     default:
 414       break;
 415   }
 416   gst_event_unref (event);
 417
 418   return TRUE;
 419 }
 420
 421 static void
 422 gst_basesrc_set_property (GObject * object, guint prop_id, const GValue * value,
 423     GParamSpec * pspec)
 424 {
 425   GstBaseSrc *src;
 426
 427   src = GST_BASESRC (object);
 428
 429   switch (prop_id) {
 430     case PROP_BLOCKSIZE:
 431       src->blocksize = g_value_get_ulong (value);
 432       break;
 433     case PROP_HAS_LOOP:
 434       src->has_loop = g_value_get_boolean (value);
 435       gst_basesrc_set_dataflow_funcs (src);
 436       break;
 437     case PROP_HAS_GETRANGE:
 438       src->has_getrange = g_value_get_boolean (value);
 439       gst_basesrc_set_dataflow_funcs (src);
 440       break;
 441     default:
 442       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 443       break;
 444   }
 445 }
 446
 447 static void
 448 gst_basesrc_get_property (GObject * object, guint prop_id, GValue * value,
 449     GParamSpec * pspec)
 450 {
 451   GstBaseSrc *src;
 452
 453   src = GST_BASESRC (object);
 454
 455   switch (prop_id) {
 456     case PROP_BLOCKSIZE:
 457       g_value_set_ulong (value, src->blocksize);
 458       break;
 459     case PROP_HAS_LOOP:
 460       g_value_set_boolean (value, src->has_loop);
 461       break;
 462     case PROP_HAS_GETRANGE:
 463       g_value_set_boolean (value, src->has_getrange);
 464       break;
 465     default:
 466       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 467       break;
 468   }
 469 }
 470
 471 static GstFlowReturn
 472 gst_basesrc_get_range_unlocked (GstPad * pad, guint64 offset, guint length,
 473     GstBuffer ** buf)
 474 {
 475   GstFlowReturn ret;
 476   GstBaseSrc *src;
 477   GstBaseSrcClass *bclass;
 478
 479   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 480   bclass = GST_BASESRC_GET_CLASS (src);
 481
 482   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED))
 483     goto not_started;
 484
 485   if (!bclass->create)
 486     goto no_function;
 487
 488   /* check size */
 489   if (src->size != -1) {
 490     if (offset + length > src->size) {
 491       if (bclass->get_size)
 492         bclass->get_size (src, &src->size);
 493
 494       if (offset + length > src->size) {
 495         length = src->size - offset;
 496       }
 497     }
 498   }
 499   if (length == 0)
 500     goto unexpected_length;
 501
 502   ret = bclass->create (src, offset, length, buf);
 503
 504   return ret;
 505
 506   /* ERROR */
 507 not_started:
 508   {
 509     GST_DEBUG_OBJECT (src, "getrange but not started");
 510     return GST_FLOW_WRONG_STATE;
 511   }
 512 no_function:
 513   {
 514     GST_DEBUG_OBJECT (src, "no create function");
 515     return GST_FLOW_ERROR;
 516   }
 517 unexpected_length:
 518   {
 519     GST_DEBUG_OBJECT (src, "unexpected length %u", length);
 520     return GST_FLOW_UNEXPECTED;
 521   }
 522 }
 523
 524 static GstFlowReturn
 525 gst_basesrc_get_range (GstPad * pad, guint64 offset, guint length,
 526     GstBuffer ** ret)
 527 {
 528   GstFlowReturn fret;
 529
 530   GST_STREAM_LOCK (pad);
 531
 532   fret = gst_basesrc_get_range_unlocked (pad, offset, length, ret);
 533
 534   GST_STREAM_UNLOCK (pad);
 535
 536   return fret;
 537 }
 538
 539 static gboolean
 540 gst_basesrc_check_get_range (GstPad * pad)
 541 {
 542   GstBaseSrc *src;
 543
 544   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 545
 546   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED)) {
 547     gst_basesrc_start (src);
 548     gst_basesrc_stop (src);
 549   }
 550
 551   return src->seekable;
 552 }
 553
 554 static void
 555 gst_basesrc_loop (GstPad * pad)
 556 {
 557   GstBaseSrc *src;
 558   GstBuffer *buf = NULL;
 559   GstFlowReturn ret;
 560
 561   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 562
 563   GST_STREAM_LOCK (pad);
 564
 565   ret = gst_basesrc_get_range_unlocked (pad, src->offset, src->blocksize, &buf);
 566   if (ret != GST_FLOW_OK)
 567     goto eos;
 568
 569   src->offset += GST_BUFFER_SIZE (buf);
 570
 571   ret = gst_pad_push (pad, buf);
 572   if (ret != GST_FLOW_OK)
 573     goto pause;
 574
 575   GST_STREAM_UNLOCK (pad);
 576   return;
 577
 578 eos:
 579   {
 580     GST_DEBUG_OBJECT (src, "going to EOS");
 581     gst_task_pause (GST_RPAD_TASK (pad));
 582     gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
 583     GST_STREAM_UNLOCK (pad);
 584     return;
 585   }
 586 pause:
 587   {
 588     GST_DEBUG_OBJECT (src, "pausing task");
 589     gst_task_pause (GST_RPAD_TASK (pad));
 590     GST_STREAM_UNLOCK (pad);
 591     return;
 592   }
 593 }
 594
 595 static gboolean
 596 gst_basesrc_unlock (GstBaseSrc * basesrc)
 597 {
 598   GstBaseSrcClass *bclass;
 599   gboolean result = FALSE;
 600
 601   bclass = GST_BASESRC_GET_CLASS (basesrc);
 602   if (bclass->unlock)
 603     result = bclass->unlock (basesrc);
 604
 605   return result;
 606 }
 607
 608 static gboolean
 609 gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size)
 610 {
 611   GstBaseSrcClass *bclass;
 612   gboolean result = FALSE;
 613
 614   bclass = GST_BASESRC_GET_CLASS (basesrc);
 615   if (bclass->get_size)
 616     result = bclass->get_size (basesrc, size);
 617
 618   if (result)
 619     basesrc->size = *size;
 620
 621   return result;
 622 }
 623
 624 static gboolean
 625 gst_basesrc_start (GstBaseSrc * basesrc)
 626 {
 627   GstBaseSrcClass *bclass;
 628   gboolean result;
 629
 630   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 631     return TRUE;
 632
 633   bclass = GST_BASESRC_GET_CLASS (basesrc);
 634   if (bclass->start)
 635     result = bclass->start (basesrc);
 636   else
 637     result = TRUE;
 638
 639   if (!result)
 640     goto could_not_start;
 641
 642   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 643
 644   /* start in the beginning */
 645   basesrc->offset = 0;
 646   basesrc->segment_start = 0;
 647
 648   /* figure out the size */
 649   if (bclass->get_size) {
 650     result = bclass->get_size (basesrc, &basesrc->size);
 651     if (result == FALSE)
 652       basesrc->size = -1;
 653   } else {
 654     result = FALSE;
 655     basesrc->size = -1;
 656   }
 657
 658   GST_DEBUG ("size %d %lld", result, basesrc->size);
 659
 660   /* we always run to the end */
 661   basesrc->segment_end = -1;
 662
 663   /* check if we can seek */
 664   if (bclass->is_seekable)
 665     basesrc->seekable = bclass->is_seekable (basesrc);
 666   else
 667     basesrc->seekable = FALSE;
 668
 669   /* run typefind */
 670 #if 0
 671   if (basesrc->seekable) {
 672     GstCaps *caps;
 673
 674     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 675     gst_pad_set_caps (basesrc->srcpad, caps);
 676   }
 677 #endif
 678
 679   return TRUE;
 680
 681   /* ERROR */
 682 could_not_start:
 683   {
 684     GST_DEBUG_OBJECT (basesrc, "could not start");
 685     return FALSE;
 686   }
 687 }
 688
 689 static gboolean
 690 gst_basesrc_stop (GstBaseSrc * basesrc)
 691 {
 692   GstBaseSrcClass *bclass;
 693   gboolean result = TRUE;
 694
 695   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 696     return TRUE;
 697
 698   bclass = GST_BASESRC_GET_CLASS (basesrc);
 699   if (bclass->stop)
 700     result = bclass->stop (basesrc);
 701
 702   if (result)
 703     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 704
 705   return result;
 706 }
 707
 708 static gboolean
 709 gst_basesrc_activate (GstPad * pad, GstActivateMode mode)
 710 {
 711   gboolean result;
 712   GstBaseSrc *basesrc;
 713
 714   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 715
 716   /* prepare subclass first */
 717   switch (mode) {
 718     case GST_ACTIVATE_PUSH:
 719     case GST_ACTIVATE_PULL:
 720       result = gst_basesrc_start (basesrc);
 721       break;
 722     default:
 723       result = TRUE;
 724       break;
 725   }
 726   /* if that failed we can stop here */
 727   if (!result)
 728     goto error_start;
 729
 730   result = FALSE;
 731   switch (mode) {
 732     case GST_ACTIVATE_PUSH:
 733       /* if we have a scheduler we can start the task */
 734       if (GST_ELEMENT_SCHEDULER (basesrc)) {
 735         GST_STREAM_LOCK (pad);
 736         GST_RPAD_TASK (pad) =
 737             gst_scheduler_create_task (GST_ELEMENT_SCHEDULER (basesrc),
 738             (GstTaskFunction) gst_basesrc_loop, pad);
 739
 740         gst_task_start (GST_RPAD_TASK (pad));
 741         GST_STREAM_UNLOCK (pad);
 742         result = TRUE;
 743       }
 744       break;
 745     case GST_ACTIVATE_PULL:
 746       result = TRUE;
 747       break;
 748     case GST_ACTIVATE_NONE:
 749       /* step 1, unblock clock sync (if any) */
 750
 751       /* step 2, make sure streaming finishes */
 752       GST_STREAM_LOCK (pad);
 753       /* step 3, stop the task */
 754       if (GST_RPAD_TASK (pad)) {
 755         gst_task_stop (GST_RPAD_TASK (pad));
 756         gst_object_unref (GST_OBJECT (GST_RPAD_TASK (pad)));
 757         GST_RPAD_TASK (pad) = NULL;
 758       }
 759       GST_STREAM_UNLOCK (pad);
 760
 761       result = TRUE;
 762       break;
 763   }
 764   return result;
 765
 766   /* ERROR */
 767 error_start:
 768   {
 769     GST_DEBUG_OBJECT (basesrc, "failed to start");
 770     return FALSE;
 771   }
 772 }
 773
 774 static GstElementStateReturn
 775 gst_basesrc_change_state (GstElement * element)
 776 {
 777   GstBaseSrc *basesrc;
 778   GstElementStateReturn result = GST_STATE_FAILURE;
 779   GstElementState transition;
 780
 781   basesrc = GST_BASESRC (element);
 782
 783   transition = GST_STATE_TRANSITION (element);
 784
 785   switch (transition) {
 786     case GST_STATE_NULL_TO_READY:
 787       break;
 788     case GST_STATE_READY_TO_PAUSED:
 789       break;
 790     case GST_STATE_PAUSED_TO_PLAYING:
 791       break;
 792     default:
 793       break;
 794   }
 795
 796   result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
 797
 798   switch (transition) {
 799     case GST_STATE_PLAYING_TO_PAUSED:
 800       break;
 801     case GST_STATE_PAUSED_TO_READY:
 802       result = gst_basesrc_stop (basesrc);
 803       break;
 804     case GST_STATE_READY_TO_NULL:
 805       break;
 806     default:
 807       break;
 808   }
 809
 810   return result;
 811 }