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