examples: add an example to show looping using segments

Fixes #339772.

diff --git a/examples/segments.py b/examples/segments.py
new file mode 100755 (executable)
index 0000000..6ce3cfb
--- /dev/null
+++ b/examples/segments.py
@@ -0,0 +1,198 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Segments.py
+# Copyright (C) 2006 Artem Popov <artfwo@gmail.com>
+#
+# This example demonstrates segment seeking
+# and seamless looping within playbin.
+
+import pygst
+pygst.require ("0.10")
+import gst
+
+import pygtk
+pygtk.require ("2.0")
+import gobject
+
+class Looper (gobject.GObject):
+       __gproperties__ = {
+               "loop": (gobject.TYPE_BOOLEAN,
+                       "loop",
+                       "Whether to loop the segment",
+                       False,
+                       gobject.PARAM_READWRITE),
+               "start-pos": (gobject.TYPE_UINT64,
+                       "start position",
+                       "The segment start marker",
+                       0,
+                       0xfffffffffffffff, # max long possible
+                       0,
+                       gobject.PARAM_READWRITE),
+               "stop-pos": (gobject.TYPE_UINT64,
+                       "stop position",
+                       "The segment stop marker",
+                       0,
+                       0xfffffffffffffff, # max long possible
+                       0,
+                       gobject.PARAM_READWRITE),
+       } # __gproperties__
+       
+       __gsignals__ = {
+               "stopped": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()),
+               "position-updated": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_FLOAT,)),
+               "error": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
+       } # __gsignals__
+       
+       def __init__ (self, location = None):
+               gobject.GObject.__init__ (self)
+               
+               self.__playbin = gst.element_factory_make ("playbin")
+               self.__playbin.props.video_sink = gst.element_factory_make ("fakesink")
+               
+               bus = self.__playbin.get_bus ()
+               bus.add_watch (self.__on_bus_message)
+               
+               self.__loop = False
+               self.__start_pos = 0
+               self.__stop_pos = 0
+               
+               self.__timeout_id = 0
+               
+               if location:
+                       self.load (location)
+       
+       def load (self, location):
+               self.__playbin.props.uri = location
+               self.__start_position = 0
+               self.__stop_position = 0
+       
+       def set_segment (self, start, stop):
+               self.props.start_pos = start
+               self.props.stop_pos = stop
+       
+       def play (self):
+               if not (self.__start_pos or self.__stop_pos):
+                       raise RuntimeError, "Cannot start playback, segment was not set!"
+               
+               self.__playbin.set_state (gst.STATE_PLAYING)
+       
+       def stop (self, silent = False):
+               self.__playbin.set_state (gst.STATE_NULL)
+               if not silent:
+                       self.emit ("stopped")
+       
+       def do_get_property (self, property):
+               if property.name == "loop":
+                       return self.__loop
+               elif property.name == "start-pos":
+                       return self.__start_pos
+               elif property.name == "stop-pos":
+                       return self.__stop_pos
+               else:
+                       raise AttributeError, "Unknown property %s" % property.name
+       
+       def do_set_property (self, property, value):
+               if property.name == "loop":
+                       self.__loop = value
+               elif property.name == "start-pos":
+                       self.__start_pos = value
+               elif property.name == "stop-pos":
+                       self.__stop_pos = value
+               else:
+                       raise AttributeError, "Unknown property %s" % property.name
+       
+       def do_stopped (self):
+               if self.__timeout_id:
+                       gobject.source_remove (self.__timeout_id)
+                       self.__timeout_id = 0
+       
+       def __seek (self, start, stop, flush):
+               flags = gst.SEEK_FLAG_SEGMENT | gst.SEEK_FLAG_ACCURATE
+               if flush:
+                       flags = flags | gst.SEEK_FLAG_FLUSH
+               self.__playbin.seek (1.0, gst.FORMAT_TIME, flags,
+                       gst.SEEK_TYPE_SET, start,
+                       gst.SEEK_TYPE_SET, stop)
+       
+       def __on_timeout (self):
+               position = self.__playbin.query_position (gst.FORMAT_TIME) [0]
+               self.emit ("position-updated", float (position))
+               return True
+       
+       def __on_bus_message (self, bus, message):
+               if message.type == gst.MESSAGE_ERROR:
+                       error, debug = message.parse_error ()
+                       self.stop () # this looks neccessary here
+                       self.emit ("error", (error, debug))
+               
+               elif message.type == gst.MESSAGE_NEW_CLOCK:
+                       # we connect the timeout handler here to be sure that further queries succeed
+                       interval = int ((self.__stop_position - self.__start_position) / (2 * gst.SECOND) + 50)
+                       self.__timeout_id = gobject.timeout_add (interval, self.__on_timeout)
+               
+               elif message.type == gst.MESSAGE_STATE_CHANGED:
+                       old_state, new_state, pending = message.parse_state_changed ()
+                       if old_state == gst.STATE_READY and new_state == gst.STATE_PAUSED and message.src == self.__playbin:
+                               self.__seek (self.__start_pos, self.__stop_pos, True)
+               
+               elif message.type == gst.MESSAGE_SEGMENT_DONE:
+                       if self.__loop:
+                               self.__seek (self.__start_pos, self.__stop_pos, False)
+                       else:
+                               src = self.__playbin.get_property ("source")
+                               pad = src.get_pad ('src')
+                               pad.push_event (gst.event_new_eos ())
+                               
+                               # this is the good old way:
+                               #
+                               # pads = src.src_pads ()
+                               # while True:
+                               #       try:
+                               #               pad = pads.next ()
+                               #               pad.push_event (gst.event_new_eos ())
+                               #       except:
+                               #               break
+               
+               elif message.type == gst.MESSAGE_EOS:
+                       self.stop ()
+               
+               return True
+
+mainloop = gobject.MainLoop ()
+
+def on_looper_stopped (looper):
+       mainloop.quit ()
+
+def on_looper_pos_updated (looper, position):
+       print round (position / gst.SECOND, 2)
+
+def on_looper_error (looper, error_tuple):
+       error, debug = error_tuple
+       print "\n\n%s\n\n%s\n\n" % (error, debug)
+       mainloop.quit ()
+
+if __name__ == "__main__":
+       import sys
+       if len (sys.argv) != 5:
+               print "Usage: %s <filename|uri> <start_seconds> <stop_seconds> <loop = 0|1>" % sys.argv [0]
+               sys.exit (1)
+       
+       if "://" in sys.argv [1]:
+               uri = sys.argv [1]
+       else:
+               import os.path
+               uri = "file://" + os.path.abspath (sys.argv [1])
+       
+       looper = Looper (uri)
+       
+       looper.props.start_pos = long (sys.argv [2]) * gst.SECOND
+       looper.props.stop_pos = long (sys.argv [3]) * gst.SECOND
+       looper.props.loop = int (sys.argv [4])
+       
+       looper.connect ("stopped", on_looper_stopped)
+       looper.connect ("position-updated", on_looper_pos_updated)
+       looper.connect ("error", on_looper_error)
+       
+       looper.play ()
+       mainloop.run ()