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     gboolean * random_access);
 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_event_mask_function (pad, gst_basesrc_get_event_mask);
 164   gst_pad_set_query_function (pad, gst_basesrc_query);
 165   gst_pad_set_query_type_function (pad, gst_basesrc_get_query_types);
 166   gst_pad_set_formats_function (pad, gst_basesrc_get_formats);
 167   gst_pad_set_checkgetrange_function (pad, gst_basesrc_check_get_range);
 168   /* hold ref to pad */
 169   basesrc->srcpad = pad;
 170   gst_element_add_pad (GST_ELEMENT (basesrc), pad);
 171
 172   basesrc->segment_start = -1;
 173   basesrc->segment_end = -1;
 174   basesrc->blocksize = DEFAULT_BLOCKSIZE;
 175
 176   GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 177 }
 178
 179 static void
 180 gst_basesrc_set_dataflow_funcs (GstBaseSrc * this)
 181 {
 182   if (this->has_loop)
 183     gst_pad_set_loop_function (this->srcpad, gst_basesrc_loop);
 184   else
 185     gst_pad_set_loop_function (this->srcpad, NULL);
 186
 187   if (this->has_getrange)
 188     gst_pad_set_getrange_function (this->srcpad, gst_basesrc_get_range);
 189   else
 190     gst_pad_set_getrange_function (this->srcpad, NULL);
 191 }
 192
 193 static const GstFormat *
 194 gst_basesrc_get_formats (GstPad * pad)
 195 {
 196   static const GstFormat formats[] = {
 197     GST_FORMAT_DEFAULT,
 198     GST_FORMAT_BYTES,
 199     0,
 200   };
 201
 202   return formats;
 203 }
 204
 205 static const GstQueryType *
 206 gst_basesrc_get_query_types (GstPad * pad)
 207 {
 208   static const GstQueryType types[] = {
 209     GST_QUERY_TOTAL,
 210     GST_QUERY_POSITION,
 211     GST_QUERY_START,
 212     GST_QUERY_SEGMENT_END,
 213     0,
 214   };
 215
 216   return types;
 217 }
 218
 219 static gboolean
 220 gst_basesrc_query (GstPad * pad, GstQueryType type,
 221     GstFormat * format, gint64 * value)
 222 {
 223   GstBaseSrc *src = GST_BASESRC (GST_PAD_PARENT (pad));
 224
 225   if (*format == GST_FORMAT_DEFAULT)
 226     *format = GST_FORMAT_BYTES;
 227
 228   switch (type) {
 229     case GST_QUERY_TOTAL:
 230       switch (*format) {
 231         case GST_FORMAT_BYTES:
 232         {
 233           gboolean ret;
 234
 235           /* FIXME-wim: is this cast right? */
 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, gboolean * random_access)
 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   *random_access = src->random_access;
 552   return src->seekable;
 553 }
 554
 555 static void
 556 gst_basesrc_loop (GstPad * pad)
 557 {
 558   GstBaseSrc *src;
 559   GstBuffer *buf = NULL;
 560   GstFlowReturn ret;
 561
 562   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 563
 564   GST_STREAM_LOCK (pad);
 565
 566   ret = gst_basesrc_get_range_unlocked (pad, src->offset, src->blocksize, &buf);
 567   if (ret != GST_FLOW_OK)
 568     goto eos;
 569
 570   src->offset += GST_BUFFER_SIZE (buf);
 571
 572   ret = gst_pad_push (pad, buf);
 573   if (ret != GST_FLOW_OK)
 574     goto pause;
 575
 576   GST_STREAM_UNLOCK (pad);
 577   return;
 578
 579 eos:
 580   {
 581     GST_DEBUG_OBJECT (src, "going to EOS");
 582     gst_task_pause (GST_RPAD_TASK (pad));
 583     gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
 584     GST_STREAM_UNLOCK (pad);
 585     return;
 586   }
 587 pause:
 588   {
 589     GST_DEBUG_OBJECT (src, "pausing task");
 590     gst_task_pause (GST_RPAD_TASK (pad));
 591     GST_STREAM_UNLOCK (pad);
 592     return;
 593   }
 594 }
 595
 596 static gboolean
 597 gst_basesrc_unlock (GstBaseSrc * basesrc)
 598 {
 599   GstBaseSrcClass *bclass;
 600   gboolean result = FALSE;
 601
 602   bclass = GST_BASESRC_GET_CLASS (basesrc);
 603   if (bclass->unlock)
 604     result = bclass->unlock (basesrc);
 605
 606   return result;
 607 }
 608
 609 static gboolean
 610 gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size)
 611 {
 612   GstBaseSrcClass *bclass;
 613   gboolean result = FALSE;
 614
 615   bclass = GST_BASESRC_GET_CLASS (basesrc);
 616   if (bclass->get_size)
 617     result = bclass->get_size (basesrc, size);
 618
 619   if (result)
 620     basesrc->size = *size;
 621
 622   return result;
 623 }
 624
 625 static gboolean
 626 gst_basesrc_start (GstBaseSrc * basesrc)
 627 {
 628   GstBaseSrcClass *bclass;
 629   gboolean result;
 630
 631   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 632     return TRUE;
 633
 634   bclass = GST_BASESRC_GET_CLASS (basesrc);
 635   if (bclass->start)
 636     result = bclass->start (basesrc);
 637   else
 638     result = TRUE;
 639
 640   if (!result)
 641     goto could_not_start;
 642
 643   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 644
 645   /* start in the beginning */
 646   basesrc->offset = 0;
 647   basesrc->segment_start = 0;
 648
 649   /* figure out the size */
 650   if (bclass->get_size) {
 651     result = bclass->get_size (basesrc, &basesrc->size);
 652     if (result == FALSE)
 653       basesrc->size = -1;
 654   } else {
 655     result = FALSE;
 656     basesrc->size = -1;
 657   }
 658
 659   GST_DEBUG ("size %d %lld", result, basesrc->size);
 660
 661   /* we always run to the end */
 662   basesrc->segment_end = -1;
 663
 664   /* check if we can seek */
 665   if (bclass->is_seekable)
 666     basesrc->seekable = bclass->is_seekable (basesrc);
 667   else
 668     basesrc->seekable = FALSE;
 669
 670   /* run typefind */
 671 #if 0
 672   if (basesrc->seekable) {
 673     GstCaps *caps;
 674
 675     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 676     gst_pad_set_caps (basesrc->srcpad, caps);
 677   }
 678 #endif
 679
 680   return TRUE;
 681
 682   /* ERROR */
 683 could_not_start:
 684   {
 685     GST_DEBUG_OBJECT (basesrc, "could not start");
 686     return FALSE;
 687   }
 688 }
 689
 690 static gboolean
 691 gst_basesrc_stop (GstBaseSrc * basesrc)
 692 {
 693   GstBaseSrcClass *bclass;
 694   gboolean result = TRUE;
 695
 696   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 697     return TRUE;
 698
 699   bclass = GST_BASESRC_GET_CLASS (basesrc);
 700   if (bclass->stop)
 701     result = bclass->stop (basesrc);
 702
 703   if (result)
 704     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 705
 706   return result;
 707 }
 708
 709 static gboolean
 710 gst_basesrc_activate (GstPad * pad, GstActivateMode mode)
 711 {
 712   gboolean result;
 713   GstBaseSrc *basesrc;
 714
 715   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 716
 717   /* prepare subclass first */
 718   switch (mode) {
 719     case GST_ACTIVATE_PUSH:
 720     case GST_ACTIVATE_PULL:
 721     case GST_ACTIVATE_PULL_RANGE:
 722       result = gst_basesrc_start (basesrc);
 723       break;
 724     default:
 725       result = TRUE;
 726       break;
 727   }
 728   /* if that failed we can stop here */
 729   if (!result)
 730     goto error_start;
 731
 732   result = FALSE;
 733   switch (mode) {
 734     case GST_ACTIVATE_PUSH:
 735       /* if we have a scheduler we can start the task */
 736       if (GST_ELEMENT_SCHEDULER (basesrc)) {
 737         GST_STREAM_LOCK (pad);
 738         GST_RPAD_TASK (pad) =
 739             gst_scheduler_create_task (GST_ELEMENT_SCHEDULER (basesrc),
 740             (GstTaskFunction) gst_basesrc_loop, pad);
 741
 742         gst_task_start (GST_RPAD_TASK (pad));
 743         GST_STREAM_UNLOCK (pad);
 744         result = TRUE;
 745       }
 746       break;
 747     case GST_ACTIVATE_PULL:
 748     case GST_ACTIVATE_PULL_RANGE:
 749       result = TRUE;
 750       break;
 751     case GST_ACTIVATE_NONE:
 752       /* step 1, unblock clock sync (if any) */
 753
 754       /* step 2, make sure streaming finishes */
 755       GST_STREAM_LOCK (pad);
 756       /* step 3, stop the task */
 757       if (GST_RPAD_TASK (pad)) {
 758         gst_task_stop (GST_RPAD_TASK (pad));
 759         gst_object_unref (GST_OBJECT (GST_RPAD_TASK (pad)));
 760         GST_RPAD_TASK (pad) = NULL;
 761       }
 762       GST_STREAM_UNLOCK (pad);
 763
 764       result = TRUE;
 765       break;
 766   }
 767   return result;
 768
 769   /* ERROR */
 770 error_start:
 771   {
 772     GST_DEBUG_OBJECT (basesrc, "failed to start");
 773     return FALSE;
 774   }
 775 }
 776
 777 static GstElementStateReturn
 778 gst_basesrc_change_state (GstElement * element)
 779 {
 780   GstBaseSrc *basesrc;
 781   GstElementStateReturn result = GST_STATE_FAILURE;
 782   GstElementState transition;
 783
 784   basesrc = GST_BASESRC (element);
 785
 786   transition = GST_STATE_TRANSITION (element);
 787
 788   switch (transition) {
 789     case GST_STATE_NULL_TO_READY:
 790       break;
 791     case GST_STATE_READY_TO_PAUSED:
 792       break;
 793     case GST_STATE_PAUSED_TO_PLAYING:
 794       break;
 795     default:
 796       break;
 797   }
 798
 799   result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
 800
 801   switch (transition) {
 802     case GST_STATE_PLAYING_TO_PAUSED:
 803       break;
 804     case GST_STATE_PAUSED_TO_READY:
 805       result = gst_basesrc_stop (basesrc);
 806       break;
 807     case GST_STATE_READY_TO_NULL:
 808       break;
 809     default:
 810       break;
 811   }
 812
 813   return result;
 814 }