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_base_src_debug);
  38 #define GST_CAT_DEFAULT gst_base_src_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_base_src_base_init (gpointer g_class);
  58 static void gst_base_src_class_init (GstBaseSrcClass * klass);
  59 static void gst_base_src_init (GstBaseSrc * src, gpointer g_class);
  60
  61 GType
  62 gst_base_src_get_type (void)
  63 {
  64   static GType base_src_type = 0;
  65
  66   if (!base_src_type) {
  67     static const GTypeInfo base_src_info = {
  68       sizeof (GstBaseSrcClass),
  69       (GBaseInitFunc) gst_base_src_base_init,
  70       NULL,
  71       (GClassInitFunc) gst_base_src_class_init,
  72       NULL,
  73       NULL,
  74       sizeof (GstBaseSrc),
  75       0,
  76       (GInstanceInitFunc) gst_base_src_init,
  77     };
  78
  79     base_src_type = g_type_register_static (GST_TYPE_ELEMENT,
  80         "GstBaseSrc", &base_src_info, G_TYPE_FLAG_ABSTRACT);
  81   }
  82   return base_src_type;
  83 }
  84
  85 static gboolean gst_base_src_activate_push (GstPad * pad, gboolean active);
  86 static gboolean gst_base_src_activate_pull (GstPad * pad, gboolean active);
  87 static void gst_base_src_set_property (GObject * object, guint prop_id,
  88     const GValue * value, GParamSpec * pspec);
  89 static void gst_base_src_get_property (GObject * object, guint prop_id,
  90     GValue * value, GParamSpec * pspec);
  91 static gboolean gst_base_src_event_handler (GstPad * pad, GstEvent * event);
  92
  93 static gboolean gst_base_src_query (GstPad * pad, GstQuery * query);
  94
  95 #if 0
  96 static const GstEventMask *gst_base_src_get_event_mask (GstPad * pad);
  97 #endif
  98
  99 static gboolean gst_base_src_unlock (GstBaseSrc * basesrc);
 100 static gboolean gst_base_src_get_size (GstBaseSrc * basesrc, guint64 * size);
 101 static gboolean gst_base_src_start (GstBaseSrc * basesrc);
 102 static gboolean gst_base_src_stop (GstBaseSrc * basesrc);
 103
 104 static GstElementStateReturn gst_base_src_change_state (GstElement * element);
 105
 106 static void gst_base_src_set_dataflow_funcs (GstBaseSrc * this);
 107 static void gst_base_src_loop (GstPad * pad);
 108 static gboolean gst_base_src_check_get_range (GstPad * pad);
 109 static GstFlowReturn gst_base_src_get_range (GstPad * pad, guint64 offset,
 110     guint length, GstBuffer ** buf);
 111
 112 static void
 113 gst_base_src_base_init (gpointer g_class)
 114 {
 115   GST_DEBUG_CATEGORY_INIT (gst_base_src_debug, "basesrc", 0, "basesrc element");
 116 }
 117
 118 static void
 119 gst_base_src_class_init (GstBaseSrcClass * klass)
 120 {
 121   GObjectClass *gobject_class;
 122   GstElementClass *gstelement_class;
 123
 124   gobject_class = (GObjectClass *) klass;
 125   gstelement_class = (GstElementClass *) klass;
 126
 127   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 128
 129   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_base_src_set_property);
 130   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_base_src_get_property);
 131
 132   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BLOCKSIZE,
 133       g_param_spec_ulong ("blocksize", "Block size",
 134           "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
 135           G_PARAM_READWRITE));
 136
 137   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HAS_LOOP,
 138       g_param_spec_boolean ("has-loop", "Has loop function",
 139           "True if the element should expose a loop function", TRUE,
 140           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 141
 142   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_HAS_GETRANGE,
 143       g_param_spec_boolean ("has-getrange", "Has getrange function",
 144           "True if the element should expose a getrange function", TRUE,
 145           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 146
 147   gstelement_class->change_state =
 148       GST_DEBUG_FUNCPTR (gst_base_src_change_state);
 149 }
 150
 151 static void
 152 gst_base_src_init (GstBaseSrc * basesrc, gpointer g_class)
 153 {
 154   GstPad *pad;
 155   GstPadTemplate *pad_template;
 156
 157   pad_template =
 158       gst_element_class_get_pad_template (GST_ELEMENT_CLASS (g_class), "src");
 159   g_return_if_fail (pad_template != NULL);
 160
 161   pad = gst_pad_new_from_template (pad_template, "src");
 162
 163   gst_pad_set_activatepush_function (pad, gst_base_src_activate_push);
 164   gst_pad_set_activatepull_function (pad, gst_base_src_activate_pull);
 165   gst_pad_set_event_function (pad, gst_base_src_event_handler);
 166   gst_pad_set_query_function (pad, gst_base_src_query);
 167
 168   gst_pad_set_checkgetrange_function (pad, gst_base_src_check_get_range);
 169
 170   basesrc->is_live = FALSE;
 171   basesrc->live_lock = g_mutex_new ();
 172   basesrc->live_cond = g_cond_new ();
 173
 174   /* hold ref to pad */
 175   basesrc->srcpad = pad;
 176   gst_element_add_pad (GST_ELEMENT (basesrc), pad);
 177
 178   basesrc->segment_start = -1;
 179   basesrc->segment_end = -1;
 180   basesrc->blocksize = DEFAULT_BLOCKSIZE;
 181   basesrc->clock_id = NULL;
 182
 183   GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 184 }
 185
 186 void
 187 gst_base_src_set_live (GstBaseSrc * src, gboolean live)
 188 {
 189   GST_LIVE_LOCK (src);
 190   src->is_live = live;
 191   GST_LIVE_UNLOCK (src);
 192 }
 193
 194 gboolean
 195 gst_base_src_is_live (GstBaseSrc * src)
 196 {
 197   gboolean result;
 198
 199   GST_LIVE_LOCK (src);
 200   result = src->is_live;
 201   GST_LIVE_UNLOCK (src);
 202
 203   return result;
 204 }
 205
 206 static void
 207 gst_base_src_set_dataflow_funcs (GstBaseSrc * this)
 208 {
 209   GST_DEBUG ("updating dataflow functions");
 210
 211   if (this->has_getrange)
 212     gst_pad_set_getrange_function (this->srcpad, gst_base_src_get_range);
 213   else
 214     gst_pad_set_getrange_function (this->srcpad, NULL);
 215 }
 216
 217 static gboolean
 218 gst_base_src_query (GstPad * pad, GstQuery * query)
 219 {
 220   gboolean b;
 221   guint64 ui64;
 222   gint64 i64;
 223   GstBaseSrc *src;
 224
 225   src = GST_BASESRC (GST_PAD_PARENT (pad));
 226
 227   switch (GST_QUERY_TYPE (query)) {
 228     case GST_QUERY_POSITION:
 229     {
 230       GstFormat format;
 231
 232       gst_query_parse_position (query, &format, NULL, NULL);
 233       switch (format) {
 234         case GST_FORMAT_DEFAULT:
 235         case GST_FORMAT_BYTES:
 236           b = gst_base_src_get_size (src, &ui64);
 237           /* better to make get_size take an int64 */
 238           i64 = b ? (gint64) ui64 : -1;
 239           gst_query_set_position (query, GST_FORMAT_BYTES, src->offset, i64);
 240           return TRUE;
 241         case GST_FORMAT_PERCENT:
 242           b = gst_base_src_get_size (src, &ui64);
 243           i64 = GST_FORMAT_PERCENT_MAX;
 244           i64 *= b ? (src->offset / (gdouble) ui64) : 1.0;
 245           gst_query_set_position (query, GST_FORMAT_PERCENT,
 246               i64, GST_FORMAT_PERCENT_MAX);
 247           return TRUE;
 248         default:
 249           return FALSE;
 250       }
 251     }
 252
 253     case GST_QUERY_SEEKING:
 254       gst_query_set_seeking (query, GST_FORMAT_BYTES,
 255           src->seekable, src->segment_start, src->segment_end);
 256       return TRUE;
 257
 258     case GST_QUERY_FORMATS:
 259       gst_query_set_formats (query, 3, GST_FORMAT_DEFAULT,
 260           GST_FORMAT_BYTES, GST_FORMAT_PERCENT);
 261       return TRUE;
 262
 263     case GST_QUERY_LATENCY:
 264     case GST_QUERY_JITTER:
 265     case GST_QUERY_RATE:
 266     case GST_QUERY_CONVERT:
 267     default:
 268       return gst_pad_query_default (pad, query);
 269   }
 270 }
 271
 272 #if 0
 273 static const GstEventMask *
 274 gst_base_src_get_event_mask (GstPad * pad)
 275 {
 276   static const GstEventMask masks[] = {
 277     {GST_EVENT_SEEK, GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_SET |
 278           GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH |
 279           GST_SEEK_FLAG_SEGMENT_LOOP},
 280     {GST_EVENT_FLUSH, 0},
 281     {GST_EVENT_SIZE, 0},
 282     {0, 0},
 283   };
 284   return masks;
 285 }
 286 #endif
 287
 288 static gboolean
 289 gst_base_src_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_loop = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
 306
 307   switch (GST_EVENT_SEEK_METHOD (event)) {
 308     case GST_SEEK_METHOD_SET:
 309       if (offset < 0)
 310         goto error;
 311       src->offset = MIN (offset, src->size);
 312       src->segment_start = src->offset;
 313       src->segment_end = MIN (GST_EVENT_SEEK_ENDOFFSET (event), src->size);
 314       GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
 315           src->offset);
 316       break;
 317     case GST_SEEK_METHOD_CUR:
 318       offset += src->offset;
 319       src->offset = CLAMP (offset, 0, src->size);
 320       src->segment_start = src->offset;
 321       src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 322       GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
 323           src->offset);
 324       break;
 325     case GST_SEEK_METHOD_END:
 326       if (offset > 0)
 327         goto error;
 328       offset = src->size + offset;
 329       src->offset = MAX (0, offset);
 330       src->segment_start = src->offset;
 331       src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 332       GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
 333           src->offset);
 334       break;
 335     default:
 336       goto error;
 337   }
 338
 339   /* send flush start */
 340   gst_pad_push_event (src->srcpad, gst_event_new_flush (FALSE));
 341
 342   /* unblock streaming thread */
 343   gst_base_src_unlock (src);
 344
 345   /* grab streaming lock */
 346   GST_STREAM_LOCK (src->srcpad);
 347
 348   /* send flush end */
 349   gst_pad_push_event (src->srcpad, gst_event_new_flush (TRUE));
 350
 351   /* now send discont */
 352   {
 353     GstEvent *event;
 354
 355     event = gst_event_new_discontinuous (1.0,
 356         GST_FORMAT_BYTES,
 357         (gint64) src->segment_start, (gint64) src->segment_end, NULL);
 358
 359     gst_pad_push_event (src->srcpad, event);
 360   }
 361
 362   /* and restart the task */
 363   gst_pad_start_task (src->srcpad, (GstTaskFunction) gst_base_src_loop,
 364       src->srcpad);
 365   GST_STREAM_UNLOCK (src->srcpad);
 366
 367   gst_event_unref (event);
 368
 369   return TRUE;
 370
 371   /* ERROR */
 372 error:
 373   {
 374     GST_DEBUG_OBJECT (src, "seek error");
 375     gst_event_unref (event);
 376     return FALSE;
 377   }
 378 }
 379
 380 static gboolean
 381 gst_base_src_event_handler (GstPad * pad, GstEvent * event)
 382 {
 383   GstBaseSrc *src;
 384   GstBaseSrcClass *bclass;
 385   gboolean result;
 386
 387   src = GST_BASESRC (GST_PAD_PARENT (pad));
 388   bclass = GST_BASESRC_GET_CLASS (src);
 389
 390   if (bclass->event)
 391     result = bclass->event (src, event);
 392
 393   switch (GST_EVENT_TYPE (event)) {
 394     case GST_EVENT_SEEK:
 395       return gst_base_src_do_seek (src, event);
 396     case GST_EVENT_SIZE:
 397     {
 398       GstFormat format;
 399
 400       format = GST_EVENT_SIZE_FORMAT (event);
 401       if (format == GST_FORMAT_DEFAULT)
 402         format = GST_FORMAT_BYTES;
 403       /* we can only accept bytes */
 404       if (format != GST_FORMAT_BYTES)
 405         return FALSE;
 406
 407       src->blocksize = GST_EVENT_SIZE_VALUE (event);
 408       g_object_notify (G_OBJECT (src), "blocksize");
 409       break;
 410     }
 411     case GST_EVENT_FLUSH:
 412       /* cancel any blocking getrange */
 413       if (!GST_EVENT_FLUSH_DONE (event))
 414         gst_base_src_unlock (src);
 415       break;
 416     default:
 417       break;
 418   }
 419   gst_event_unref (event);
 420
 421   return TRUE;
 422 }
 423
 424 static void
 425 gst_base_src_set_property (GObject * object, guint prop_id,
 426     const GValue * value, GParamSpec * pspec)
 427 {
 428   GstBaseSrc *src;
 429
 430   src = GST_BASESRC (object);
 431
 432   switch (prop_id) {
 433     case PROP_BLOCKSIZE:
 434       src->blocksize = g_value_get_ulong (value);
 435       break;
 436     case PROP_HAS_LOOP:
 437       src->has_loop = g_value_get_boolean (value);
 438       gst_base_src_set_dataflow_funcs (src);
 439       break;
 440     case PROP_HAS_GETRANGE:
 441       src->has_getrange = g_value_get_boolean (value);
 442       gst_base_src_set_dataflow_funcs (src);
 443       break;
 444     default:
 445       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 446       break;
 447   }
 448 }
 449
 450 static void
 451 gst_base_src_get_property (GObject * object, guint prop_id, GValue * value,
 452     GParamSpec * pspec)
 453 {
 454   GstBaseSrc *src;
 455
 456   src = GST_BASESRC (object);
 457
 458   switch (prop_id) {
 459     case PROP_BLOCKSIZE:
 460       g_value_set_ulong (value, src->blocksize);
 461       break;
 462     case PROP_HAS_LOOP:
 463       g_value_set_boolean (value, src->has_loop);
 464       break;
 465     case PROP_HAS_GETRANGE:
 466       g_value_set_boolean (value, src->has_getrange);
 467       break;
 468     default:
 469       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 470       break;
 471   }
 472 }
 473
 474 static GstFlowReturn
 475 gst_base_src_get_range (GstPad * pad, guint64 offset, guint length,
 476     GstBuffer ** buf)
 477 {
 478   GstFlowReturn ret;
 479   GstBaseSrc *src;
 480   GstBaseSrcClass *bclass;
 481
 482   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 483   bclass = GST_BASESRC_GET_CLASS (src);
 484
 485   GST_LIVE_LOCK (src);
 486   if (src->is_live) {
 487     while (!src->live_running) {
 488       GST_DEBUG ("live source waiting for running state");
 489       GST_LIVE_WAIT (src);
 490       GST_DEBUG ("live source unlocked");
 491     }
 492   }
 493   GST_LIVE_UNLOCK (src);
 494
 495   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED))
 496     goto not_started;
 497
 498   if (!bclass->create)
 499     goto no_function;
 500
 501   /* check size */
 502   if (src->size != -1) {
 503     if (offset > src->size)
 504       goto unexpected_length;
 505
 506     if (offset + length > src->size) {
 507       if (bclass->get_size)
 508         bclass->get_size (src, &src->size);
 509
 510       if (offset + length > src->size) {
 511         length = src->size - offset;
 512       }
 513     }
 514   }
 515   if (length == 0)
 516     goto unexpected_length;
 517
 518   ret = bclass->create (src, offset, length, buf);
 519
 520   return ret;
 521
 522   /* ERROR */
 523 not_started:
 524   {
 525     GST_DEBUG_OBJECT (src, "getrange but not started");
 526     return GST_FLOW_WRONG_STATE;
 527   }
 528 no_function:
 529   {
 530     GST_DEBUG_OBJECT (src, "no create function");
 531     return GST_FLOW_ERROR;
 532   }
 533 unexpected_length:
 534   {
 535     GST_DEBUG_OBJECT (src, "unexpected length %u", length);
 536     return GST_FLOW_UNEXPECTED;
 537   }
 538 }
 539
 540 static gboolean
 541 gst_base_src_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_base_src_start (src);
 549     gst_base_src_stop (src);
 550   }
 551
 552   return src->seekable;
 553 }
 554
 555 static void
 556 gst_base_src_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   ret = gst_base_src_get_range (pad, src->offset, src->blocksize, &buf);
 565   if (ret != GST_FLOW_OK)
 566     goto eos;
 567
 568   src->offset += GST_BUFFER_SIZE (buf);
 569
 570   ret = gst_pad_push (pad, buf);
 571   if (ret != GST_FLOW_OK)
 572     goto pause;
 573
 574   return;
 575
 576 eos:
 577   {
 578     GST_DEBUG_OBJECT (src, "going to EOS");
 579     gst_pad_pause_task (pad);
 580     gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
 581     return;
 582   }
 583 pause:
 584   {
 585     GST_DEBUG_OBJECT (src, "pausing task");
 586     gst_pad_pause_task (pad);
 587     return;
 588   }
 589 }
 590
 591 static gboolean
 592 gst_base_src_unlock (GstBaseSrc * basesrc)
 593 {
 594   GstBaseSrcClass *bclass;
 595   gboolean result = FALSE;
 596
 597   GST_DEBUG ("unlock");
 598   /* unblock whatever the subclass is doing */
 599   bclass = GST_BASESRC_GET_CLASS (basesrc);
 600   if (bclass->unlock)
 601     result = bclass->unlock (basesrc);
 602
 603   GST_DEBUG ("unschedule clock");
 604   /* and unblock the clock as well, if any */
 605   GST_LOCK (basesrc);
 606   if (basesrc->clock_id) {
 607     gst_clock_id_unschedule (basesrc->clock_id);
 608   }
 609   GST_UNLOCK (basesrc);
 610
 611   GST_DEBUG ("unlock done");
 612
 613   return result;
 614 }
 615
 616 static gboolean
 617 gst_base_src_get_size (GstBaseSrc * basesrc, guint64 * size)
 618 {
 619   GstBaseSrcClass *bclass;
 620   gboolean result = FALSE;
 621
 622   bclass = GST_BASESRC_GET_CLASS (basesrc);
 623   if (bclass->get_size)
 624     result = bclass->get_size (basesrc, size);
 625
 626   if (result)
 627     basesrc->size = *size;
 628
 629   return result;
 630 }
 631
 632 static gboolean
 633 gst_base_src_is_seekable (GstBaseSrc * basesrc)
 634 {
 635   GstBaseSrcClass *bclass;
 636
 637   bclass = GST_BASESRC_GET_CLASS (basesrc);
 638
 639   /* check if we can seek */
 640   if (bclass->is_seekable)
 641     basesrc->seekable = bclass->is_seekable (basesrc);
 642   else
 643     basesrc->seekable = FALSE;
 644
 645   return basesrc->seekable;
 646 }
 647
 648 static gboolean
 649 gst_base_src_start (GstBaseSrc * basesrc)
 650 {
 651   GstBaseSrcClass *bclass;
 652   gboolean result;
 653
 654   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 655     return TRUE;
 656
 657   bclass = GST_BASESRC_GET_CLASS (basesrc);
 658   if (bclass->start)
 659     result = bclass->start (basesrc);
 660   else
 661     result = TRUE;
 662
 663   if (!result)
 664     goto could_not_start;
 665
 666   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 667
 668   /* start in the beginning */
 669   basesrc->offset = 0;
 670   basesrc->segment_start = 0;
 671
 672   /* figure out the size */
 673   if (bclass->get_size) {
 674     result = bclass->get_size (basesrc, &basesrc->size);
 675     if (result == FALSE)
 676       basesrc->size = -1;
 677   } else {
 678     result = FALSE;
 679     basesrc->size = -1;
 680   }
 681
 682   GST_DEBUG ("size %d %lld", result, basesrc->size);
 683
 684   /* we always run to the end */
 685   basesrc->segment_end = -1;
 686
 687   /* check if we can seek, updates ->seekable */
 688   gst_base_src_is_seekable (basesrc);
 689
 690   /* run typefind */
 691 #if 0
 692   if (basesrc->seekable) {
 693     GstCaps *caps;
 694
 695     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 696     gst_pad_set_caps (basesrc->srcpad, caps);
 697   }
 698 #endif
 699
 700   return TRUE;
 701
 702   /* ERROR */
 703 could_not_start:
 704   {
 705     GST_DEBUG_OBJECT (basesrc, "could not start");
 706     return FALSE;
 707   }
 708 }
 709
 710 static gboolean
 711 gst_base_src_stop (GstBaseSrc * basesrc)
 712 {
 713   GstBaseSrcClass *bclass;
 714   gboolean result = TRUE;
 715
 716   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 717     return TRUE;
 718
 719   bclass = GST_BASESRC_GET_CLASS (basesrc);
 720   if (bclass->stop)
 721     result = bclass->stop (basesrc);
 722
 723   if (result)
 724     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 725
 726   return result;
 727 }
 728
 729 static gboolean
 730 gst_base_src_deactivate (GstBaseSrc * basesrc, GstPad * pad)
 731 {
 732   gboolean result;
 733
 734   GST_LIVE_LOCK (basesrc);
 735   basesrc->live_running = TRUE;
 736   GST_LIVE_SIGNAL (basesrc);
 737   GST_LIVE_UNLOCK (basesrc);
 738
 739   /* step 1, unblock clock sync (if any) */
 740   gst_base_src_unlock (basesrc);
 741
 742   /* step 2, make sure streaming finishes */
 743   result = gst_pad_stop_task (pad);
 744
 745   return result;
 746 }
 747
 748 static gboolean
 749 gst_base_src_activate_push (GstPad * pad, gboolean active)
 750 {
 751   GstBaseSrc *basesrc;
 752
 753   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 754
 755   /* prepare subclass first */
 756   if (active) {
 757     if (!gst_base_src_start (basesrc))
 758       goto error_start;
 759
 760     return gst_pad_start_task (pad, (GstTaskFunction) gst_base_src_loop, pad);
 761   } else {
 762     return gst_base_src_deactivate (basesrc, pad);
 763   }
 764
 765 error_start:
 766   {
 767     GST_DEBUG_OBJECT (basesrc, "failed to start");
 768     return FALSE;
 769   }
 770 }
 771
 772 static gboolean
 773 gst_base_src_activate_pull (GstPad * pad, gboolean active)
 774 {
 775   GstBaseSrc *basesrc;
 776
 777   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 778
 779   /* prepare subclass first */
 780   if (active) {
 781     if (!gst_base_src_start (basesrc))
 782       goto error_start;
 783
 784     if (!basesrc->seekable) {
 785       gst_base_src_stop (basesrc);
 786       return FALSE;
 787     }
 788
 789     return TRUE;
 790   } else {
 791     return gst_base_src_deactivate (basesrc, pad);
 792   }
 793
 794 error_start:
 795   {
 796     GST_DEBUG_OBJECT (basesrc, "failed to start");
 797     return FALSE;
 798   }
 799 }
 800
 801 static GstElementStateReturn
 802 gst_base_src_change_state (GstElement * element)
 803 {
 804   GstBaseSrc *basesrc;
 805   GstElementStateReturn result = GST_STATE_SUCCESS;
 806   GstElementStateReturn presult;
 807   GstElementState transition;
 808
 809   basesrc = GST_BASESRC (element);
 810
 811   transition = GST_STATE_TRANSITION (element);
 812
 813   switch (transition) {
 814     case GST_STATE_NULL_TO_READY:
 815       break;
 816     case GST_STATE_READY_TO_PAUSED:
 817       GST_LIVE_LOCK (element);
 818       if (basesrc->is_live) {
 819         result = GST_STATE_NO_PREROLL;
 820         basesrc->live_running = FALSE;
 821       }
 822       GST_LIVE_UNLOCK (element);
 823       break;
 824     case GST_STATE_PAUSED_TO_PLAYING:
 825       GST_LIVE_LOCK (element);
 826       basesrc->live_running = TRUE;
 827       GST_LIVE_SIGNAL (element);
 828       GST_LIVE_UNLOCK (element);
 829       break;
 830     default:
 831       break;
 832   }
 833
 834   if ((presult = GST_ELEMENT_CLASS (parent_class)->change_state (element)) !=
 835       GST_STATE_SUCCESS)
 836     return presult;
 837
 838   switch (transition) {
 839     case GST_STATE_PLAYING_TO_PAUSED:
 840       GST_LIVE_LOCK (element);
 841       if (basesrc->is_live) {
 842         result = GST_STATE_NO_PREROLL;
 843         basesrc->live_running = FALSE;
 844       }
 845       GST_LIVE_UNLOCK (element);
 846       break;
 847     case GST_STATE_PAUSED_TO_READY:
 848       if (!gst_base_src_stop (basesrc))
 849         result = GST_STATE_FAILURE;
 850       break;
 851     case GST_STATE_READY_TO_NULL:
 852       break;
 853     default:
 854       break;
 855   }
 856
 857   return result;
 858 }