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   basesrc->is_live = FALSE;
 168   basesrc->live_lock = g_mutex_new ();
 169   basesrc->live_cond = g_cond_new ();
 170
 171   /* hold ref to pad */
 172   basesrc->srcpad = pad;
 173   gst_element_add_pad (GST_ELEMENT (basesrc), pad);
 174
 175   basesrc->segment_start = -1;
 176   basesrc->segment_end = -1;
 177   basesrc->blocksize = DEFAULT_BLOCKSIZE;
 178   basesrc->clock_id = NULL;
 179
 180   GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 181 }
 182
 183 void
 184 gst_basesrc_set_live (GstBaseSrc * src, gboolean live)
 185 {
 186   GST_LIVE_LOCK (src);
 187   src->is_live = live;
 188   GST_LIVE_UNLOCK (src);
 189 }
 190
 191 gboolean
 192 gst_basesrc_is_live (GstBaseSrc * src)
 193 {
 194   gboolean result;
 195
 196   GST_LIVE_LOCK (src);
 197   result = src->is_live;
 198   GST_LIVE_UNLOCK (src);
 199
 200   return result;
 201 }
 202
 203 static void
 204 gst_basesrc_set_dataflow_funcs (GstBaseSrc * this)
 205 {
 206   GST_DEBUG ("updating dataflow functions");
 207
 208   if (this->has_loop)
 209     gst_pad_set_loop_function (this->srcpad, gst_basesrc_loop);
 210   else
 211     gst_pad_set_loop_function (this->srcpad, NULL);
 212
 213   if (this->has_getrange)
 214     gst_pad_set_getrange_function (this->srcpad, gst_basesrc_get_range);
 215   else
 216     gst_pad_set_getrange_function (this->srcpad, NULL);
 217 }
 218
 219 static gboolean
 220 gst_basesrc_query (GstPad * pad, GstQuery * query)
 221 {
 222   gboolean b;
 223   guint64 ui64;
 224   gint64 i64;
 225   GstBaseSrc *src;
 226
 227   src = GST_BASESRC (GST_PAD_PARENT (pad));
 228
 229   switch (GST_QUERY_TYPE (query)) {
 230     case GST_QUERY_POSITION:
 231     {
 232       GstFormat format;
 233
 234       gst_query_parse_position (query, &format, NULL, NULL);
 235       switch (format) {
 236         case GST_FORMAT_DEFAULT:
 237         case GST_FORMAT_BYTES:
 238           b = gst_basesrc_get_size (src, &ui64);
 239           /* better to make get_size take an int64 */
 240           i64 = b ? (gint64) ui64 : -1;
 241           gst_query_set_position (query, GST_FORMAT_BYTES, src->offset, i64);
 242           return TRUE;
 243         case GST_FORMAT_PERCENT:
 244           b = gst_basesrc_get_size (src, &ui64);
 245           i64 = GST_FORMAT_PERCENT_MAX;
 246           i64 *= b ? (src->offset / (gdouble) ui64) : 1.0;
 247           gst_query_set_position (query, GST_FORMAT_PERCENT,
 248               i64, GST_FORMAT_PERCENT_MAX);
 249           return TRUE;
 250         default:
 251           return FALSE;
 252       }
 253     }
 254
 255     case GST_QUERY_SEEKING:
 256       gst_query_set_seeking (query, GST_FORMAT_BYTES,
 257           src->seekable, src->segment_start, src->segment_end);
 258       return TRUE;
 259
 260     case GST_QUERY_FORMATS:
 261       gst_query_set_formats (query, 3, GST_FORMAT_DEFAULT,
 262           GST_FORMAT_BYTES, GST_FORMAT_PERCENT);
 263       return TRUE;
 264
 265     case GST_QUERY_LATENCY:
 266     case GST_QUERY_JITTER:
 267     case GST_QUERY_RATE:
 268     case GST_QUERY_CONVERT:
 269     default:
 270       return gst_pad_query_default (pad, query);
 271   }
 272 }
 273
 274 #if 0
 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 #endif
 289
 290 static gboolean
 291 gst_basesrc_do_seek (GstBaseSrc * src, GstEvent * event)
 292 {
 293   GstFormat format;
 294   gint64 offset;
 295
 296   format = GST_EVENT_SEEK_FORMAT (event);
 297
 298   /* get seek format */
 299   if (format == GST_FORMAT_DEFAULT)
 300     format = GST_FORMAT_BYTES;
 301   /* we can only seek bytes */
 302   if (format != GST_FORMAT_BYTES)
 303     return FALSE;
 304
 305   /* get seek positions */
 306   offset = GST_EVENT_SEEK_OFFSET (event);
 307   src->segment_loop = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
 308
 309   switch (GST_EVENT_SEEK_METHOD (event)) {
 310     case GST_SEEK_METHOD_SET:
 311       if (offset < 0)
 312         goto error;
 313       src->offset = MIN (offset, src->size);
 314       src->segment_start = src->offset;
 315       src->segment_end = MIN (GST_EVENT_SEEK_ENDOFFSET (event), src->size);
 316       GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
 317           src->offset);
 318       break;
 319     case GST_SEEK_METHOD_CUR:
 320       offset += src->offset;
 321       src->offset = CLAMP (offset, 0, src->size);
 322       src->segment_start = src->offset;
 323       src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 324       GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
 325           src->offset);
 326       break;
 327     case GST_SEEK_METHOD_END:
 328       if (offset > 0)
 329         goto error;
 330       offset = src->size + offset;
 331       src->offset = MAX (0, offset);
 332       src->segment_start = src->offset;
 333       src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
 334       GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
 335           src->offset);
 336       break;
 337     default:
 338       goto error;
 339   }
 340
 341   /* send flush start */
 342   gst_pad_push_event (src->srcpad, gst_event_new_flush (FALSE));
 343
 344   /* unblock streaming thread */
 345   gst_basesrc_unlock (src);
 346
 347   /* grab streaming lock */
 348   GST_STREAM_LOCK (src->srcpad);
 349
 350   /* send flush end */
 351   gst_pad_push_event (src->srcpad, gst_event_new_flush (TRUE));
 352
 353   /* now send discont */
 354   {
 355     GstEvent *event;
 356
 357     event = gst_event_new_discontinuous (1.0,
 358         GST_FORMAT_BYTES,
 359         (gint64) src->segment_start, (gint64) src->segment_end, NULL);
 360
 361     gst_pad_push_event (src->srcpad, event);
 362   }
 363
 364   /* and restart the task */
 365   gst_pad_start_task (src->srcpad, (GstTaskFunction) gst_basesrc_loop,
 366       src->srcpad);
 367   GST_STREAM_UNLOCK (src->srcpad);
 368
 369   gst_event_unref (event);
 370
 371   return TRUE;
 372
 373   /* ERROR */
 374 error:
 375   {
 376     GST_DEBUG_OBJECT (src, "seek error");
 377     gst_event_unref (event);
 378     return FALSE;
 379   }
 380 }
 381
 382 static gboolean
 383 gst_basesrc_event_handler (GstPad * pad, GstEvent * event)
 384 {
 385   GstBaseSrc *src;
 386   GstBaseSrcClass *bclass;
 387   gboolean result;
 388
 389   src = GST_BASESRC (GST_PAD_PARENT (pad));
 390   bclass = GST_BASESRC_GET_CLASS (src);
 391
 392   if (bclass->event)
 393     result = bclass->event (src, event);
 394
 395   switch (GST_EVENT_TYPE (event)) {
 396     case GST_EVENT_SEEK:
 397       return gst_basesrc_do_seek (src, event);
 398     case GST_EVENT_SIZE:
 399     {
 400       GstFormat format;
 401
 402       format = GST_EVENT_SIZE_FORMAT (event);
 403       if (format == GST_FORMAT_DEFAULT)
 404         format = GST_FORMAT_BYTES;
 405       /* we can only accept bytes */
 406       if (format != GST_FORMAT_BYTES)
 407         return FALSE;
 408
 409       src->blocksize = GST_EVENT_SIZE_VALUE (event);
 410       g_object_notify (G_OBJECT (src), "blocksize");
 411       break;
 412     }
 413     case GST_EVENT_FLUSH:
 414       /* cancel any blocking getrange */
 415       if (!GST_EVENT_FLUSH_DONE (event))
 416         gst_basesrc_unlock (src);
 417       break;
 418     default:
 419       break;
 420   }
 421   gst_event_unref (event);
 422
 423   return TRUE;
 424 }
 425
 426 static void
 427 gst_basesrc_set_property (GObject * object, guint prop_id, const GValue * value,
 428     GParamSpec * pspec)
 429 {
 430   GstBaseSrc *src;
 431
 432   src = GST_BASESRC (object);
 433
 434   switch (prop_id) {
 435     case PROP_BLOCKSIZE:
 436       src->blocksize = g_value_get_ulong (value);
 437       break;
 438     case PROP_HAS_LOOP:
 439       src->has_loop = g_value_get_boolean (value);
 440       gst_basesrc_set_dataflow_funcs (src);
 441       break;
 442     case PROP_HAS_GETRANGE:
 443       src->has_getrange = g_value_get_boolean (value);
 444       gst_basesrc_set_dataflow_funcs (src);
 445       break;
 446     default:
 447       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 448       break;
 449   }
 450 }
 451
 452 static void
 453 gst_basesrc_get_property (GObject * object, guint prop_id, GValue * value,
 454     GParamSpec * pspec)
 455 {
 456   GstBaseSrc *src;
 457
 458   src = GST_BASESRC (object);
 459
 460   switch (prop_id) {
 461     case PROP_BLOCKSIZE:
 462       g_value_set_ulong (value, src->blocksize);
 463       break;
 464     case PROP_HAS_LOOP:
 465       g_value_set_boolean (value, src->has_loop);
 466       break;
 467     case PROP_HAS_GETRANGE:
 468       g_value_set_boolean (value, src->has_getrange);
 469       break;
 470     default:
 471       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 472       break;
 473   }
 474 }
 475
 476 static GstFlowReturn
 477 gst_basesrc_get_range (GstPad * pad, guint64 offset, guint length,
 478     GstBuffer ** buf)
 479 {
 480   GstFlowReturn ret;
 481   GstBaseSrc *src;
 482   GstBaseSrcClass *bclass;
 483
 484   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 485   bclass = GST_BASESRC_GET_CLASS (src);
 486
 487   GST_LIVE_LOCK (src);
 488   if (src->is_live) {
 489     while (!src->live_running) {
 490       GST_DEBUG ("live source waiting for running state");
 491       GST_LIVE_WAIT (src);
 492       GST_DEBUG ("live source unlocked");
 493     }
 494   }
 495   GST_LIVE_UNLOCK (src);
 496
 497   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED))
 498     goto not_started;
 499
 500   if (!bclass->create)
 501     goto no_function;
 502
 503   /* check size */
 504   if (src->size != -1) {
 505     if (offset > src->size)
 506       goto unexpected_length;
 507
 508     if (offset + length > src->size) {
 509       if (bclass->get_size)
 510         bclass->get_size (src, &src->size);
 511
 512       if (offset + length > src->size) {
 513         length = src->size - offset;
 514       }
 515     }
 516   }
 517   if (length == 0)
 518     goto unexpected_length;
 519
 520   ret = bclass->create (src, offset, length, buf);
 521
 522   return ret;
 523
 524   /* ERROR */
 525 not_started:
 526   {
 527     GST_DEBUG_OBJECT (src, "getrange but not started");
 528     return GST_FLOW_WRONG_STATE;
 529   }
 530 no_function:
 531   {
 532     GST_DEBUG_OBJECT (src, "no create function");
 533     return GST_FLOW_ERROR;
 534   }
 535 unexpected_length:
 536   {
 537     GST_DEBUG_OBJECT (src, "unexpected length %u", length);
 538     return GST_FLOW_UNEXPECTED;
 539   }
 540 }
 541
 542 static gboolean
 543 gst_basesrc_check_get_range (GstPad * pad)
 544 {
 545   GstBaseSrc *src;
 546
 547   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 548
 549   if (!GST_FLAG_IS_SET (src, GST_BASESRC_STARTED)) {
 550     gst_basesrc_start (src);
 551     gst_basesrc_stop (src);
 552   }
 553
 554   return src->seekable;
 555 }
 556
 557 static void
 558 gst_basesrc_loop (GstPad * pad)
 559 {
 560   GstBaseSrc *src;
 561   GstBuffer *buf = NULL;
 562   GstFlowReturn ret;
 563
 564   src = GST_BASESRC (GST_OBJECT_PARENT (pad));
 565
 566   ret = gst_basesrc_get_range (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   return;
 577
 578 eos:
 579   {
 580     GST_DEBUG_OBJECT (src, "going to EOS");
 581     gst_pad_pause_task (pad);
 582     gst_pad_push_event (pad, gst_event_new (GST_EVENT_EOS));
 583     return;
 584   }
 585 pause:
 586   {
 587     GST_DEBUG_OBJECT (src, "pausing task");
 588     gst_pad_pause_task (pad);
 589     return;
 590   }
 591 }
 592
 593 static gboolean
 594 gst_basesrc_unlock (GstBaseSrc * basesrc)
 595 {
 596   GstBaseSrcClass *bclass;
 597   gboolean result = FALSE;
 598
 599   GST_DEBUG ("unlock");
 600   /* unblock whatever the subclass is doing */
 601   bclass = GST_BASESRC_GET_CLASS (basesrc);
 602   if (bclass->unlock)
 603     result = bclass->unlock (basesrc);
 604
 605   GST_DEBUG ("unschedule clock");
 606   /* and unblock the clock as well, if any */
 607   GST_LOCK (basesrc);
 608   if (basesrc->clock_id) {
 609     gst_clock_id_unschedule (basesrc->clock_id);
 610   }
 611   GST_UNLOCK (basesrc);
 612
 613   GST_DEBUG ("unlock done");
 614
 615   return result;
 616 }
 617
 618 static gboolean
 619 gst_basesrc_get_size (GstBaseSrc * basesrc, guint64 * size)
 620 {
 621   GstBaseSrcClass *bclass;
 622   gboolean result = FALSE;
 623
 624   bclass = GST_BASESRC_GET_CLASS (basesrc);
 625   if (bclass->get_size)
 626     result = bclass->get_size (basesrc, size);
 627
 628   if (result)
 629     basesrc->size = *size;
 630
 631   return result;
 632 }
 633
 634 static gboolean
 635 gst_basesrc_is_seekable (GstBaseSrc * basesrc)
 636 {
 637   GstBaseSrcClass *bclass;
 638
 639   bclass = GST_BASESRC_GET_CLASS (basesrc);
 640
 641   /* check if we can seek */
 642   if (bclass->is_seekable)
 643     basesrc->seekable = bclass->is_seekable (basesrc);
 644   else
 645     basesrc->seekable = FALSE;
 646
 647   return basesrc->seekable;
 648 }
 649
 650 static gboolean
 651 gst_basesrc_start (GstBaseSrc * basesrc)
 652 {
 653   GstBaseSrcClass *bclass;
 654   gboolean result;
 655
 656   if (GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 657     return TRUE;
 658
 659   bclass = GST_BASESRC_GET_CLASS (basesrc);
 660   if (bclass->start)
 661     result = bclass->start (basesrc);
 662   else
 663     result = TRUE;
 664
 665   if (!result)
 666     goto could_not_start;
 667
 668   GST_FLAG_SET (basesrc, GST_BASESRC_STARTED);
 669
 670   /* start in the beginning */
 671   basesrc->offset = 0;
 672   basesrc->segment_start = 0;
 673
 674   /* figure out the size */
 675   if (bclass->get_size) {
 676     result = bclass->get_size (basesrc, &basesrc->size);
 677     if (result == FALSE)
 678       basesrc->size = -1;
 679   } else {
 680     result = FALSE;
 681     basesrc->size = -1;
 682   }
 683
 684   GST_DEBUG ("size %d %lld", result, basesrc->size);
 685
 686   /* we always run to the end */
 687   basesrc->segment_end = -1;
 688
 689   /* check if we can seek, updates ->seekable */
 690   gst_basesrc_is_seekable (basesrc);
 691
 692   /* run typefind */
 693 #if 0
 694   if (basesrc->seekable) {
 695     GstCaps *caps;
 696
 697     caps = gst_type_find_helper (basesrc->srcpad, basesrc->size);
 698     gst_pad_set_caps (basesrc->srcpad, caps);
 699   }
 700 #endif
 701
 702   return TRUE;
 703
 704   /* ERROR */
 705 could_not_start:
 706   {
 707     GST_DEBUG_OBJECT (basesrc, "could not start");
 708     return FALSE;
 709   }
 710 }
 711
 712 static gboolean
 713 gst_basesrc_stop (GstBaseSrc * basesrc)
 714 {
 715   GstBaseSrcClass *bclass;
 716   gboolean result = TRUE;
 717
 718   if (!GST_FLAG_IS_SET (basesrc, GST_BASESRC_STARTED))
 719     return TRUE;
 720
 721   bclass = GST_BASESRC_GET_CLASS (basesrc);
 722   if (bclass->stop)
 723     result = bclass->stop (basesrc);
 724
 725   if (result)
 726     GST_FLAG_UNSET (basesrc, GST_BASESRC_STARTED);
 727
 728   return result;
 729 }
 730
 731 static gboolean
 732 gst_basesrc_activate (GstPad * pad, GstActivateMode mode)
 733 {
 734   gboolean result;
 735   GstBaseSrc *basesrc;
 736
 737   basesrc = GST_BASESRC (GST_OBJECT_PARENT (pad));
 738
 739   /* prepare subclass first */
 740   switch (mode) {
 741     case GST_ACTIVATE_PUSH:
 742     case GST_ACTIVATE_PULL:
 743       result = gst_basesrc_start (basesrc);
 744       break;
 745     default:
 746       result = TRUE;
 747       break;
 748   }
 749   /* if that failed we can stop here */
 750   if (!result)
 751     goto error_start;
 752
 753   result = FALSE;
 754   switch (mode) {
 755     case GST_ACTIVATE_PUSH:
 756       result =
 757           gst_pad_start_task (pad, (GstTaskFunction) gst_basesrc_loop, pad);
 758       break;
 759     case GST_ACTIVATE_PULL:
 760       result = basesrc->seekable;
 761       if (!result)
 762         gst_basesrc_stop (basesrc);
 763       break;
 764     case GST_ACTIVATE_NONE:
 765       GST_LIVE_LOCK (basesrc);
 766       basesrc->live_running = TRUE;
 767       GST_LIVE_SIGNAL (basesrc);
 768       GST_LIVE_UNLOCK (basesrc);
 769
 770       /* step 1, unblock clock sync (if any) */
 771       gst_basesrc_unlock (basesrc);
 772
 773       /* step 2, make sure streaming finishes */
 774       result = gst_pad_stop_task (pad);
 775       break;
 776   }
 777   return result;
 778
 779   /* ERROR */
 780 error_start:
 781   {
 782     GST_DEBUG_OBJECT (basesrc, "failed to start");
 783     return FALSE;
 784   }
 785 }
 786
 787 static GstElementStateReturn
 788 gst_basesrc_change_state (GstElement * element)
 789 {
 790   GstBaseSrc *basesrc;
 791   GstElementStateReturn result = GST_STATE_SUCCESS;
 792   GstElementStateReturn presult;
 793   GstElementState transition;
 794
 795   basesrc = GST_BASESRC (element);
 796
 797   transition = GST_STATE_TRANSITION (element);
 798
 799   switch (transition) {
 800     case GST_STATE_NULL_TO_READY:
 801       break;
 802     case GST_STATE_READY_TO_PAUSED:
 803       GST_LIVE_LOCK (element);
 804       if (basesrc->is_live) {
 805         result = GST_STATE_NO_PREROLL;
 806         basesrc->live_running = FALSE;
 807       }
 808       GST_LIVE_UNLOCK (element);
 809       break;
 810     case GST_STATE_PAUSED_TO_PLAYING:
 811       GST_LIVE_LOCK (element);
 812       basesrc->live_running = TRUE;
 813       GST_LIVE_SIGNAL (element);
 814       GST_LIVE_UNLOCK (element);
 815       break;
 816     default:
 817       break;
 818   }
 819
 820   if ((presult = GST_ELEMENT_CLASS (parent_class)->change_state (element)) !=
 821       GST_STATE_SUCCESS)
 822     return presult;
 823
 824   switch (transition) {
 825     case GST_STATE_PLAYING_TO_PAUSED:
 826       GST_LIVE_LOCK (element);
 827       if (basesrc->is_live) {
 828         result = GST_STATE_NO_PREROLL;
 829         basesrc->live_running = FALSE;
 830       }
 831       GST_LIVE_UNLOCK (element);
 832       break;
 833     case GST_STATE_PAUSED_TO_READY:
 834       if (!gst_basesrc_stop (basesrc))
 835         result = GST_STATE_FAILURE;
 836       break;
 837     case GST_STATE_READY_TO_NULL:
 838       break;
 839     default:
 840       break;
 841   }
 842
 843   return result;
 844 }