Juraj Kubelka

#!/usr/bin/env python
# -*- coding: utf-8 ; tab-width: 4 ; indent-tabs-mode: t -*-

# gobject
import gobject
gobject.threads_init()

# GST
import pygst
pygst.require("0.10")
import gst

class PipelineHolder:

        def __init__(self, parent, filename):
                self.parent            = parent
                self.pipeline          = self.createPipeline(filename)

        def run(self):
                self.pipeline.set_state(gst.STATE_PLAYING)

        def stop(self):
                src = self.pipeline.get_by_name('source')
                src.send_event(gst.event_new_eos())

        def getState(self):
                return self.pipeline.get_state()

        def setNewFilename(self, filename):
                self.replaceFilebinBlocked(filename)

        def destroyBin(self):
                bin = self.pipeline.get_by_name('filebin')
                bin.set_state(gst.STATE_NULL)
                return self.pipeline.remove(bin)

        def replaceFilebinBlocked(self, filename):
                element = self.pipeline.get_by_name('converter')
                oldbin = self.pipeline.get_by_name('filebin')
                srcpad = element.get_pad('src')
                sinkpad = oldbin.get_pad('binsink')
                srcpad.unlink(sinkpad)
                oldbin.send_event(gst.event_new_eos())
                oldbin.get_state()
                self.pipeline.remove(oldbin)
                self.asyncDestroyFilebin(oldbin)
                self.attachNewFilebin(filename)
                newbin = self.pipeline.get_by_name('filebin')
                newbin.get_state()
                newbin.set_state(gst.STATE_PLAYING)
                self.pipeline.get_state()
                newbin.get_state()
                self.pipeline.get_state()

        def asyncDestroyFilebin(self, filebin):
                gobject.idle_add(self.destroyFilebin, filebin)

        def destroyFilebin(self, filebin):
                filebin.set_state(gst.STATE_NULL)
                filebin.get_state()

        def attachNewFilebin(self, filename):
                bin = self.createFilebin(filename)
                self.pipeline.add(bin)
                element = self.pipeline.get_by_name('converter')
                return element.get_pad('src').link(bin.get_pad('binsink'))

        def createPipeline(self, filename):
                pipeline = gst.Pipeline('pipeline')

                src   = gst.element_factory_make('alsasrc', 'source')
                queue = gst.element_factory_make('queue', 'queue')
                conv  = gst.element_factory_make('audioconvert', 'converter')
                bin   = self.createFilebin(filename)
                pipeline.add(src, queue, conv, bin)
                if not gst.element_link_many(src, queue, conv, bin):
                        print "Failed to link elements!"

                bus = pipeline.get_bus()
                bus.add_signal_watch()
                bus.connect('message', self.on_message)
                bus.connect('message::eos', self.on_eos)
                bus.connect('message::tag', self.on_tag)
                bus.connect('message::error', self.on_error)
                return pipeline

        def createFilebin(self, filename):
                filebin = gst.Bin('filebin')

                enc   = gst.element_factory_make('vorbisenc', 'encoder')
                mux   = gst.element_factory_make('oggmux', 'multiplexer')
                file  = gst.element_factory_make('filesink', 'file')
                filebin.add(enc, mux, file)
                if not gst.element_link_many(enc, mux, file):
                        print "Failed to link elements!"
                pad = gst.GhostPad('binsink', enc.get_pad('sink'))
                filebin.add_pad(pad)
                file.set_property('location', filename)
                return filebin

        def on_message(self, bus, message):
                pass #print "on_message: ", message

        def on_eos(self, bus, message):
                print "on_eos: ", bus, message
                bus.remove_signal_watch()
                if self.pipeline.set_state(gst.STATE_NULL) != gst.STATE_CHANGE_SUCCESS:
                        print "error: cannot close pipeline properly!!!"

        def on_tag(self, bus, message):
                print "on_tag: ", bus, message

        def on_error(self, bus, msg):
                error = msg.parse_error()
                print "on_error: ", error[1]
                bus.remove_signal_watch()
                print self.pipeline.set_state(gst.STATE_NULL)
                self.parent.on_pipeline_error(self, bus, msg)