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_loop = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
 284
 285   switch (GST_EVENT_SEEK_METHOD (event)) {
 286     case GST_SEEK_METHOD_SET:
 287       if (offset < 0)
 288         goto error;
 289       src->offset = MIN (offset, src->size);
 290       src->segment_start = src->offset;
 291       src->segment_end = MIN (GST_EVENT_SEEK_ENDOFFSET (event), src->size);
 292       GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
 293           src->offset);
 294       break;
 295     case GST_SEEK_METHOD_CUR:
 296       offset += src->offset;
 297       src->offset = CLAMP (offset, 0, src->size);
 298       src->segment_start = src->offset;
 299       src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 300       GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
 301           src->offset);
 302       break;
 303     case GST_SEEK_METHOD_END:
 304       if (offset > 0)
 305         goto error;
 306       offset = src->size + offset;
 307       src->offset = MAX (0, offset);
 308       src->segment_start = src->offset;
 309       src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 310       GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
 311           src->offset);
 312       break;
 313     default:
 314       goto error;
 315   }
 316
 317   /* send flush start */
 318   gst_pad_push_event (src->srcpad, gst_event_new_flush (FALSE));
 319
 320   /* unblock streaming thread */
 321   gst_basesrc_unlock (src);
 322
 323   /* grab streaming lock */
 324   GST_STREAM_LOCK (src->srcpad);
 325
 326   /* send flush end */
 327   gst_pad_push_event (src->srcpad, gst_event_new_flush (TRUE));
 328
 329   /* now send discont */
 330   {
 331     GstEvent *event;
 332
 333     event = gst_event_new_discontinuous (1.0,
 334         GST_FORMAT_BYTES,
 335         (gint64) src->segment_start, (gint64) src->segment_end, NULL);
 336
 337     gst_pad_push_event (src->srcpad, event);
 338   }
 339
 340   /* and restart the task */
 341   gst_pad_start_task (src->srcpad, (GstTaskFunction) gst_basesrc_loop,
 342       src->srcpad);
 343   GST_STREAM_UNLOCK (src->srcpad);
 344
 345   gst_event_unref (event);
 346
 347   return TRUE;
 348
 349   /* ERROR */
 350 error:
 351   {
 352     GST_DEBUG_OBJECT (src, "seek error");
 353     gst_event_unref (event);
 354     return FALSE;
 355   }
 356 }
 357
 358 static gboolean
 359 gst_basesrc_event_handler (GstPad * pad, GstEvent * event)
 360 {
 361   GstBaseSrc *src;
 362   GstBaseSrcClass *bclass;
 363   gboolean result;
 364
 365   src = GST_BASESRC (GST_PAD_PARENT (pad));
 366   bclass = GST_BASESRC_GET_CLASS (src);
 367
 368   if (bclass->event)
 369     result = bclass->event (src, event);
 370
 371   switch (GST_EVENT_TYPE (event)) {
 372     case GST_EVENT_SEEK:
 373       return gst_basesrc_do_seek (src, event);
 374     case GST_EVENT_SIZE:
 375     {
 376       GstFormat format;
 377
 378       format = GST_EVENT_SIZE_FORMAT (event);
 379       if (format == GST_FORMAT_DEFAULT)
 380         format = GST_FORMAT_BYTES;
 381       /* we can only accept bytes */
 382       if (format != GST_FORMAT_BYTES)
 383         return FALSE;
 384
 385       src->blocksize = GST_EVENT_SIZE_VALUE (event);
 386       g_object_notify (G_OBJECT (src), "blocksize");
 387       break;
 388     }
 389     case GST_EVENT_FLUSH:
 390       /* cancel any blocking getrange */
 391       if (!GST_EVENT_FLUSH_DONE (event))
 392         gst_basesrc_unlock (src);
 393       break;
 394     default:
 395       break;
 396   }
 397   gst_event_unref (event);
 398
 399   return TRUE;
 400 }
 401
 402 static void
 403 gst_basesrc_set_property (GObject * object, guint prop_id, const GValue * value,
 404     GParamSpec * pspec)
 405 {
 406   GstBaseSrc *src;
 407
 408   src = GST_BASESRC (object);
 409
 410   switch (prop_id) {
 411     case PROP_BLOCKSIZE:
 412       src->blocksize = g_value_get_ulong (value);
 413       break;
 414     case PROP_HAS_LOOP:
 415       src->has_loop = g_value_get_boolean (value);
 416       gst_basesrc_set_dataflow_funcs (src);
 417       break;
 418     case PROP_HAS_GETRANGE:
 419       src->has_getrange = g_value_get_boolean (value);
 420       gst_basesrc_set_dataflow_funcs (src);
 421       break;
 422     default:
 423       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 424       break;
 425   }
 426 }
 427
 428 static void
 429 gst_basesrc_get_property (GObject * object, guint prop_id, GValue * value,
 430     GParamSpec * pspec)
 431 {
 432   GstBaseSrc *src;
 433
 434   src = GST_BASESRC (object);
 435
 436   switch (prop_id) {
 437     case PROP_BLOCKSIZE:
 438       g_value_set_ulong (value, src->blocksize);
 439       break;
 440     case PROP_HAS_LOOP:
 441       g_value_set_boolean (value, src->has_loop);
 442       break;
 443     case PROP_HAS_GETRANGE:
 444       g_value_set_boolean (value, src->has_getrange);
 445       break;
 446     default:
 447       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 448       break;
 449   }
 450 }
 451
 452 static GstFlowReturn
 453 gst_basesrc_get_range (GstPad * pad, guint64 offset, guint length,
 454     GstBuffer ** buf)
 455 {
 456   GstFlowReturn ret;
 457   GstBaseSrc *src;
 458   GstBaseSrcClass *bclass;
 459
 460   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 461   bclass = GST_BASESRC_GET_CLASS (src);
 462
 463   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED))
 464     goto not_started;
 465
 466   if (!bclass->create)
 467     goto no_function;
 468
 469   /* check size */
 470   if (src->size != -1) {
 471     if (offset + length > src->size) {
 472       if (bclass->get_size)
 473         bclass->get_size (src, &src->size);
 474
 475       if (offset + length > src->size) {
 476         length = src->size - offset;
 477       }
 478     }
 479   }
 480   if (length == 0)
 481     goto unexpected_length;
 482
 483   ret = bclass->create (src, offset, length, buf);
 484
 485   return ret;
 486
 487   /* ERROR */
 488 not_started:
 489   {
 490     GST_DEBUG_OBJECT (src, "getrange but not started");
 491     return GST_FLOW_WRONG_STATE;
 492   }
 493 no_function:
 494   {
 495     GST_DEBUG_OBJECT (src, "no create function");
 496     return GST_FLOW_ERROR;
 497   }
 498 unexpected_length:
 499   {
 500     GST_DEBUG_OBJECT (src, "unexpected length %u", length);
 501     return GST_FLOW_UNEXPECTED;
 502   }
 503 }
 504
 505 static gboolean
 506 gst_basesrc_check_get_range (GstPad * pad)
 507 {
 508   GstBaseSrc *src;
 509
 510   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 511
 512   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED)) {
 513     gst_basesrc_start (src);
 514     gst_basesrc_stop (src);
 515   }
 516
 517   return src->seekable;
 518 }
 519
 520 static void
 521 gst_basesrc_loop (GstPad * pad)
 522 {
 523   GstBaseSrc *src;
 524   GstBuffer *buf = NULL;
 525   GstFlowReturn ret;
 526
 527   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 528
 529   ret = gst_basesrc_get_range (pad, src->offset, src->blocksize, &buf);
 530   if (ret != GST_FLOW_OK)
 531     goto eos;
 532
 533   src->offset += GST_BUFFER_SIZE (buf);
 534
 535   ret = gst_pad_push (pad, buf);
 536   if (ret != GST_FLOW_OK)
 537     goto pause;
 538
 539   return;
 540
 541 eos:
 542   {
 543     GST_DEBUG_OBJECT (src, "going to EOS");
 544     gst_pad_pause_task (pad);
 545     gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
 546     return;
 547   }
 548 pause:
 549   {
 550     GST_DEBUG_OBJECT (src, "pausing task");
 551     gst_pad_pause_task (pad);
 552     return;
 553   }
 554 }
 555
 556 static gboolean
 557 gst_basesrc_unlock (GstBaseSrc * basesrc)
 558 {
 559   GstBaseSrcClass *bclass;
 560   gboolean result = FALSE;
 561
 562   GST_DEBUG ("unlock");
 563   /* unblock whatever the subclass is doing */
 564   bclass = GST_BASESRC_GET_CLASS (basesrc);
 565   if (bclass->unlock)
 566     result = bclass->unlock (basesrc);
 567
 568   GST_DEBUG ("unschedule clock");
 569   /* and unblock the clock as well, if any */
 570   GST_LOCK (basesrc);
 571   if (basesrc->clock_id) {
 572     gst_clock_id_unschedule (basesrc->clock_id);
 573   }
 574   GST_UNLOCK (basesrc);
 575
 576   GST_DEBUG ("unlock done");
 577
 578   return result;
 579 }
 580
 581 static gboolean
 582 gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size)
 583 {
 584   GstBaseSrcClass *bclass;
 585   gboolean result = FALSE;
 586
 587   bclass = GST_BASESRC_GET_CLASS (basesrc);
 588   if (bclass->get_size)
 589     result = bclass->get_size (basesrc, size);
 590
 591   if (result)
 592     basesrc->size = *size;
 593
 594   return result;
 595 }
 596
 597 static gboolean
 598 gst_basesrc_is_seekable (GstBaseSrc * basesrc)
 599 {
 600   GstBaseSrcClass *bclass;
 601
 602   bclass = GST_BASESRC_GET_CLASS (basesrc);
 603
 604   /* check if we can seek */
 605   if (bclass->is_seekable)
 606     basesrc->seekable = bclass->is_seekable (basesrc);
 607   else
 608     basesrc->seekable = FALSE;
 609
 610   return basesrc->seekable;
 611 }
 612
 613 static gboolean
 614 gst_basesrc_start (GstBaseSrc * basesrc)
 615 {
 616   GstBaseSrcClass *bclass;
 617   gboolean result;
 618
 619   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 620     return TRUE;
 621
 622   bclass = GST_BASESRC_GET_CLASS (basesrc);
 623   if (bclass->start)
 624     result = bclass->start (basesrc);
 625   else
 626     result = TRUE;
 627
 628   if (!result)
 629     goto could_not_start;
 630
 631   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 632
 633   /* start in the beginning */
 634   basesrc->offset = 0;
 635   basesrc->segment_start = 0;
 636
 637   /* figure out the size */
 638   if (bclass->get_size) {
 639     result = bclass->get_size (basesrc, &basesrc->size);
 640     if (result == FALSE)
 641       basesrc->size = -1;
 642   } else {
 643     result = FALSE;
 644     basesrc->size = -1;
 645   }
 646
 647   GST_DEBUG ("size %d %lld", result, basesrc->size);
 648
 649   /* we always run to the end */
 650   basesrc->segment_end = -1;
 651
 652   /* check if we can seek, updates ->seekable */
 653   gst_basesrc_is_seekable (basesrc);
 654
 655   /* run typefind */
 656 #if 0
 657   if (basesrc->seekable) {
 658     GstCaps *caps;
 659
 660     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 661     gst_pad_set_caps (basesrc->srcpad, caps);
 662   }
 663 #endif
 664
 665   return TRUE;
 666
 667   /* ERROR */
 668 could_not_start:
 669   {
 670     GST_DEBUG_OBJECT (basesrc, "could not start");
 671     return FALSE;
 672   }
 673 }
 674
 675 static gboolean
 676 gst_basesrc_stop (GstBaseSrc * basesrc)
 677 {
 678   GstBaseSrcClass *bclass;
 679   gboolean result = TRUE;
 680
 681   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 682     return TRUE;
 683
 684   bclass = GST_BASESRC_GET_CLASS (basesrc);
 685   if (bclass->stop)
 686     result = bclass->stop (basesrc);
 687
 688   if (result)
 689     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 690
 691   return result;
 692 }
 693
 694 static gboolean
 695 gst_basesrc_activate (GstPad * pad, GstActivateMode mode)
 696 {
 697   gboolean result;
 698   GstBaseSrc *basesrc;
 699
 700   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 701
 702   /* prepare subclass first */
 703   switch (mode) {
 704     case GST_ACTIVATE_PUSH:
 705     case GST_ACTIVATE_PULL:
 706       result = gst_basesrc_start (basesrc);
 707       break;
 708     default:
 709       result = TRUE;
 710       break;
 711   }
 712   /* if that failed we can stop here */
 713   if (!result)
 714     goto error_start;
 715
 716   result = FALSE;
 717   switch (mode) {
 718     case GST_ACTIVATE_PUSH:
 719       result =
 720           gst_pad_start_task (pad, (GstTaskFunction) gst_basesrc_loop, pad);
 721       break;
 722     case GST_ACTIVATE_PULL:
 723       result = basesrc->seekable;
 724       if (!result)
 725         gst_basesrc_stop (basesrc);
 726       break;
 727     case GST_ACTIVATE_NONE:
 728       /* step 1, unblock clock sync (if any) */
 729       gst_basesrc_unlock (basesrc);
 730
 731       /* step 2, make sure streaming finishes */
 732       result = gst_pad_stop_task (pad);
 733       break;
 734   }
 735   return result;
 736
 737   /* ERROR */
 738 error_start:
 739   {
 740     GST_DEBUG_OBJECT (basesrc, "failed to start");
 741     return FALSE;
 742   }
 743 }
 744
 745 static GstElementStateReturn
 746 gst_basesrc_change_state (GstElement * element)
 747 {
 748   GstBaseSrc *basesrc;
 749   GstElementStateReturn result = GST_STATE_FAILURE;
 750   GstElementState transition;
 751
 752   basesrc = GST_BASESRC (element);
 753
 754   transition = GST_STATE_TRANSITION (element);
 755
 756   switch (transition) {
 757     case GST_STATE_NULL_TO_READY:
 758       break;
 759     case GST_STATE_READY_TO_PAUSED:
 760       break;
 761     case GST_STATE_PAUSED_TO_PLAYING:
 762       break;
 763     default:
 764       break;
 765   }
 766
 767   result = GST_ELEMENT_CLASS (parent_class)->change_state (element);
 768
 769   switch (transition) {
 770     case GST_STATE_PLAYING_TO_PAUSED:
 771       break;
 772     case GST_STATE_PAUSED_TO_READY:
 773       if (!gst_basesrc_stop (basesrc))
 774         result = GST_STATE_FAILURE;
 775       break;
 776     case GST_STATE_READY_TO_NULL:
 777       break;
 778     default:
 779       break;
 780   }
 781
 782   return result;
 783 }