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   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 const GstFormat *
 196 gst_basesrc_get_formats (GstPad * pad)
 197 {
 198   static const GstFormat formats[] = {
 199     GST_FORMAT_DEFAULT,
 200     GST_FORMAT_BYTES,
 201     0,
 202   };
 203
 204   return formats;
 205 }
 206
 207 static const GstQueryType *
 208 gst_basesrc_get_query_types (GstPad * pad)
 209 {
 210   static const GstQueryType types[] = {
 211     GST_QUERY_TOTAL,
 212     GST_QUERY_POSITION,
 213     GST_QUERY_START,
 214     GST_QUERY_SEGMENT_END,
 215     0,
 216   };
 217
 218   return types;
 219 }
 220
 221 static gboolean
 222 gst_basesrc_query (GstPad * pad, GstQueryType type,
 223     GstFormat * format, gint64 * value)
 224 {
 225   GstBaseSrc *src = GST_BASESRC (GST_PAD_PARENT (pad));
 226
 227   if (*format == GST_FORMAT_DEFAULT)
 228     *format = GST_FORMAT_BYTES;
 229
 230   switch (type) {
 231     case GST_QUERY_TOTAL:
 232       switch (*format) {
 233         case GST_FORMAT_BYTES:
 234         {
 235           gboolean ret;
 236
 237           ret = gst_basesrc_get_size (src, (guint64 *) value);
 238           GST_DEBUG ("getting length %d %lld", ret, *value);
 239           return ret;
 240         }
 241         case GST_FORMAT_PERCENT:
 242           *value = GST_FORMAT_PERCENT_MAX;
 243           return TRUE;
 244         default:
 245           return FALSE;
 246       }
 247       break;
 248     case GST_QUERY_POSITION:
 249       switch (*format) {
 250         case GST_FORMAT_BYTES:
 251           *value = src->offset;
 252           break;
 253         case GST_FORMAT_PERCENT:
 254           /* fixme */
 255           if (!gst_basesrc_get_size (src, (guint64 *) value))
 256             return FALSE;
 257           *value = src->offset * GST_FORMAT_PERCENT_MAX / *value;
 258           return TRUE;
 259         default:
 260           return FALSE;
 261       }
 262       break;
 263     case GST_QUERY_START:
 264       *value = src->segment_start;
 265       return TRUE;
 266     case GST_QUERY_SEGMENT_END:
 267       *value = src->segment_end;
 268       return TRUE;
 269     default:
 270       return FALSE;
 271   }
 272   return FALSE;
 273 }
 274
 275 static const GstEventMask *
 276 gst_basesrc_get_event_mask (GstPad * pad)
 277 {
 278   static const GstEventMask masks[] = {
 279     {GST_EVENT_SEEK, GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_SET |
 280           GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH |
 281           GST_SEEK_FLAG_SEGMENT_LOOP},
 282     {GST_EVENT_FLUSH, 0},
 283     {GST_EVENT_SIZE, 0},
 284     {0, 0},
 285   };
 286   return masks;
 287 }
 288
 289 static gboolean
 290 gst_basesrc_do_seek (GstBaseSrc * src, GstEvent * event)
 291 {
 292   GstFormat format;
 293   gint64 offset;
 294
 295   format = GST_EVENT_SEEK_FORMAT (event);
 296
 297   /* get seek format */
 298   if (format == GST_FORMAT_DEFAULT)
 299     format = GST_FORMAT_BYTES;
 300   /* we can only seek bytes */
 301   if (format != GST_FORMAT_BYTES)
 302     return FALSE;
 303
 304   /* get seek positions */
 305   offset = GST_EVENT_SEEK_OFFSET (event);
 306   src->segment_start = offset;
 307   src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 308   src->segment_loop = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
 309
 310   /* send flush start */
 311   gst_pad_push_event (src->srcpad, gst_event_new_flush (FALSE));
 312
 313   /* unblock streaming thread */
 314   gst_basesrc_unlock (src);
 315
 316   /* grab streaming lock */
 317   GST_STREAM_LOCK (src->srcpad);
 318
 319   switch (GST_EVENT_SEEK_METHOD (event)) {
 320     case GST_SEEK_METHOD_SET:
 321       if (offset < 0)
 322         goto error;
 323       src->offset = MIN (offset, src->size);
 324       GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
 325           src->offset);
 326       break;
 327     case GST_SEEK_METHOD_CUR:
 328       offset += src->offset;
 329       src->offset = CLAMP (offset, 0, src->size);
 330       GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
 331           src->offset);
 332       break;
 333     case GST_SEEK_METHOD_END:
 334       if (offset > 0)
 335         goto error;
 336       offset = src->size + offset;
 337       src->offset = MAX (0, offset);
 338       GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
 339           src->offset);
 340       break;
 341     default:
 342       goto error;
 343   }
 344   /* send flush end */
 345   gst_pad_push_event (src->srcpad, gst_event_new_flush (TRUE));
 346
 347   /* now send discont */
 348   {
 349     GstEvent *event;
 350
 351     event = gst_event_new_discontinuous (1.0,
 352         GST_FORMAT_TIME,
 353         (gint64) src->segment_start, (gint64) src->segment_end, NULL);
 354
 355     gst_pad_push_event (src->srcpad, event);
 356   }
 357
 358   /* and restart the task */
 359   if (GST_RPAD_TASK (src->srcpad)) {
 360     gst_task_start (GST_RPAD_TASK (src->srcpad));
 361   }
 362   GST_STREAM_UNLOCK (src->srcpad);
 363
 364   gst_event_unref (event);
 365
 366   return TRUE;
 367
 368   /* ERROR */
 369 error:
 370   {
 371     GST_DEBUG_OBJECT (src, "seek error");
 372     GST_STREAM_UNLOCK (src->srcpad);
 373     gst_event_unref (event);
 374     return FALSE;
 375   }
 376 }
 377
 378 static gboolean
 379 gst_basesrc_event_handler (GstPad * pad, GstEvent * event)
 380 {
 381   GstBaseSrc *src;
 382   GstBaseSrcClass *bclass;
 383   gboolean result;
 384
 385   src = GST_BASESRC (GST_PAD_PARENT (pad));
 386   bclass = GST_BASESRC_GET_CLASS (src);
 387
 388   if (bclass->event)
 389     result = bclass->event (src, event);
 390
 391   switch (GST_EVENT_TYPE (event)) {
 392     case GST_EVENT_SEEK:
 393       return gst_basesrc_do_seek (src, event);
 394     case GST_EVENT_SIZE:
 395     {
 396       GstFormat format;
 397
 398       format = GST_EVENT_SIZE_FORMAT (event);
 399       if (format == GST_FORMAT_DEFAULT)
 400         format = GST_FORMAT_BYTES;
 401       /* we can only accept bytes */
 402       if (format != GST_FORMAT_BYTES)
 403         return FALSE;
 404
 405       src->blocksize = GST_EVENT_SIZE_VALUE (event);
 406       g_object_notify (G_OBJECT (src), "blocksize");
 407       break;
 408     }
 409     case GST_EVENT_FLUSH:
 410       /* cancel any blocking getrange */
 411       if (!GST_EVENT_FLUSH_DONE (event))
 412         gst_basesrc_unlock (src);
 413       break;
 414     default:
 415       break;
 416   }
 417   gst_event_unref (event);
 418
 419   return TRUE;
 420 }
 421
 422 static void
 423 gst_basesrc_set_property (GObject * object, guint prop_id, const GValue * value,
 424     GParamSpec * pspec)
 425 {
 426   GstBaseSrc *src;
 427
 428   src = GST_BASESRC (object);
 429
 430   switch (prop_id) {
 431     case PROP_BLOCKSIZE:
 432       src->blocksize = g_value_get_ulong (value);
 433       break;
 434     case PROP_HAS_LOOP:
 435       src->has_loop = g_value_get_boolean (value);
 436       gst_basesrc_set_dataflow_funcs (src);
 437       break;
 438     case PROP_HAS_GETRANGE:
 439       src->has_getrange = g_value_get_boolean (value);
 440       gst_basesrc_set_dataflow_funcs (src);
 441       break;
 442     default:
 443       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 444       break;
 445   }
 446 }
 447
 448 static void
 449 gst_basesrc_get_property (GObject * object, guint prop_id, GValue * value,
 450     GParamSpec * pspec)
 451 {
 452   GstBaseSrc *src;
 453
 454   src = GST_BASESRC (object);
 455
 456   switch (prop_id) {
 457     case PROP_BLOCKSIZE:
 458       g_value_set_ulong (value, src->blocksize);
 459       break;
 460     case PROP_HAS_LOOP:
 461       g_value_set_boolean (value, src->has_loop);
 462       break;
 463     case PROP_HAS_GETRANGE:
 464       g_value_set_boolean (value, src->has_getrange);
 465       break;
 466     default:
 467       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 468       break;
 469   }
 470 }
 471
 472 static GstFlowReturn
 473 gst_basesrc_get_range_unlocked (GstPad * pad, guint64 offset, guint length,
 474     GstBuffer ** buf)
 475 {
 476   GstFlowReturn ret;
 477   GstBaseSrc *src;
 478   GstBaseSrcClass *bclass;
 479
 480   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 481   bclass = GST_BASESRC_GET_CLASS (src);
 482
 483   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED))
 484     goto not_started;
 485
 486   if (!bclass->create)
 487     goto no_function;
 488
 489   /* check size */
 490   if (src->size != -1) {
 491     if (offset + length > src->size) {
 492       if (bclass->get_size)
 493         bclass->get_size (src, &src->size);
 494
 495       if (offset + length > src->size) {
 496         length = src->size - offset;
 497       }
 498     }
 499   }
 500   if (length == 0)
 501     goto unexpected_length;
 502
 503   ret = bclass->create (src, offset, length, buf);
 504
 505   return ret;
 506
 507   /* ERROR */
 508 not_started:
 509   {
 510     GST_DEBUG_OBJECT (src, "getrange but not started");
 511     return GST_FLOW_WRONG_STATE;
 512   }
 513 no_function:
 514   {
 515     GST_DEBUG_OBJECT (src, "no create function");
 516     return GST_FLOW_ERROR;
 517   }
 518 unexpected_length:
 519   {
 520     GST_DEBUG_OBJECT (src, "unexpected length %u", length);
 521     return GST_FLOW_UNEXPECTED;
 522   }
 523 }
 524
 525 static GstFlowReturn
 526 gst_basesrc_get_range (GstPad * pad, guint64 offset, guint length,
 527     GstBuffer ** ret)
 528 {
 529   GstFlowReturn fret;
 530
 531   GST_STREAM_LOCK (pad);
 532
 533   fret = gst_basesrc_get_range_unlocked (pad, offset, length, ret);
 534
 535   GST_STREAM_UNLOCK (pad);
 536
 537   return fret;
 538 }
 539
 540 static gboolean
 541 gst_basesrc_check_get_range (GstPad * pad)
 542 {
 543   GstBaseSrc *src;
 544
 545   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 546
 547   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED)) {
 548     gst_basesrc_start (src);
 549     gst_basesrc_stop (src);
 550   }
 551
 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   /* unblock whatever the subclass is doing */
 603   bclass = GST_BASESRC_GET_CLASS (basesrc);
 604   if (bclass->unlock)
 605     result = bclass->unlock (basesrc);
 606
 607   /* and unblock the clock as well, if any */
 608   GST_LOCK (basesrc);
 609   if (basesrc->clock_id) {
 610     gst_clock_id_unschedule (basesrc->clock_id);
 611   }
 612   GST_UNLOCK (basesrc);
 613
 614   return result;
 615 }
 616
 617 static gboolean
 618 gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size)
 619 {
 620   GstBaseSrcClass *bclass;
 621   gboolean result = FALSE;
 622
 623   bclass = GST_BASESRC_GET_CLASS (basesrc);
 624   if (bclass->get_size)
 625     result = bclass->get_size (basesrc, size);
 626
 627   if (result)
 628     basesrc->size = *size;
 629
 630   return result;
 631 }
 632
 633 static gboolean
 634 gst_basesrc_start (GstBaseSrc * basesrc)
 635 {
 636   GstBaseSrcClass *bclass;
 637   gboolean result;
 638
 639   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 640     return TRUE;
 641
 642   bclass = GST_BASESRC_GET_CLASS (basesrc);
 643   if (bclass->start)
 644     result = bclass->start (basesrc);
 645   else
 646     result = TRUE;
 647
 648   if (!result)
 649     goto could_not_start;
 650
 651   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 652
 653   /* start in the beginning */
 654   basesrc->offset = 0;
 655   basesrc->segment_start = 0;
 656
 657   /* figure out the size */
 658   if (bclass->get_size) {
 659     result = bclass->get_size (basesrc, &basesrc->size);
 660     if (result == FALSE)
 661       basesrc->size = -1;
 662   } else {
 663     result = FALSE;
 664     basesrc->size = -1;
 665   }
 666
 667   GST_DEBUG ("size %d %lld", result, basesrc->size);
 668
 669   /* we always run to the end */
 670   basesrc->segment_end = -1;
 671
 672   /* check if we can seek */
 673   if (bclass->is_seekable)
 674     basesrc->seekable = bclass->is_seekable (basesrc);
 675   else
 676     basesrc->seekable = FALSE;
 677
 678   /* run typefind */
 679 #if 0
 680   if (basesrc->seekable) {
 681     GstCaps *caps;
 682
 683     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 684     gst_pad_set_caps (basesrc->srcpad, caps);
 685   }
 686 #endif
 687
 688   return TRUE;
 689
 690   /* ERROR */
 691 could_not_start:
 692   {
 693     GST_DEBUG_OBJECT (basesrc, "could not start");
 694     return FALSE;
 695   }
 696 }
 697
 698 static gboolean
 699 gst_basesrc_stop (GstBaseSrc * basesrc)
 700 {
 701   GstBaseSrcClass *bclass;
 702   gboolean result = TRUE;
 703
 704   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 705     return TRUE;
 706
 707   bclass = GST_BASESRC_GET_CLASS (basesrc);
 708   if (bclass->stop)
 709     result = bclass->stop (basesrc);
 710
 711   if (result)
 712     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 713
 714   return result;
 715 }
 716
 717 static gboolean
 718 gst_basesrc_activate (GstPad * pad, GstActivateMode mode)
 719 {
 720   gboolean result;
 721   GstBaseSrc *basesrc;
 722
 723   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 724
 725   /* prepare subclass first */
 726   switch (mode) {
 727     case GST_ACTIVATE_PUSH:
 728     case GST_ACTIVATE_PULL:
 729       result = gst_basesrc_start (basesrc);
 730       break;
 731     default:
 732       result = TRUE;
 733       break;
 734   }
 735   /* if that failed we can stop here */
 736   if (!result)
 737     goto error_start;
 738
 739   result = FALSE;
 740   switch (mode) {
 741     case GST_ACTIVATE_PUSH:
 742       /* if we have a scheduler we can start the task */
 743       if (GST_ELEMENT_SCHEDULER (basesrc)) {
 744         GST_STREAM_LOCK (pad);
 745         GST_RPAD_TASK (pad) =
 746             gst_scheduler_create_task (GST_ELEMENT_SCHEDULER (basesrc),
 747             (GstTaskFunction) gst_basesrc_loop, pad);
 748
 749         gst_task_start (GST_RPAD_TASK (pad));
 750         GST_STREAM_UNLOCK (pad);
 751         result = TRUE;
 752       }
 753       break;
 754     case GST_ACTIVATE_PULL:
 755       result = TRUE;
 756       break;
 757     case GST_ACTIVATE_NONE:
 758       /* step 1, unblock clock sync (if any) */
 759       gst_basesrc_unlock (basesrc);
 760
 761       /* step 2, make sure streaming finishes */
 762       GST_STREAM_LOCK (pad);
 763       /* step 3, stop the task */
 764       if (GST_RPAD_TASK (pad)) {
 765         gst_task_stop (GST_RPAD_TASK (pad));
 766         gst_object_unref (GST_OBJECT (GST_RPAD_TASK (pad)));
 767         GST_RPAD_TASK (pad) = NULL;
 768       }
 769       GST_STREAM_UNLOCK (pad);
 770
 771       result = TRUE;
 772       break;
 773   }
 774   return result;
 775
 776   /* ERROR */
 777 error_start:
 778   {
 779     GST_DEBUG_OBJECT (basesrc, "failed to start");
 780     return FALSE;
 781   }
 782 }
 783
 784 static GstElementStateReturn
 785 gst_basesrc_change_state (GstElement * element)
 786 {
 787   GstBaseSrc *basesrc;
 788   GstElementStateReturn result = GST_STATE_FAILURE;
 789   GstElementState transition;
 790
 791   basesrc = GST_BASESRC (element);
 792
 793   transition = GST_STATE_TRANSITION (element);
 794
 795   switch (transition) {
 796     case GST_STATE_NULL_TO_READY:
 797       break;
 798     case GST_STATE_READY_TO_PAUSED:
 799       break;
 800     case GST_STATE_PAUSED_TO_PLAYING:
 801       break;
 802     default:
 803       break;
 804   }
 805
 806   result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
 807
 808   switch (transition) {
 809     case GST_STATE_PLAYING_TO_PAUSED:
 810       break;
 811     case GST_STATE_PAUSED_TO_READY:
 812       result = gst_basesrc_stop (basesrc);
 813       break;
 814     case GST_STATE_READY_TO_NULL:
 815       break;
 816     default:
 817       break;
 818   }
 819
 820   return result;
 821 }