#!/usr/bin/env python
import os
import sys
import gst
import gobject

class tag_getter:
    def __init__(self):
        #make a dictionary to hold our tag info
        self.file_tags = {}
        #make a playbin to parse the audio file
        self.pbin = gst.element_factory_make("playbin")
        #we need to receive signals from the playbin's bus
        self.bus = self.pbin.get_bus()
        #make sure we are watching the signals on the bus
        self.bus.add_signal_watch()
        #what do we do when a tag is part of the bus signal?
        self.bus.connect("message::tag", self.bus_message_tag)
        #create a loop to control our app
        self.mainloop = gobject.MainLoop()
        
    def bus_message_tag (self, bus, message):
        #we received a tag message
        taglist = message.parse_tag()
        #put the keys in the dictionary
        for key in taglist.keys():
            self.file_tags[key] = taglist[key]
        #for this test, if we have the artist tag, we can quit
        if self.file_tags['artist']:
            print self.file_tags
            sys.exit()
        
    def set_file(self,file):
        #set the uri of the playbin to our audio file
        self.pbin.set_property("uri","file://"+file)
        #pause the playbin, we don't really need to play
        self.pbin.set_state(gst.STATE_PAUSED)
        
    def run(self):
        #start the main loop
        self.mainloop.run()

if __name__=="__main__":
    if len(sys.argv)>1:
        file = sys.argv[1]
        pwd = os.getcwd()
        filepath = os.path.join(pwd,file)
        getter = tag_getter()
        getter.set_file(file)
        getter.run()

    else:
        print "select an audio file"

#!/usr/bin/env python

import sys
import gst
import time
class myPlayer ():
    def __init__(self):
        self.pipeline = gst.Pipeline()
        self.src = gst.element_factory_make("filesrc", "src")
        self.decoder = gst.element_factory_make("decodebin", "decoder")
        self.decoder.connect("new-decoded-pad", self.onNewDecodedPad)
        self.goom = gst.element_factory_make("goom")
        self.colorspace = gst.element_factory_make("ffmpegcolorspace","color")
        self.conv = gst.element_factory_make("audioconvert", "conv")
        self.vidsink = gst.element_factory_make("autovideosink","videosink")
        self.asink = gst.element_factory_make("autoaudiosink", "aoutput")
        self.tee = gst.element_factory_make('tee', "tee")
        self.queuea = gst.element_factory_make("queue", "queuea")
        self.queuev = gst.element_factory_make("queue", "queuev")
        self.pipeline.add(self.src,self.decoder,self.conv,self.tee,self.queuea)
        self.pipeline.add(self.asink,self.queuev,self.goom, self.colorspace, self.vidsink)
        gst.element_link_many(self.src,self.decoder)
        gst.element_link_many(self.conv,self.tee)
        self.tee.link(self.queuea)
        self.queuea.link(self.asink)
        self.tee.link(self.queuev)
        gst.element_link_many(self.queuev, self.goom,self.colorspace, self.vidsink)
    def onNewDecodedPad(self,decodebin, pad, islast):
        #link the pad to the converter
        decodebin.link(self.conv)
        
    def playfile(self,file):
        self.src.set_property('location', file)
        self.pipeline.set_state(gst.STATE_PLAYING)
        pipelinestate = self.pipeline.get_state()
        
        while pipelinestate[1] == gst.STATE_PLAYING:
            time.sleep(1)
            pipelinestate = self.pipeline.get_state()
        sys.exit()

if __name__ == '__main__':
    if (len(sys.argv) > 1):
        file = sys.argv[1]
        player = myPlayer()
        player.playfile(file)
    else:
        print "you must select a tune"