Merge lp:~brunogirin/python-snippets/gstreamer-basics into lp:~jonobacon/python-snippets/trunk

[Bruno Girin]

Added two snippets:
- stream an audio CD to standard audio output (pulse)
- stream from a webcam, scale the stream and display in a small window

Unmerged revisions

100. By Bruno Girin on 2010-04-27

Added snippets to play audio CDs and display a webcam input

=== added file 'gstreamer/cdaudio.py'
--- gstreamer/cdaudio.py	1970-01-01 00:00:00 +0000
+++ gstreamer/cdaudio.py	2010-04-27 19:42:32 +0000
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+#
+# [SNIPPET_NAME: Audio CD Streamer]
+# [SNIPPET_CATEGORIES: GStreamer]
+# [SNIPPET_DESCRIPTION: A basic streamer that plays the first five seconds of each song on an audio CD]
+# [SNIPPET_AUTHOR: Bruno Girin <[e-mail]>]
+# [SNIPPET_LICENSE: GPL]
+#
+# This snippet demonstrate the basics of playing an audio CD. In practice, it
+# uses the core code of a small application I wrote for my own use and that I
+# called Cacofonix (after the bard in the Asterix comics of course). If you
+# want a more complete example with GTK UI, grab the cacofonix code here:
+# https://launchpad.net/~brunogirin/+archive/cacofonix
+#
+
+import sys
+import time
+# gtk is used exclusively to benefit from the GTK main loop
+# This is because the GStreamer pipeline uses its own thread which means that
+# the main thread doesn't block and exits immediately; the gtk main loop is an
+# easy way to prevent this problem happening even though it is not ideal.
+# If anybody has a better way to do this, please contribute a patch.
+import gtk
+# the main import for GStreamer
+import gst
+
+class CdPlayer:
+    def __init__(self):
+        """
+        Initialise the CD player
+        """
+        # initialise a GStreamer pipeline
+        self.player = gst.Pipeline("player")
+        # create the source and sink
+        # note that you could also use the cdparanoiasrc source; cdparanoiasrc
+        # performs complex validation of the source (as the documentation puts
+        # it: 'Read audio from CD in paranoid mode') and is more CPU intensive
+        source = gst.element_factory_make("cdiocddasrc", "cd-source")
+        sink = gst.element_factory_make("pulsesink", "pulse-sink")
+        # build the pipeline
+        self.player.add(source, sink)
+        gst.element_link_many(source, sink)
+        # connect the bus's message signal to the on_message method
+        bus = self.player.get_bus()
+        bus.add_signal_watch()
+        bus.connect("message", self.on_message)
+        self.sample_time = 5
+
+    def play(self):
+        """
+        Start playing the CD as soon as the user has inserted and audio CD
+        in the drive.
+        """
+        print('Insert an audio CD in the drive and press ENTER.')
+        sys.stdin.readline()
+        self.player.set_state(gst.STATE_PLAYING)
+    
+    def on_message(self, bus, message):
+        """
+        Handle messages posted on the player's bus.
+        The most insteresting messages are TAG messages as they advise us
+        when a track starts playing and provide us with the track number and
+        count, which we use to jump forward to the next track after 5 seconds.
+        We also handle error messages to advise the user that there is a problem
+        reading from the CD.
+        """
+        t = message.type
+        if t == gst.MESSAGE_TAG:
+            taglist = message.parse_tag()
+            tags=dict([(k, taglist[k]) for k in taglist.keys()])
+            if('track-count' in tags):
+                self.track_count = tags['track-count']
+            if('track-number' in tags):
+                # if we receive a message that includes the track number, it
+                # means that the player has just started to play that track
+                # note that track_number starts at index 1
+                self.track_number = tags['track-number']
+                print('Sampling track {track_number} out of {track_count}'.format(
+                    track_number = self.track_number, track_count = self.track_count))
+                if(self.track_number < self.track_count):
+                    # if we haven't sampled all tracks yet, sleep for 5 seconds
+                    # and seek forward to the next track
+                    time.sleep(self.sample_time)
+                    # create a track format to tell seek_simple to seek by
+                    # track number
+                    format = gst.format_get_by_nick('track')
+                    # the seek_simple method expects the track number as a
+                    # 0-based index, while the track number in the message
+                    # is a 1-based index so passing track_number rather than
+                    # track_number+1 actually does the right thing
+                    self.player.seek_simple(
+                        format, gst.SEEK_FLAG_FLUSH, self.track_number)
+                else:
+                    # stop the player and ask the GTK main loop to quit after
+                    # sleeping 5 seconds to sample the last track
+                    time.sleep(self.sample_time)
+                    print('Sampled all tracks, exiting.')
+                    self.player.set_state(gst.STATE_NULL)
+                    gtk.main_quit()
+        elif t == gst.MESSAGE_ERROR:
+            print('Cannot read CD.')
+            self.play()
+
+if __name__ == "__main__":
+    cdplayer = CdPlayer()
+    cdplayer.play()
+    # we only call gtk.main() to have a main loop and prevent the application
+    # from exiting as soon as cdplayer.play() has been called
+    gtk.main()
+

=== added file 'gstreamer/webcam.py'
--- gstreamer/webcam.py	1970-01-01 00:00:00 +0000
+++ gstreamer/webcam.py	2010-04-27 19:42:32 +0000
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+#
+# [SNIPPET_NAME: Webcam Streamer]
+# [SNIPPET_CATEGORIES: GStreamer]
+# [SNIPPET_DESCRIPTION: A basic streamer that plays a webcam's video input in a window]
+# [SNIPPET_AUTHOR: Bruno Girin <[e-mail]>]
+# [SNIPPET_LICENSE: GPL]
+#
+# This snippet demonstrate the basics of streaming a webcam input to a display
+# window. This is derived from BigWhale's GStreamer tutorial:
+# http://www.twm-kd.com/computers/software/webcam-and-linux-gstreamer-tutorial/
+# And from Ptterb's post on StackOverflow:
+# http://stackoverflow.com/questions/2398958/python-qt-gstreamer
+# Note that it doesn't handle audio: this is left as an exercise for the reader.
+# BigWhale's tutorial has all the elements you need to get that to work.
+#
+
+import sys
+import time
+# gtk is used exclusively to benefit from the GTK main loop
+# This is because the GStreamer pipeline uses its own thread which means that
+# the main thread doesn't block and exits immediately; the gtk main loop is an
+# easy way to prevent this problem happening even though it is not ideal.
+# If anybody has a better way to do this, please contribute a patch.
+import gtk
+# the main import for GStreamer
+import gst
+
+class WebcamPlayer:
+    def __init__(self):
+        """
+        Initialise the Webcam player
+        """
+        # initialise a GStreamer pipeline
+        self.player = gst.Pipeline("player")
+        # create the source and sink
+        source = gst.element_factory_make("v4l2src", "webcam-source")
+        fvidscale_cap = gst.element_factory_make("capsfilter", "fvidscale_cap")
+        fvidscale_cap.set_property('caps', gst.caps_from_string('video/x-raw-yuv, width=320, height=240, framerate=30/1'))
+        sink = gst.element_factory_make("xvimagesink", "video-sink")
+        sink.set_property('force-aspect-ratio', True)
+        # build the pipeline
+        self.player.add(source, fvidscale_cap, sink)
+        gst.element_link_many(source, fvidscale_cap, sink)
+        # connect the bus's message signal to the on_message method
+        bus = self.player.get_bus()
+        bus.add_signal_watch()
+        bus.connect("message", self.on_message)
+
+    def play(self):
+        """
+        Start streaming the webcam.
+        """
+        print('A display window for your webcam should appear soon.\nClose that window to exit.')
+        self.player.set_state(gst.STATE_PLAYING)
+    
+    def on_message(self, bus, message):
+        """
+        Handle error messages posted on the player's bus.
+        """
+        t = message.type
+        if t == gst.MESSAGE_ERROR:
+            # An error is received when the display window is closed so use
+            # that to exit. Of course, that's a bit of a nasty hack and you'd
+            # want a more reliable way to exit in a real application but it
+            # will do for this example.
+            self.player.set_state(gst.STATE_NULL)
+            gtk.main_quit()
+
+if __name__ == "__main__":
+    webcamplayer = WebcamPlayer()
+    webcamplayer.play()
+    # we only call gtk.main() to have a main loop and prevent the application
+    # from exiting as soon as cdplayer.play() has been called
+    gtk.main()
+